FurnaceELK/FrameworkLocal/Common/DataCenter/ScheduleMaintenanceDataManager.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;
using Aitex.Core.Common;
using Aitex.Core.RT.DBCore;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Vml;
using DocumentFormat.OpenXml.Wordprocessing;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.Utilities;

namespace MECF.Framework.Common.DataCenter
{
    public class ScheduleMaintenanceData
    {
        public ScheduleMaintenanceDataItem DataItem { get; private set; }

        public ScheduleMaintenanceData(string item, string unit, string path, string additionInformationName = "", string additionInformationDisplay = "", float startValue = 0, float limitValue = 0, string display = "", string maintenanceProcessing = "None",  string associationProcessRecipeName = "", string additionInformationDisplaySupplement = "")
        {
            if (string.IsNullOrEmpty(display))
                display = item;

            ScheduleMaintenanceDataManager.Instance.Subscribe(item, display, unit, startValue, limitValue, maintenanceProcessing, path, additionInformationName, additionInformationDisplay, associationProcessRecipeName, additionInformationDisplaySupplement);

            DataItem = ScheduleMaintenanceDataManager.Instance.GetItem(item);
        }
        public float SetLimitValue(float value)
        {
            return ScheduleMaintenanceDataManager.Instance.SetLimitValue(DataItem.Item, value);
        }
        public string SetMaintenanceProcessing(string value)
        {
            return ScheduleMaintenanceDataManager.Instance.SetMaintenanceProcessing(DataItem.Item, value);
        }
        public void SetValue(float value)
        {
            ScheduleMaintenanceDataManager.Instance.SetValue(DataItem.Item, value);
        }

        public void SetStartValue(float value)
        {
            ScheduleMaintenanceDataManager.Instance.SetStartValue(DataItem.Item, value);
        }
        public float GetValue()
        {
            return ScheduleMaintenanceDataManager.Instance.GetValue(DataItem.Item);
        }

        public float Increase(float additionValue = 1)
        {
            return ScheduleMaintenanceDataManager.Instance.Increase(DataItem.Item, additionValue);
        }
    }

    public class ScheduleMaintenanceDataItem
    {
        public string Unit { get; set; }
        public string Item { get; set; }
        public float CurrentValue { get; set; }
        public float StartValue { get; set; }
        public float LimitValue { get; set; }
        public string MaintenanceProcessing { get; set; }
        public string AssociationProcessRecipeName { get; set; }
        public string Display { get; set; }
        public string Path { get; set; }
        public string AdditionInformationName { get; set; }
        public string AdditionInformationDisplay { get; set; }
        public string AdditionInformationDisplaySupplement { get; set; }
    }

    public class ScheduleMaintenanceDataManager : Singleton<ScheduleMaintenanceDataManager>
    {
        private Dictionary<string, ScheduleMaintenanceDataItem> _items = new Dictionary<string, ScheduleMaintenanceDataItem>();

        public Dictionary<string, ScheduleMaintenanceDataItem> Item { get => _items; }

        private object _locker = new object();

        public ScheduleMaintenanceDataManager()
        {

        }

