CyberX8/Framework/Common/WaferHolder/WaferHolderDataService.cs

using Aitex.Core.Common;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using SciChart.Core.Utility.Mouse;
using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.WaferHolder
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class WaferHolderDataService : IWaferHolderDataService
    {
        /// <summary>
        /// 获取所有集合
        /// </summary>
        /// <returns></returns>
        public List<WaferHolderInfo> GetAllWaferHolderDatas()
        {
            return WaferHolderDataRecorder.GetAllWaferHolderDatas();
        }
        /// <summary>
        /// 根据Location获取WaferHolder信息
        /// </summary>
        /// <returns></returns>
        public WaferHolderInfo GetWaferHolderDataByLocation(string location)
        {
            return WaferHolderDataRecorder.GetWaferHolderDataByLocation(location);
        }
        /// <summary>
        /// 启用禁用
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="enable"></param>
        /// <returns></returns>
        public int UpdateWaferHolderEnable(string waferHolderId, bool enable)
        {
            WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolderInfoById(waferHolderId);
            if (waferHolderInfo != null)
            {
                waferHolderInfo.Enabled = enable;
            }
            return WaferHolderDataRecorder.UpdateWaferHolderEnable(waferHolderId, enable);
        }
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="bufferId"></param>
        /// <param name="waferHolderInfo"></param>
        /// <returns></returns>
        public int AddWaferHolderData(int bufferId, WaferHolderInfo waferHolderInfo)
        {
            int result= WaferHolderDataRecorder.AddWaferHolderData(bufferId, waferHolderInfo);
           
            if(result>0)
            {
                CreateWaferHolderWafer(waferHolderInfo,waferHolderInfo.CurrentLocation);

                WaferHolderManager.Instance.SubscribeLocation(waferHolderInfo.CurrentLocation, waferHolderInfo);
                WaferHolderManager.Instance.CreateWaferHolder(waferHolderInfo);
                LOG.WriteLog(eEvent.INFO_WINRESOURCE, "System", $"Create Wafer Shuttle {waferHolderInfo.Id}");
            }
            return result;
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="info"></param>
        /// <returns></returns>
        public int UpdateWaferHolderData(string waferHolderId, WaferHolderInfo info,bool sync)
        {
            WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolderInfoById(waferHolderId);

            if (!string.IsNullOrEmpty(waferHolderId) && waferHolderId != info.Id)
            {
                WaferHolderManager.Instance.SwitchWaferHolderId(waferHolderInfo, waferHolderInfo.CurrentLocation, info.Id);
            }
                                 
            if(waferHolderInfo!=null)
            {
                if (string.IsNullOrEmpty(info.CurrentLocation))
                {
                    WaferHolderManager.Instance.Remove(waferHolderInfo.CurrentLocation);
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferAId))
                    {
                        WaferManager.Instance.DeleteWaferById(waferHolderInfo.WaferAId);
                    }
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferBId))
                    {
                        WaferManager.Instance.DeleteWaferById(waferHolderInfo.WaferBId);
                    }
                    waferHolderInfo.CurrentLocation = "";
                    waferHolderInfo.CloneBaseInfo(info);
                    WaferHolderHistoryRecord.InsertWaferHolderRemoveHistory(waferHolderInfo.Id);
                }
                else if (string.IsNullOrEmpty(waferHolderInfo.CurrentLocation) && !string.IsNullOrEmpty(info.CurrentLocation))
                {
                    CreateWaferHolderWafer(waferHolderInfo, info.CurrentLocation);
                    waferHolderInfo.CloneBaseInfo(info);
                    WaferHolderManager.Instance.SubscribeLocation(info.CurrentLocation, waferHolderInfo);
                }
                else if (waferHolderInfo.WaferSize != info.WaferSize)
                {
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferAId))
                    {
                        UpdateWaferHolderWaferSize(waferHolderInfo.WaferAId, (WaferSize)info.WaferSize);
                    }
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferBId))
                    {
                        UpdateWaferHolderWaferSize(waferHolderInfo.WaferBId, (WaferSize)info.WaferSize);
                    }
                    waferHolderInfo.CloneBaseInfo(info);
                }
                else
                {
                    waferHolderInfo.CloneBaseInfo(info);
                }
            }
            
            if (sync)
            {
                int result= WaferHolderDataRecorder.SyncUpdateWaferHolderData(waferHolderId, waferHolderInfo);
                if (result>0)
                {
                    LOG.WriteLog(eEvent.INFO_WINRESOURCE, "System", $"Update Wafer Shuttle {waferHolderInfo}");
                    MaterialTrackerManager.Instance.UpdateModuleMaterial(waferHolderInfo.CurrentLocation);
                }
                return result;
            }
            else
            {
                WaferHolderDataRecorder.UpdateWaferHolderData(waferHolderId, waferHolderInfo);
                MaterialTrackerManager.Instance.UpdateModuleMaterial(waferHolderInfo.CurrentLocation);
                return 1;
            }
        }
        /// <summary>
        /// 更新WaferShuttle的尺寸
        /// </summary>
        /// <param name="waferId"></param>
        /// <param name="waferSize"></param>
        private void UpdateWaferHolderWaferSize(string waferId,WaferSize waferSize)
        {
            WaferInfo waferInfo = WaferManager.Instance.GetWaferByWaferId(waferId);
            if (waferInfo != null && !waferInfo.IsEmpty)
            {
                waferInfo.Size = waferSize;
            }
        }
        /// <summary>
        /// 创建WaferHolder中Wafer
        /// </summary>
        /// <param name="waferHolderInfo"></param>
        private void CreateWaferHolderWafer(WaferHolderInfo waferHolderInfo,string currentLocation)
        {
            ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), currentLocation);
            if (!string.IsNullOrEmpty(waferHolderInfo.WaferAId))
            {
                WaferManager.Instance.CreateWafer(moduleName, 0, WaferStatus.Normal, (WaferSize)waferHolderInfo.WaferSize, WaferType.Assit);
                WaferInfo waferInfo = WaferManager.Instance.GetWafer(moduleName, 0);
                waferInfo.WaferOrigin = waferHolderInfo.WaferAId;
                waferInfo.WaferID = waferHolderInfo.WaferAId;
                waferInfo.WaferType = (WaferType)waferHolderInfo.WaferAType;
                waferInfo.OriginStation = (int)moduleName;
                waferInfo.OrginalWaferHolder = waferHolderInfo.Id;
            }
            if (!string.IsNullOrEmpty(waferHolderInfo.WaferBId))
            {
                WaferManager.Instance.CreateWafer(moduleName, 1, WaferStatus.Normal, (WaferSize)waferHolderInfo.WaferSize, WaferType.Assit);
                WaferInfo waferInfo = WaferManager.Instance.GetWafer(moduleName, 1);
                waferInfo.WaferOrigin = waferHolderInfo.WaferBId;
                waferInfo.WaferID = waferHolderInfo.WaferBId;
                waferInfo.WaferType = (WaferType)waferHolderInfo.WaferBType;
                waferInfo.OriginStation = (int)moduleName;
                waferInfo.OrginalWaferHolder=waferHolderInfo.Id;
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <returns></returns>
        public int DeleteWaferHolderData(string waferHolderId)
        {
            WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolderInfoById(waferHolderId);
            int result= WaferHolderDataRecorder.DeleteWaferHolderData(waferHolderId);
            if(result>0)
            {
                if (!string.IsNullOrEmpty(waferHolderInfo.CurrentLocation))
                {
                    WaferHolderManager.Instance.Remove(waferHolderInfo.CurrentLocation);
                }
                if(!string.IsNullOrEmpty(waferHolderId))               
                {
                    WaferHolderManager.Instance.RemoveByWaferHolderId(waferHolderId);
                }
                
                if (waferHolderInfo != null)
                {
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferAId))
                    {
                        WaferManager.Instance.DeleteWaferById(waferHolderInfo.WaferAId);
                    }
                    if (!string.IsNullOrEmpty(waferHolderInfo.WaferBId))
                    {
                        WaferManager.Instance.DeleteWaferById(waferHolderInfo.WaferBId);
                    }
                }
            }
            return result;
        }
    }
}