Sic.Framework/MECF.Framework.UI.Core/TrayCoating/CoatingManager.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Threading;

namespace MECF.Framework.UI.Core.TrayCoating
{
    public class CoatingManager : Singleton<CoatingManager>
    {

        private int MAX_TRAY_COUNT = 8;

        public CoatingManager()
        {
            MAX_TRAY_COUNT = SC.GetValue<int>($"TM.TrayNum");
            ThicknessCollection = new List<TrayCoatingThickness>();
            pm_TrayCoatingThickness = new TrayCoatingThickness(true);
            for (int i = 0; i < MAX_TRAY_COUNT; i++)
            {
                ThicknessCollection.Add(new TrayCoatingThickness((i + 1).ToString()));
            }
            QueryUpdate();

        }
        List<CoatingData> coatingData = new List<CoatingData>();
        public TrayCoatingThickness pm_TrayCoatingThickness { get; set; }
        public List<TrayCoatingThickness> ThicknessCollection { get; set; }
        private CoatingSqlHelp coatingSqlHelp = new CoatingSqlHelp();
        public string ThicknessCollectionData { get; set; }
        InspectCleanView inspectCleanView = new InspectCleanView();
        public void Initialize()
        {
            InitData();
        }

        private void InitData()
        {
            DATA.Subscribe("TrayCoatingData", () => GetCoatingDataJsonString());
            OP.Subscribe("CoatingManager.QueryUpdate", (string cmd, object[] args) => QueryUpdate());
            OP.Subscribe("CoatingManager.Clear", (string cmd, object[] args) => Clear(args));
            OP.Subscribe("CoatingManager.Set", (string cmd, object[] args) => Set(args));
            OP.Subscribe("CoatingManager.Grow", (string cmd, object[] args) => Grow(args));
        }

        private readonly object locker = new object();
        //打包数据源，界面更新使用
        private string GetCoatingDataJsonString()
        {
            lock (locker)
            {
                return JsonConvert.SerializeObject(coatingData);
            }

        }
        public bool QueryUpdate()//从数据库整体更新所有数据，在初始化和数据操作后更新
        {
            coatingData.Clear();
            TrayCoatingThickness _trayCoatingThickness = coatingSqlHelp.GetCoatingData("PM");
            CoatingDataUpData(pm_TrayCoatingThickness, _trayCoatingThickness);
            for (int i = 0; i < MAX_TRAY_COUNT; i++)
            {
                TrayCoatingThickness trayCoatingThickness = coatingSqlHelp.GetCoatingData((i + 1).ToString());
                CoatingDataUpData(ThicknessCollection[i], trayCoatingThickness);
            }
            return true;
        }
        private bool Clear(object[] args)//设置当前生长厚度为0，操作数据为一行
        {
            coatingSqlHelp.Cmd_Clear_Coating(args[0].ToString(), out _);
            QueryUpdate();
            return true;
        }
        private bool Set(object[] args)//设置一行数据
        {
            CoatingData coatingData = JsonConvert.DeserializeObject<CoatingData>(args[0].ToString());
            coatingSqlHelp.Cmd_Set_update(coatingData, CmdFactor(coatingData), out _);
            return true;
        }
        public bool Grow(object[] args)//Process完成后更新生长厚度，操作对象Tray PM
        {
            try
            {
                coatingSqlHelp.GrowTray(args[0].ToString(), Convert.ToDouble(args[1]), Convert.ToDouble(args[2]));
                coatingSqlHelp.GrowPM(args[3].ToString(), Convert.ToDouble(args[1]), Convert.ToDouble(args[2]));
                QueryUpdate();
                CheckIsClear(args[0].ToString());
                CheckIsClear(args[3].ToString());
                return true;
            }
            catch (Exception ex)
            {
                EV.PostInfoLog("System", $"CoatingManager.Grow_Error {ex.ToString()}");
                return false;
            }

        }

        private bool CheckIsClear(string id) //检查当前厚度是否大于设定厚度，操作对象Tray PM,需要清理时弹窗提示
        {
            string _uiShowName;
            List<string> growList;

            //拼接好要提示的内容 ，查询Coating和MAX数据
            if (id.Contains("PM"))
                _uiShowName = $"{id} 腔体 ";
            else
                _uiShowName = $"Tray盘 {id}";


            growList = coatingSqlHelp.Get_Coating_MAX(id);


            if (growList == null)
                return false;
            for (int i = 0; i < growList.Count / 2; i++)
            {
                double _coating = Convert.ToDouble(growList[i * 2]);
                double _max = Convert.ToDouble(growList[i * 2 + 1]);
                if (_coating >= _max)
                {
                    string str = $"{_uiShowName} \r\n Coating={_coating} 大于 MAX={_max}";
                    //在异步中弹窗
                    Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
                    {
                        inspectCleanView.AddToolTip(str);
                        //弹窗提示，不关闭时，文本内容递增，关闭后重新提示
                        var wins = Application.Current.Windows.OfType<InspectCleanView>().ToArray();
                        if (wins.Any())
                        {
                            foreach (InspectCleanView w in wins)
                            {
                                if (w.WindowState == WindowState.Minimized)
                                    w.WindowState = WindowState.Normal;
                                w.Show();
                                w.Activate();
                            }
                        }
                        else
                        {
                            if (!inspectCleanView.IsActive)
                            {
                                inspectCleanView = new InspectCleanView();
                                inspectCleanView.AddToolTip(str);
                                inspectCleanView.Show();
                            }
                        }
                    }));
                    return true;
                }
            }


            return true;
        }


        //Tray对象拆分成单个对象数据,方便UI层绑定使用
        private void CoatingDataUpData(TrayCoatingThickness trayCoatingThickness, TrayCoatingThickness trayCoatingThicknessFromSql)
        {
            trayCoatingThickness.Tray.Update(trayCoatingThicknessFromSql.Tray);
            trayCoatingThickness.TrayInner.Update(trayCoatingThicknessFromSql.TrayInner);
            trayCoatingThickness.RingInner.Update(trayCoatingThicknessFromSql.RingInner);
            trayCoatingThickness.RingOuter.Update(trayCoatingThicknessFromSql.RingOuter);

            coatingData.Add(trayCoatingThickness.Tray);
            coatingData.Add(trayCoatingThickness.TrayInner);
            coatingData.Add(trayCoatingThickness.RingInner);
            coatingData.Add(trayCoatingThickness.RingOuter);
        }

        //传入用户设置的Label名称，返回数据库属性名称，为拼接SQL做数据准备
        private string CmdFactor(CoatingData coatingData)
        {
            if (coatingData.Label.Contains("Tray Inner") || coatingData.Label.Contains("PM1 Major cycle"))
                return "tray_inner_number";
            else if (coatingData.Label.Contains("Ring Inner") || coatingData.Label.Contains("PM2 Minor Cycle"))
                return "ring_inner_number";
            else if (coatingData.Label.Contains("Ring Outer") || coatingData.Label.Contains("PM2 Major cycle"))
                return "ring_outer_number";
            else return "tray_number";
        }

    }
}