PortDataFileReader.cs

~~~ C# PortDataFileReader.cs

using Bartech.SGCore.Base; using Bartech.SGCore.Helpers; using Bartech.SGCore.Model.ProcessData; using System; using System.Collections.Generic; using System.IO;

namespace Bartech.SGCore.Local { [XModule("PORTDATA_FILEREADER", "Modul pro preposílání SN, které se ctou ze souboru generovaných modulem PortDataFileWriter", ModuleGroupType.Other, ModuleType.Script)] public class SGPortDataFileReader : SGModuleLocal { public SGPortDataFileReader(SGSession session) : base(session) {

    }

    string m_path;
    SGLMState m_sendDataTo = SGLMState.ResetIndex;
    Queue<string> m_fileQueueu = new Queue<string>();
    private int m_lastFileCount = -1;

    bool m_directoryAvaible = true;
    long m_lastJobID;
    public string DirectoryJobPath { get; private set; }
    public string DirectoryJobPathBackup { get; private set; }

    protected override bool OnSetParameters()
    {
        m_path = Session.SysParams.GetString(this, "Path", string.Empty, "Cesta ke složce, kde ukládá soubory modul PortDataFileWriter. Soubory se ctou z podsložek s názvem aktuálního Jobu. Všechny soubory co jsou ve složce se považují jako nezpracované");
        m_sendDataTo = Session.SysParams.GetEnum(this, "SendDataTo", SGLMState.ResetIndex, "Urcuje na jaký level se prepošle SN ze souboru. Povolené hodnoty: ResetIndex - SN je posláno na stejný level, UpLevel - SN je posláno na další level.");

        if ((m_sendDataTo != SGLMState.UpLevel) && (m_sendDataTo != SGLMState.ResetIndex))
        {
            throw new SGSysParamException("SendDataTo", LogMsg.SYSPARAM_NotInRequestedFormat, "SendDataTo", "PORTDATA_FILEREADER");
        }

        if (string.IsNullOrEmpty(m_path))
        {
            throw new SGSysParamException("Path", LogMsg.SYSPARAM_MustBeDefined, "Path", "PORTDATA_FILEREADER");
        }

        return base.OnSetParameters();
    }

    public override SGLMState HandlePortData(SGTreeModuleData mdata, SGReceivedData data)
    {
        SGLMState s = base.HandlePortData(mdata, data);

        if (mdata.LevelState == SGLevelState.Echo)
        {
            s = SGLMState.Handled;
            Message = Log(LogMsg.FILE_WaitForFile);
        }

        return s;
    }

    public override void StartLevel(SGTreeModuleData mdata)
    {
        var doJob = Session.Job.GetEffectiveDOJob();

        if (doJob.IsSelected == false)
        {
            Log(LogMsg.PORTDATAREADER_JobNeedsToBeSelected);
            return;
        }

        //job se nezmenil = nic nenastavuji
        if (m_lastJobID == doJob.JobID)
            return;

        //uložím si nový job
        m_lastJobID = doJob.JobID;

        //složka se jmenuje podle CustomerJobBD, když nahodou je prazdné tak JobBD
        var jobDirName = string.IsNullOrEmpty(doJob.CustomerBarcode) ? doJob.Barcode : doJob.CustomerBarcode;

        //nastavím si property s cestami
        this.DirectoryJobPath = PrepareDir(m_path, jobDirName);
        this.DirectoryJobPathBackup = PrepareDir(m_path, Path.Combine(jobDirName, jobDirName + "_Backup"));
    }

    public override SGLMState ModuleChecker(SGTreeModuleData mdata)
    {
        SGLMState s = base.ModuleChecker(mdata);

        //dir není dostupný
        if (CheckIsDirAvaible() == false)
            return s;

        //nacte queue
        LoadFileQueueu(this.DirectoryJobPath);

        //ve složce nebyli žadne soubory
        if (m_fileQueueu.Count == 0 || Session.ContainsData())
            return s;

        var filePath = m_fileQueueu.Dequeue();
        var resObj = HandleFile(filePath);

        if (resObj != null
            && FileHelper.BackupFile(filePath, this.DirectoryJobPathBackup, true, OnError) == true)
        {
            Session.SetNextData(Session.Data.CreateReceivedData(SGDeviceType.Scanner, resObj.Barcode));
            s = SGLMState.Handled | SGLMState.OK | m_sendDataTo; //UpLevel nebo ResetIndex
        }

        return s;
    }

