laatzen/GenesisDisplayTool/RawData.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing.Printing;
using ZedGraph;
using System.IO;

namespace GenesisDisplayTool
{
    public static partial class RawData
    {
        public static void DisplayText(String timestamp, String data, CultureInfo culture)
        {
            if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.InvokeRequired)
            {
                GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.Invoke((Action<String, String, CultureInfo>)DisplayText, timestamp, data, culture);
                return;
            }

            try
            {
                #region Display in textbox
                if (!String.IsNullOrEmpty(data))
                {
                    GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.rtB_RawData_RxData.AppendText($"{data}");
                    GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.rtB_RawData_RxData.ScrollToCaret();
                    if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.rtB_RawData_RxData.Text.Length > GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.nUD_Settings_RxDataAutoclear.Value)
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.rtB_RawData_RxData.Clear();
                    #endregion
                }
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayText() failed", $"0x{ex.HResult.ToString("X", culture)}", "first try/catch (Display in textbox)");
                return;
            }
        }
        public static void SaveText(String savePath, String timestamp, Boolean loggingEnable, String data, Int32 cyclesToStorage, CultureInfo culture)
        {

            String _data = data;


            #region Save raw data
            if (Boolean.Equals(loggingEnable, true))
            {
                try
                {
                    if (!String.IsNullOrEmpty(_data))
                    {
                        var temp = $"{ timestamp}{ _data}";
                        //   if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.RawDataToLogCounter > cyclesToStorage)
                        //   {
                        Task.Run(() =>
                        {
                            using (StreamWriter sw = File.AppendText(@savePath))
                            {
                                sw.Write(temp);
                            }
                        });
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounter(0);
                        //   }
                        //   else
                        //       GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.RawDataToLogCounter++;
                    }
                }
                catch (Exception ex)
                {   
                    ErrorLog.Log(LogErrReason.Exception(), "RawData.SaveText() failed", $"0x{ex.HResult.ToString("X", culture)}", "second try/catch (save raw data)");
                    GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawLoggingSingleMeterEnable(false);
                }
            }
            #endregion




            
        }

        public static void DisplayAndSaveRawMeter1(String rxStringDataChannel, String saveDataPathRawMeter1, String timestamp, Int32 autoclear, ref Boolean loggingEnable, ref String dataToLog, Int32 cyclesToStorage)
        {
            CultureInfo culture = GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture();

            try
            {
                #region Display in label
                String display = String.Empty;
                if (rxStringDataChannel.Count() > 20)
                    display = $"{ rxStringDataChannel.Substring(0, 20)} [...]";
                else
                    display = rxStringDataChannel;

                GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.l_RawDataMeter1.Text = display;
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter1() failed", $"0x{ex.HResult.ToString("X", culture)}", String.Empty);
                return;
            }

            #region Save raw data
            if (loggingEnable == true) //LoggingRawEn
            {
                try
                {
                    rxStringDataChannel = rxStringDataChannel.Replace("\n", String.Empty);
                    dataToLog = dataToLog + timestamp + rxStringDataChannel + "\r\n";
                    if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter1() > cyclesToStorage)
                    {       
                        String temp = dataToLog;

                        Task.Run(() =>
                        {
                            using (StreamWriter sw = File.AppendText(@saveDataPathRawMeter1))
                            {
                                sw.Write(temp);
                            }
                        });
                        dataToLog = String.Empty;
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter1(0);
                    }
                    else
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter1(GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter1() + 1);
                }
                catch (Exception ex)
                {
                    ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter1() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", "second try/catch (save raw data)");
                    loggingEnable = false; // LoggingRawEn = false;
                }
            }
            #endregion
        }

        public static void DisplayAndSaveRawMeter2(String rxStringDataChannel, String saveDataPathRawMeter2, String timestamp, Int32 autoclear, ref Boolean loggingEnable, ref String dataToLog, Int32 cyclesToStorage)
        {
            try
            {
                #region Display in label
                String display = String.Empty;
                if (rxStringDataChannel.Count() > 20)
                    display = $"{rxStringDataChannel.Substring(0, 20)} [...]";
                else
                    display = rxStringDataChannel;

                GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.l_RawDataMeter2.Text = display;
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter2() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", String.Empty);
                return;
            }

            #region Save raw data
            if (loggingEnable == true) //LoggingRawEn
            {
                try
                {
                    rxStringDataChannel = rxStringDataChannel.Replace("\n", String.Empty);
                    dataToLog = $"{dataToLog}{timestamp + rxStringDataChannel}\r\n";
                    if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter2() > cyclesToStorage)
                    {
                        
                        String temp = dataToLog;
                        Task.Run(() =>
                        {
                            using (StreamWriter sw = File.AppendText(@saveDataPathRawMeter2))
                            {
                               sw.Write(temp);
                            }
                        });
                        dataToLog = String.Empty;
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter2(0);
                    }
                    else
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter2(GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter2() + 1);
                }
                catch (Exception ex)
                {
                    ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter2() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", "second try/catch (save raw data)");
                    loggingEnable = false; // LoggingRawEn = false;
                }
            }
            #endregion
        }

        public static void DisplayAndSaveRawMeter3(String rxStringDataChannel, String saveDataPathRawMeter3, String timestamp, Int32 autoclear, ref Boolean loggingEnable, ref String dataToLog, Int32 cyclesToStorage)
        {
            try
            {
                #region Display in label
                String display = String.Empty;
                if (rxStringDataChannel.Count() > 20)
                    display = $"{rxStringDataChannel.Substring(0, 20)} [...]";
                else
                    display = rxStringDataChannel;

                GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.l_RawDataMeter3.Text = display;
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter3() failed", $"0x{ex.HResult.ToString("X")}", String.Empty);
                return;
            }

            #region Save raw data
            if (loggingEnable == true) //LoggingRawEn
            {
                try
                {
                    rxStringDataChannel = rxStringDataChannel.Replace("\n", String.Empty);
                    dataToLog = dataToLog + timestamp + rxStringDataChannel + "\r\n";
                    if (GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter3() > cyclesToStorage)
                    {
                        
                        String temp = dataToLog;
                        Task.Run(() =>
                        {
                            using (StreamWriter sw = File.AppendText(@saveDataPathRawMeter3))
                            {
                                sw.Write(temp);
                            }
                        });
                        dataToLog = String.Empty;
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter3(0);
                    }
                    else
                        GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.SetRawDataToLogCounterMeter3(GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetRawDataToLogCounterMeter3() + 1);
                }
                catch (Exception ex)
                {
                    ErrorLog.Log(LogErrReason.Exception(), "RawData.DisplayAndSaveRawMeter3() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", "second try/catch (save raw data)");
                    loggingEnable = false; // LoggingRawEn = false;
                }
            }
            #endregion
        }

        public static void Print(String inputText, Boolean setHeader, PrintDocument docToPrint, Int32 hMargin, Int32 vMargin)
        {
            #region Header
            String PrintHeader0 = "------------------------------SENSUS Hannover GmbH-----------------------------------\n\n";
            String PrintHeader1 = $" {GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.l_About_Version.Text}\n";
            String PrintHeader2 = $" {GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.l_About_Author.Text}\n";
            String PrintHeader3 = DateTime.Now.ToString(" yyyy-MM-dd/ HH:mm:ss\n");
            String PrintHeader4 = " The content of the raw data-window is shown \n";
            String PrintHeader5 = "--------------------------------------------------------------------------------------------------\n\n";
            String PrintHeader = String.Empty;
            if (setHeader)
                PrintHeader = $"{PrintHeader0}{PrintHeader1}{PrintHeader2}{PrintHeader3}{PrintHeader4}{PrintHeader5}";
            #endregion
            #region Print dialog
            PrintDocument DocToPrint = new PrintDocument();
            PrintDialog PrintDialog1 = new PrintDialog();

            PrintDialog1.AllowSomePages = true;
            PrintDialog1.ShowHelp = true;
            PrintDialog1.Document = DocToPrint;
            DialogResult Result = PrintDialog1.ShowDialog();
            #endregion
            #region Print settings
            DocToPrint.PrintPage += delegate (object sender1, PrintPageEventArgs e1)
            {
                //  e1.Graphics.DrawString(PrintHeader+RxDataBox.Text, new Font("Times New Roman", 12), new SolidBrush(Color.Black), new RectangleF(0, 0, docToPrint.DefaultPageSettings.PrintableArea.Width, docToPrint.DefaultPageSettings.PrintableArea.Height));
                e1.Graphics.DrawString(PrintHeader + inputText, new Font("Times New Roman", 12), new SolidBrush(Color.Black), new RectangleF(hMargin, vMargin, docToPrint.DefaultPageSettings.PrintableArea.Width, docToPrint.DefaultPageSettings.PrintableArea.Height));
            };
            #endregion
            #region Perform printing
            if (Result == DialogResult.OK)
            {
                try
                {
                    Task.Run(() =>
                    {
                        DocToPrint.Print();
                    });
                }
                catch (Exception ex)
                {
                    ErrorLog.Log(LogErrReason.Exception(), "RawData.Print() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", String.Empty);
                    MessageBox.Show("Printing Error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            #endregion
        }

        public static RichTextBox SetTextbox(String RxString, Int32 clearval)
        {
            RichTextBox Textbox = new RichTextBox();
            try
            {
                #region Display in textbox
                Textbox.AppendText(RxString);
                Textbox.ScrollToCaret();
                if (Textbox.Text.Length > clearval) // nUD_Settings_RxDataAutoclear.Value
                    Textbox.Clear();
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exception(), "SetTextbox() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", "first try/catch (Display in textbox)");
            }
            return Textbox;
        }

        public static void Log(String RxString, DecodedData[] decoded, String saveDataPathRaw, ref Boolean loggingRawEn)
        {
            #region Save raw data
            if (loggingRawEn) // LoggingRawEn
            {
                //Task.Run(() =>
                //{
                try
                {
                    using (StreamWriter sw = File.AppendText(@saveDataPathRaw))
                    {
                        RxString = RxString.Replace("\n", String.Empty);
                        sw.WriteLine(decoded[0].RawTimestamp + RxString);
                        //sw.Dispose();
                    }
                }
                catch (Exception ex)
                {
                    ErrorLog.Log(LogErrReason.Exception(), "Log() failed", $"0x{ex.HResult.ToString("X", GENESIS_DISPLAY_TOOL._GENESIS_DISPLAY_TOOL.GetGlobalCulture())}", "second try/catch (save raw data)");
                    loggingRawEn = false;
                }
                //});
            }
            #endregion
        }

    }
}