CyberX8/Framework/Common/SubstrateTrackings/MaterialTrackerManager.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.EMMA;
using DocumentFormat.OpenXml.Vml;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.WaferHolder;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.SubstrateTrackings
{
    public class MaterialTrackerManager : Singleton<MaterialTrackerManager>
    {
        #region 内部变量
        /// <summary>
        /// 模块资源集合
        /// </summary>
        private List<ModuleMaterial> _moduleMaterials = new List<ModuleMaterial>();
        /// <summary>
        /// 模块资源(key-模块名称,value-资源)
        /// </summary>
        private Dictionary<string, ModuleMaterial> _moduleMaterialDic = new Dictionary<string, ModuleMaterial>();
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            InitialModuleMaterial(ModuleName.PUF1.ToString());
            InitialModuleMaterial(ModuleName.PUF2.ToString());
            InitialModuleMaterial(ModuleName.Loader1.ToString());
            InitialModuleMaterial(ModuleName.Transporter2.ToString());
            InitialModuleMaterial(ModuleName.Transporter1.ToString());
            InitializeModulesMaterial(BufferItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(PrewetItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(DryerItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(MetalItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(RinseItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(SrdItemManager.Instance.InstalledModules);
            InitializeData();
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitializeData()
        {
            DATA.Subscribe("System.ModuleMaterials", () => _moduleMaterials, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Buffer模块
        /// </summary>
        private void InitializeModulesMaterial(List<string> lst)
        {
            foreach (string item in lst)
            {
                InitialModuleMaterial(item);
            }
        }
        /// <summary>
        /// 初始化模块资源
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitialModuleMaterial(string moduleName)
        {
            if (Enum.TryParse(moduleName, out ModuleName module))
            {
                if (ModuleHelper.IsInstalled(module))
                {
                    ModuleMaterial moduleMaterial = new ModuleMaterial();
                    moduleMaterial.ModuleName = moduleName;
                    moduleMaterial.SideAWaferType = "";
                    moduleMaterial.SideBWaferType = "";
                    UpdateModuleMaterial(moduleMaterial, moduleName);
                    _moduleMaterialDic[moduleName] = moduleMaterial;
                    _moduleMaterials.Add(moduleMaterial);
                }
            }
        }
        /// <summary>
        /// 是否WaferHolder模块
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        private bool IsModuleWaferHolder(ModuleName moduleName)
        {
            if(ModuleHelper.IsRinse(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsMetal(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsDry(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsBuffer(moduleName))
            {
                return true;
            }
            if (moduleName == ModuleName.Transporter1 || moduleName == ModuleName.Transporter2 || 
                    moduleName == ModuleName.Loader1||moduleName==ModuleName.Prewet1)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 更新模块资源
        /// </summary>
        public void UpdateModuleMaterial(string moduleName)
        {
            if (moduleName == "Loader")
            {
                moduleName = ModuleName.Loader1.ToString();
            }
            if (_moduleMaterialDic.ContainsKey(moduleName))
            {
                ModuleMaterial moduleMaterial = _moduleMaterialDic[moduleName];
                UpdateModuleMaterial(moduleMaterial,moduleName);
            }
        }
        /// <summary>
        /// 更新模块资源
        /// </summary>
        /// <param name="moduleMaterial"></param>
        /// <param name="moduleName"></param>
        private void UpdateModuleMaterial(ModuleMaterial moduleMaterial,string moduleName)
        {
            if (Enum.TryParse(moduleName, out ModuleName module))
            {
                if (IsModuleWaferHolder(module))
                {
                    WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(moduleName);
                    if (waferHolderInfo != null)
                    {
                        moduleMaterial.WaferHolderId = waferHolderInfo.Id;
                        if(WaferManager.Instance.CheckHasWafer(module,0))
                        {
                            WaferInfo info = WaferManager.Instance.GetWafer(module, 0);
                            moduleMaterial.SideAWaferStatus =WaferManager.Instance.WaferStatusConverter(info);
                            moduleMaterial.SideAWaferId = waferHolderInfo.WaferAId;
                            WaferType waferType = (WaferType)waferHolderInfo.WaferAType;
                            moduleMaterial.SideAWaferType = waferType.ToString();
                        }
                        else
                        {
                            moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                            moduleMaterial.SideAWaferId = "";
                            moduleMaterial.SideAWaferType = "";
                        }
                        if (WaferManager.Instance.CheckHasWafer(module, 1))
                        {
                            WaferInfo info = WaferManager.Instance.GetWafer(module, 1);
                            moduleMaterial.SideBWaferStatus =WaferManager.Instance.WaferStatusConverter(info);
                            moduleMaterial.SideBWaferId = waferHolderInfo.WaferBId;
                            WaferType waferType = (WaferType)waferHolderInfo.WaferBType;
                            moduleMaterial.SideBWaferType = waferType.ToString();
                        }
                        else
                        {
                            moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                            moduleMaterial.SideBWaferId = "";
                            moduleMaterial.SideBWaferType = "";
                        }
                    }
                    else
                    {
                        moduleMaterial.WaferHolderId = "";
                        moduleMaterial.SideAWaferId = "";
                        moduleMaterial.SideBWaferId = "";
                        moduleMaterial.SideAWaferType = "";
                        moduleMaterial.SideBWaferType = "";
                        moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                        return;
                    }
                }
                else
                {
                    moduleMaterial.WaferHolderId = "";
                    if (WaferManager.Instance.CheckHasWafer(module, 0))
                    {
                        WaferInfo waferAInfo = WaferManager.Instance.GetWafer(module, 0);
                        moduleMaterial.SideAWaferStatus =WaferManager.Instance.WaferStatusConverter(waferAInfo);
                        moduleMaterial.SideAWaferId = waferAInfo.WaferID;
                        moduleMaterial.SideAWaferType = waferAInfo.WaferType.ToString();
                    }
                    else
                    {
                        moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideAWaferId = "";
                        moduleMaterial.SideAWaferType = "";
                    }
                    if (WaferManager.Instance.CheckHasWafer(module, 1))
                    {
                        WaferInfo waferBInfo = WaferManager.Instance.GetWafer(module, 1);
                        moduleMaterial.SideBWaferStatus =WaferManager.Instance.WaferStatusConverter(waferBInfo);
                        moduleMaterial.SideBWaferId = waferBInfo.WaferID;
                        moduleMaterial.SideBWaferType = waferBInfo.WaferType.ToString();
                    }
                    else
                    {
                        moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideBWaferId = "";
                        moduleMaterial.SideBWaferType = "";
                    }
                }
                
            }
        }
    }
}