PortDataFileWriter.cs

*PortDataFileWriter.cs*

using Bartech.SGCore.Base;
using Bartech.SGCore.Local.DataObjects;
using Bartech.SGCore.Model;
using Bartech.SGCore.Model.ProcessData;
using System.IO;
using System.Text.RegularExpressions;

namespace Bartech.SGCore.Local
{
    [XModule("PORTDATA_FILEWRITER", "Modul pro zápis souboru na sdílený disk", ModuleGroupType.Other)]
    public class SGPortDataFileWriter : SGModuleLocal
    {
        #region Constructor
        public SGPortDataFileWriter(SGSession session)
            : base(session)
        {
            m_dataToWrite = new FileReaderWriterDefinition();
            m_escapeCharactersRegex = new Regex(@"\\|/|\*");
        }
        #endregion

        #region Private Variables
        private FileReaderWriterDefinition m_dataToWrite;
        private string m_sharedFolder;
        private string m_localFolder;
        private bool m_isSharedFolder = false;
        private Regex m_escapeCharactersRegex;
        private string m_fileName;
        private DOJob m_lastJob;
        private BusOperation m_lastOperationOverride;
        private string m_sharedFolderToWrite;
        private string m_localFolderToWrite;
        private bool m_isCustomerJobBD = false;
        private string m_escapeString = "^";
        private bool m_sharedFolderExists = false;
        private bool m_localFolderExists = false;
        #endregion

        #region Override methods
        protected override bool OnSetParameters()
        {
            bool foldersExists = true;
            m_escapeString = Session.SysParams.TryGetString(this, "EscapeString", m_escapeString, "Retezec, kterým bude nahrazen každý výskyt znaku jenž není povolen v názvu souboru.");
            m_sharedFolder = Session.SysParams.TryGetString(this, "SharedFolderPath", m_sharedFolder, "Cesta se sdíleným adresárem do kterého se mají primárne ukládat soubory.");
            m_localFolder = Session.SysParams.TryGetString(this, "LocalFolderPath", m_localFolder, "Cesta ke složce do které se mají ukládat soubory v prípade výpadku sdílené složky. Nesmí být prázdná.");
            if (string.IsNullOrEmpty(m_escapeString))
            {
                Message = Log(LogMsg.SYSPARAM_NotInRequestedFormat, "EscapeString", "PORTDATA_FILEWRITER");
                return false;
            }
            if (string.IsNullOrEmpty(m_localFolder))
            {
                Message = Log(LogMsg.SYSPARAM_NotInRequestedFormat, "LocalFolderPath", "PORTDATA_FILEWRITER");
                return false;
            }
            if (!string.IsNullOrEmpty(m_sharedFolder))
            {
                m_isSharedFolder = true;
            }
            if (!Session.IsStudioSession)
            {
                foldersExists = DirectoryCheck(m_localFolder) && (m_isSharedFolder ? DirectoryCheck(m_sharedFolder) : true);
            }

            return foldersExists && base.OnSetParameters();
        }

        public override void StartLevel(SGTreeModuleData mdata)
        {
            if ((!m_localFolderExists || (m_isSharedFolder && !m_sharedFolderExists)) || (Session.Job.GetEffectiveDOJob().JobID != m_lastJob?.JobID || Session.CycleContext.OperationOverride != m_lastOperationOverride))
            {
                m_lastJob = Session.Job.GetEffectiveDOJob();
                m_lastOperationOverride = Session.CycleContext.OperationOverride;
                SetBarcodeJob();
                SetWriteData();
                if (m_isSharedFolder)
                {
                    m_sharedFolderToWrite = Path.Combine(m_sharedFolder, m_isCustomerJobBD ? m_dataToWrite.Job.CustomerJobBD : m_dataToWrite.Job.JobBD);
                    m_sharedFolderExists = DirectoryCheck(m_sharedFolderToWrite);
                }
                m_localFolderToWrite = Path.Combine(m_localFolder, m_isCustomerJobBD ? m_dataToWrite.Job.CustomerJobBD : m_dataToWrite.Job.JobBD);
                m_localFolderExists = DirectoryCheck(m_localFolderToWrite);
                if (m_sharedFolderExists)
                {
                    int numOfFilesShared = Directory.GetFiles(m_sharedFolderToWrite).Length;
                    int numOfFilesLocal = Directory.GetFiles(m_localFolderToWrite).Length;
                    Log(LogMsg.CUSTOM_INFO_MSG, $"Zmena VO. Aktuální pocet souboru pro VO: {(m_isCustomerJobBD ? m_dataToWrite.Job.CustomerJobBD : m_dataToWrite.Job.JobBD)} ve sdílené složce: {numOfFilesShared}, v lokální složce: {numOfFilesLocal}");
                }
                else
                {
                    int numOfFilesLocal = Directory.GetFiles(m_localFolderToWrite).Length;
                    Log(LogMsg.CUSTOM_INFO_MSG, $"Zmena VO. Aktuální pocet souboru pro VO: {(m_isCustomerJobBD ? m_dataToWrite.Job.CustomerJobBD : m_dataToWrite.Job.JobBD)} v lokální složce: {numOfFilesLocal}, sdílená složka neexistuje.");
                }
            }
        }