        public void Initialize()
        {

            try
            {
                OP.Subscribe("System.ScheduleMaintenance.SetCurrentValue", (method, args) =>
                {
                    float.TryParse(args[1].ToString(), out float value);
                    SetValue((string)args[0], value);
                    return true;
                });

                OP.Subscribe("System.ScheduleMaintenance.SetMaintenanceName", (method, args) =>
                {
                    SetMaintenanceName((string)args[0], args[1].ToString());
                    return true;
                });
                OP.Subscribe("System.ScheduleMaintenance.SetMaintenanceProcessing", (method, args) =>
                {
                    SetMaintenanceProcessing((string)args[0], args[1].ToString());
                    return true;
                });
                OP.Subscribe("System.ScheduleMaintenance.SetAssociationProcessRecipeName", (method, args) =>
                {
                    SetAssociationProcessRecipeName((string)args[0], args[1].ToString());
                    return true;
                });

                OP.Subscribe("System.ScheduleMaintenance.SetLimitValue", (method, args) =>
                {
                    float.TryParse(args[1].ToString(), out float value);
                    SetLimitValue((string)args[0], value);
                    return true;
                });

                OP.Subscribe("System.ScheduleMaintenance.SetStartValue", (method, args) =>
                {
                    float.TryParse(args[1].ToString(), out float value);
                    SetStartValue((string)args[0], value);
                    return true;
                });


                OP.Subscribe("System.ScheduleMaintenance.SetAdditionInformationDisplayName", (method, args) =>
                {
                    SetAdditionInformationDisplayName((string)args[0], args[1].ToString(), args.Length > 2 ? args[2].ToString() : "");
                    return true;
                });

                DataTable dt = DataQuery.Query("select * from \"schedule_maintenance\"");

                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    ScheduleMaintenanceDataItem item = new ScheduleMaintenanceDataItem();
                    item.Item = dt.Rows[i]["maintenance_item"].ToString();
                    item.Display = dt.Rows[i]["maintenance_display"].ToString();
                    item.Unit = dt.Rows[i]["unit"].ToString();
                    item.MaintenanceProcessing = dt.Rows[i]["maintenance_processing"].ToString();
                    item.Path = dt.Rows[i]["path"].ToString();
                    item.AdditionInformationName = dt.Rows[i]["addition_information_name"].ToString();
                    item.AdditionInformationDisplay = dt.Rows[i]["addition_information_display"].ToString();
                    item.AdditionInformationDisplaySupplement = dt.Rows[i]["addition_information_display_supplement"].ToString();
                    item.AssociationProcessRecipeName = dt.Rows[i]["association_process_recipeName"].ToString();
                    if (float.TryParse(dt.Rows[i]["current_value"].ToString(), out float value))
                        item.CurrentValue = value;
                    if (float.TryParse(dt.Rows[i]["scheduling_start_value"].ToString(), out value))
                        item.StartValue = value;
                    if (float.TryParse(dt.Rows[i]["maintenance_limit_value"].ToString(), out value))
                        item.LimitValue = value;

                    _items[item.Item] = item;
                }

            }
            catch (Exception ex)
            {
                LOG.Error("init stats data manager failed", ex);
            }
        }
        public string SetMaintenanceName(string name, string display)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} maintenanceName value, not defined item");
                    return "";
                }

                string preValue = _items[name].Display;
                _items[name].Display = display;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"maintenance_display\"='{0}'WHERE \"maintenance_item\"='{1}';", display,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} schedule maintenance maintenanceName value changed from {preValue} to {display}");

                return display;
            }
        }
        public string SetAdditionInformationDisplayName(string name, string display, string displaySupplement = "")
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} AdditionInformationDispla value, not defined item");
                    return "";
                }

                string preValue = _items[name].AdditionInformationDisplay;
                _items[name].AdditionInformationDisplay = display;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"addition_information_display\"='{0}' , \"addition_information_display_supplement\"='{2}'WHERE \"maintenance_item\"='{1}';", display,
                    name, displaySupplement);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} schedule maintenance AdditionInformationDisplay value changed from {preValue} to {display}");

                return display;
            }
        }

        public string SetAssociationProcessRecipeName(string name, string associationProcessRecipeName)
        {

            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} associationProcessRecipeName value, not defined item");
                    return "";
                }

                string preValue = _items[name].AssociationProcessRecipeName;
                _items[name].AssociationProcessRecipeName = associationProcessRecipeName;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"association_process_recipeName\"='{0}'WHERE \"maintenance_item\"='{1}';", associationProcessRecipeName,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} schedule maintenance associationProcessRecipeName value changed from {preValue} to {associationProcessRecipeName}");

                return associationProcessRecipeName;
            }
        }
        public string SetMaintenanceProcessing(string name, string maintenanceProcessing)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} maintenanceProcessing value, not defined item");
                    return "";
                }

                string preValue = _items[name].MaintenanceProcessing;
                _items[name].MaintenanceProcessing = maintenanceProcessing;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"maintenance_processing\"='{0}'WHERE \"maintenance_item\"='{1}';", maintenanceProcessing,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} schedule maintenance MaintenanceProcessing value changed from {preValue} to {maintenanceProcessing}");

                return maintenanceProcessing;
            }
        }
        public float SetLimitValue(string name, float value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} limit value, not defined item");
                    return -1;
                }

                float preValue = _items[name].LimitValue;
                _items[name].LimitValue = value;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"maintenance_limit_value\"='{0}'WHERE \"maintenance_item\"='{1}';", _items[name].LimitValue,
                    name);
                DB.Insert(sql);

                EV.PostInfoLog("System", $"{name} schedule maintenance limit value changed from {preValue} to {value}");

                return preValue;
            }
        }

        public void Terminate()
        {

        }
        public void Subscribe(string item, string display, string unit, float startValue, float limitValue, string maintenanceProcessing, string path, string additionInformationName, string additionInformationDisplay, string associationProcessRecipeName, string additionInformationDisplaySupplement)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(item))
                {
                    _items[item] = new ScheduleMaintenanceDataItem()
                    { Display = display, Item = item };
                    string executeInsert = string.Format(
                        @"Insert into ""schedule_maintenance""(""maintenance_item"",
                                                    ""maintenance_display"",
                                                    ""scheduling_start_value"",
                                                    ""maintenance_limit_value"",
                                                    ""maintenance_processing"",
                                                    ""unit"",
                                                    ""path"",
                                                    ""addition_information_name"",
                                                    ""addition_information_display"",
                                                    ""association_process_recipeName"",
                                                    ""addition_information_display_supplement""
                                                    ) values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}')",
                        item, display, startValue, limitValue, maintenanceProcessing, unit, path, additionInformationName, additionInformationDisplay, associationProcessRecipeName, additionInformationDisplaySupplement);
                    DB.Insert(executeInsert);
                }
            }
        }

        public void SetValue(string name, float value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} value, not defined item");
                    return;
                }

                _items[name].CurrentValue = value;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"current_value\"='{0}' WHERE \"maintenance_item\"='{1}';",
                    _items[name].CurrentValue,
                    name);
                DB.Insert(sql);
            }
        }
        public void SetStartValue(string name, float value)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not set {name} scheduling_start_value, not defined item");
                    return;
                }

                _items[name].StartValue = value;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"scheduling_start_value\"='{0}' WHERE \"maintenance_item\"='{1}';",
                    _items[name].StartValue,
                    name);
                DB.Insert(sql);
            }
        }

        public float GetValue(string name)
        {
            lock (_locker)
            {
                if (_items.ContainsKey(name))
                {
                    return _items[name].CurrentValue;
                }
            }

            LOG.Error($"Can not get {name} value, not defined item");

            return 0;
        }

        public ScheduleMaintenanceDataItem GetItem(string name)
        {
            lock (_locker)
            {
                if (_items.ContainsKey(name))
                {
                    return _items[name];
                }
            }

            LOG.Error($"Can not get {name} value, not defined item");

            return null;
        }
        public bool CheckHasItem(string name)
        {
            if (_items.ContainsKey(name))
                return true;
            else
                return false;
        }

        public float Increase(string name, float additionValue = 1)
        {
            lock (_locker)
            {
                if (!_items.ContainsKey(name))
                {
                    LOG.Error($"Can not increase {name} value, not defined item");
                    return -1;
                }

                _items[name].CurrentValue += additionValue;

                string sql = string.Format(
                    "UPDATE \"schedule_maintenance\" SET \"current_value\"='{0}' WHERE \"maintenance_item\"='{1}';",
                    _items[name].CurrentValue,
                    name);
                DB.Insert(sql);

                return _items[name].CurrentValue;
            }
        }

        #region 










        #endregion




    }
}