    public override void Clear()
    {
        m_lastFileCount = -1;
        base.Clear();
    }

    void OnError(Exception e) => Log(LogMsg.FILE_FileBackupNotOk, e.Message);

    string PrepareDir(string path, string dirName)
    {
        string fullPath = string.Empty;

        //vytvorím si fullpath
        fullPath = Path.Combine(path, dirName);

        //když neexistuje tak založím
        if (Directory.Exists(fullPath) == false)
        {
            try
            {
                Directory.CreateDirectory(fullPath);
            }
            catch
            {
                Log(LogMsg.DIRECTORY_CreateError, $"{fullPath}, zkontrolujte oprávnení pro zapis do adresáre.");
            }
        }

        return fullPath;
    }


    FileReaderWriterDefinition HandleFile(string path)
    {
        if (string.IsNullOrEmpty(path) || File.Exists(path) == false)
            return null;

        FileReaderWriterDefinition obj = null;

        try
        {
            obj = FileReaderWriterDefinition.Deserialize(File.ReadAllText(path));
            Log(LogMsg.FILE_ReadFile, path, new FileInfo(path).Extension);
        }
        catch
        {
            Log(LogMsg.FILE_ERROR, $"Soubor {path} se nezdarilo precíst!");
            return null;
        }

        #region Stavy co by nemely nastat
        if (obj == null)
        {
            Log(LogMsg.FILE_DeserializationNotOk, path);
            return null;
        }

        if (obj.Job == null)
        {
            Log(LogMsg.FILE_NotContainJobInformation, path);
            return null;
        }

        if (obj.Job.OID != m_lastJobID)
        {
            Log(LogMsg.FILE_JobNotCorrect, path, obj.Job.JobBD, Session.Job.GetEffectiveDOJob().Barcode);
            return null;
        }
        #endregion

        obj.Reader.DateTime = Session.WorkShift.ServerTime;
        obj.Reader.WorkplaceCode = Session.WorkPlace.PlaceCode;
        obj.Reader.WorkplaceID = Session.WorkPlace.WorkPlaceID;

        var content = obj.Serialize();
        try
        {
            //prepíše soubor na aktuální hodnotu (soubor se backupne v dalším kroku)
            File.WriteAllText(path, content);
        }
        catch
        {
            Log(LogMsg.FILE_ERROR, $"Soubor {path} se nezdarilo prepsat!");
            return null;
        }

        return obj;
    }

    /// <summary>
    /// Nacítá soubory do queue, dokud není queue prázdné nenacítá další
    /// </summary>
    void LoadFileQueueu(string path)
    {
        if (m_fileQueueu.Count > 0)
            return;

        foreach (var item in Directory.EnumerateFiles(path))
        {
            m_fileQueueu.Enqueue(item);
        }

        if (m_lastFileCount != m_fileQueueu.Count)
            Log(LogMsg.FILE_FileQueue, m_fileQueueu.Count);

        m_lastFileCount = m_fileQueueu.Count;
    }

    /// <summary>
    /// Check zda je Directory avaible
    /// </summary>
    bool CheckIsDirAvaible()
    {
        //adresár je nedostupný
        if (string.IsNullOrEmpty(DirectoryJobPath)
            || Directory.Exists(DirectoryJobPath) == false)
        {
            if (m_directoryAvaible == true)
            {
                m_directoryAvaible = false;
                Message = Log(LogMsg.PORTDATAFILEREADER_ERROR_DirectoryNotAvaible, DirectoryJobPath);
            }

            return false;
        }

        return m_directoryAvaible = true;
    }
}

} ~~