        public override SGLMState ModuleChecker(SGTreeModuleData mdata)
        {
            m_dataToWrite.Barcode = Session.WorkPlaceSetting.InfoData.LastPartBarcode;
            m_dataToWrite.Writer.DateTime = Session.WorkShift.ServerTime;
            m_fileName = EscapeBarcode(m_dataToWrite.Barcode) + "_" + m_dataToWrite.Writer.DateTime.ToString("dd-MM-yyyy_HH-mm-ss") + ".txt";
            if (m_isSharedFolder) // sdilena slozka byla zadana
            {
                if (!PrepareForFileWrite(m_fileName, m_sharedFolderToWrite, m_dataToWrite.Serialize())) // pokus o zápis do sdílené složky
                {
                    PrepareForFileWrite(m_fileName, m_localFolderToWrite, m_dataToWrite.Serialize());
                }
            }
            else // sdilena slozka nebyla zadana
            {
                PrepareForFileWrite(m_fileName, m_localFolderToWrite, m_dataToWrite.Serialize());
            }
            return SGLMState.Handled | SGLMState.UpLevel;
        }

        public override bool IsQuickModul(SGTreeModuleData mdata)
        {
            return base.IsQuickModul(mdata);
        }

        public override void Clear()
        {
            m_lastJob?.Clear();
            m_lastOperationOverride?.Clear();

            base.Clear();
        }
        #endregion

        #region Helper functions
        private bool DirectoryCheck(string filePath)
        {
            if (!Directory.Exists(filePath))
            {
                try
                {
                    Directory.CreateDirectory(filePath);
                }
                catch
                {
                    Message = Log(LogMsg.DIRECTORY_CreateError, $"{filePath}, zkontrolujte oprávnení pro zapis do adresáre.");
                    return false;
                }

                if (!Directory.Exists(filePath))
                {
                    Message = Log(LogMsg.DIRECTORY_CreateError, $"{filePath}, zkontrolujte oprávnení pro zapis do adresáre.");
                    return false;
                }
            }
            return true;
        }

        private string EscapeBarcode(string originalBarcode)
        {
            if (m_escapeCharactersRegex.IsMatch(originalBarcode))
            {
                return m_escapeCharactersRegex.Replace(originalBarcode, m_escapeString);
            }
            return originalBarcode;
        }

        private void SetBarcodeJob()
        {
            m_dataToWrite.Job.OID = m_lastJob.JobID;
            m_dataToWrite.Job.JobBD = m_lastJob.Barcode;
            m_dataToWrite.Job.CustomerJobBD = m_lastJob.CustomerBarcode ?? string.Empty;
            m_isCustomerJobBD = !string.IsNullOrEmpty(m_dataToWrite.Job.CustomerJobBD);
        }

        private void SetWriteData()
        {
            m_dataToWrite.Writer.WorkplaceID = Session.WorkPlace.WorkPlaceID;
            m_dataToWrite.Writer.WorkplaceCode = Session.WorkPlace.PlaceCode;
        }

        private bool PrepareForFileWrite(string fileName, string directoryPath, string content)
        {
            if (!Directory.Exists(directoryPath))
            {
                Message = Log(LogMsg.PORTDATAFILEWRITER_DirectoryNotFoundOrNotAvailableFileCannotBeCreated, directoryPath, fileName);
                return false;
            }

            return FileWrite(fileName, directoryPath, content);
        }

        private bool FileWrite(string fileName, string directoryPath, string content)
        {
            try
            {
                using (StreamWriter outputFile = new StreamWriter(Path.Combine(directoryPath, fileName)))
                {
                    outputFile.WriteLine(content);
                }
                int numOfFilesInDirectory = Directory.GetFiles(directoryPath).Length;
                Message = Log(LogMsg.FILE_CreateOk, fileName, $"{directoryPath}. Pocet souboru ve složce je {numOfFilesInDirectory}");
            }
            catch
            {
                Message = Log(LogMsg.FILE_CreateError, fileName, directoryPath);
                return false;
            }
            return true;
        }
        #endregion
    }
}