using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using AMESCoreStudio.Web.Models;
using Newtonsoft.Json;
using AMESCoreStudio.WebApi;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc.Rendering;
using AMESCoreStudio.WebApi.Models.AMES;
using AMESCoreStudio.WebApi.Models.BAS;
using AMESCoreStudio.Web.ViewModels;
using AMESCoreStudio.Web.ViewModels.PCS;
using AMESCoreStudio.WebApi.DTO.AMES;
using System.Linq;
using AMESCoreStudio.CommonTools.Result;
using System;
using System.IO;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Hosting;
using System.ComponentModel.DataAnnotations;

namespace AMESCoreStudio.Web.Controllers
{
    public class PCSController : Controller
    {
        private readonly ILogger<PCSController> _logger;
        public readonly ISYS _sysApi;
        public readonly IPCS _pcsApi;
        public readonly IBAS _basApi;
        public readonly IPPS _ppsApi;
        public readonly IFileServerProvider _fileServerProvider;
        private readonly IWebHostEnvironment _env;

        public PCSController(ILogger<PCSController> logger, ISYS sysApi, IPCS pcsApi, IBAS basApi, IPPS ppsApi
            , IFileServerProvider fileServerProvider, IWebHostEnvironment env)
        {
            _logger = logger;
            _sysApi = sysApi;
            _pcsApi = pcsApi;
            _basApi = basApi;
            _ppsApi = ppsApi;
            _fileServerProvider = fileServerProvider;
            _env = env;
        }

        #region Funcion BLL


        /// <summary>
        /// 工單建立時判斷是否都有資料
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public string CheckWipInfoInsert(WipViewModel model)
        {
            string Msg = string.Empty;

            if (string.IsNullOrWhiteSpace(model.wipInfo.LineID.ToString()))
                Msg += model.wipInfo.GetAttributeFrom<DisplayAttribute>(nameof(model.wipInfo.LineID)).Name + "，";

            if (string.IsNullOrWhiteSpace(model.wipInfo.UnitNO))
                Msg += "，" + model.wipInfo.GetAttributeFrom<DisplayAttribute>(nameof(model.wipInfo.UnitNO)).Name + "，";

            if (model.wipInfo.WipDueDate == DateTime.MinValue)
                Msg += "，" + model.wipInfo.GetAttributeFrom<DisplayAttribute>(nameof(model.wipInfo.WipDueDate)).Name + "，";

            if (model.wipInfo.WipScheduleDate == DateTime.MinValue)
                Msg += "，" + model.wipInfo.GetAttributeFrom<DisplayAttribute>(nameof(model.wipInfo.WipScheduleDate)).Name + "，";

            // 序號編碼sheet


            // 系統
            if (model.wipInfo.UnitNO == "B" || model.wipInfo.UnitNO == "P" || model.wipInfo.UnitNO == "T")
            {

                Msg += CheckWipInfoInsert_WipSystem(model.wipSystem);
            }
            // 板卡
            else
            {
                Msg += CheckWipInfoInsert_WipBoard(model.wipBoard);
            }

            // 內部條碼
            if (string.IsNullOrWhiteSpace(model.wipBarcode.StartNO) != string.IsNullOrWhiteSpace(model.wipBarcode.EndNO))
            {
                Msg += "，內部序號未填完整";
            }

            // 出貨序號
            if (string.IsNullOrWhiteSpace(model.wipBarcodeOther.StartNO) != string.IsNullOrWhiteSpace(model.wipBarcodeOther.EndNO))
            {
                Msg += "，客戶序號未填完整";
            }

            // MAC
            if (string.IsNullOrWhiteSpace(model.wipMAC.StartNO) != string.IsNullOrWhiteSpace(model.wipMAC.EndNO))
            {
                Msg += "，MAC未填完整";
            }

            if (!string.IsNullOrWhiteSpace(Msg))
                Msg = "必填欄位未填寫：" + Msg.Substring(0, (Msg.Length - 1));

            return Msg;
        }

        public string CheckWipInfoInsert_WipSystem(WipSystem model)
        {
            string Msg = string.Empty;

            // 判斷預設值是否更改過，如果有就判斷必填欄位
            if (!string.IsNullOrWhiteSpace(model.BiTemperature) ||
                !string.IsNullOrWhiteSpace(model.BiTime) ||
                !string.IsNullOrWhiteSpace(model.BiMemo) ||
                !string.IsNullOrWhiteSpace(model.Checksum) ||
                !string.IsNullOrWhiteSpace(model.Cpu) ||
                !string.IsNullOrWhiteSpace(model.DmiBi) ||
                !string.IsNullOrWhiteSpace(model.Ec) ||
                !string.IsNullOrWhiteSpace(model.Fw) ||
                !string.IsNullOrWhiteSpace(model.Fw) ||
                !string.IsNullOrWhiteSpace(model.Fw1) ||
                !string.IsNullOrWhiteSpace(model.Fw2) ||
                !string.IsNullOrWhiteSpace(model.Jumper) ||
                !string.IsNullOrWhiteSpace(model.Memo) ||
                !string.IsNullOrWhiteSpace(model.OsVer) ||
                !string.IsNullOrWhiteSpace(model.PowerMode) ||
                !string.IsNullOrWhiteSpace(model.Ram))
            {
                if (string.IsNullOrWhiteSpace(model.BiTemperature))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.BiTemperature)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.BiTime))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.BiTime)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.Checksum))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.Checksum)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.Cpu))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.Cpu)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.Ram))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.Ram)).Name + "，";

            }

            return Msg;
        }

        public string CheckWipInfoInsert_WipBoard(WipBoard model)
        {
            string Msg = string.Empty;

            // 判斷預設值是否更改過，如果有就判斷必填欄位
            if (model.BiRatio != 0 ||
                model.BiosVer != 0 ||
                model.PartsBakeTime != 0 ||
                model.PcbBake != 0 ||
                !string.IsNullOrWhiteSpace(model.BiTemperature) ||
                !string.IsNullOrWhiteSpace(model.BiTime) ||
                !string.IsNullOrWhiteSpace(model.Checksum) ||
                !string.IsNullOrWhiteSpace(model.BurnLocation))
            {
                if (string.IsNullOrWhiteSpace(model.BiTemperature))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.BiTemperature)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.BiTime))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.BiTime)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.Checksum))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.Checksum)).Name + "，";

                if (string.IsNullOrWhiteSpace(model.BurnLocation))
                    Msg += model.GetAttributeFrom<DisplayAttribute>(nameof(model.BurnLocation)).Name + "，";

            }

            return Msg;
        }
        #endregion



        #region 下拉選單
        /// <summary>
        /// 產品別
        /// </summary>
        /// <returns></returns>
        private async Task GetProductType()
        {

            var result = await _pcsApi.GetProductTypes();

            var ProductTypes = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                ProductTypes.Add(new SelectListItem(result[i].ProductTypeNO + "-" + result[i].ProductTypeName, result[i].ProductTypeID.ToString()));
            }

            if (ProductTypes.Count == 0)
            {
                ProductTypes.Add(new SelectListItem("N/A", null));
            }

            ViewBag.ProductTypesList = ProductTypes;
        }

        /// <summary>
        /// 線別
        /// </summary>
        /// <returns></returns>
        private async Task GetLineInfo()
        {
            var result = await _pcsApi.GetLineInfo();

            var LineInfo = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                LineInfo.Add(new SelectListItem(result[i].LineID + "-" + result[i].LineDesc, result[i].LineID.ToString()));
            }

            if (LineInfo.Count == 0)
            {
                LineInfo.Add(new SelectListItem("N/A", null));
            }

            ViewBag.LineInfoList = LineInfo;
        }

        /// <summary>
        /// 廠別/委外廠
        /// </summary>
        /// <returns></returns>
        private async Task GetFactoryInfo()
        {
            var result = await _pcsApi.GetFactoryInfo();

            var FactoryInfo = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                FactoryInfo.Add(new SelectListItem(result[i].FactoryNo + "-" + result[i].FactoryNameCh, result[i].FactoryID.ToString()));
            }

            if (FactoryInfo.Count == 0)
            {
                FactoryInfo.Add(new SelectListItem("N/A", null));
            }

            ViewBag.FactoryInfoList = FactoryInfo;
        }

        /// <summary>
        /// 生產單位
        /// </summary>
        /// <returns></returns>
        private async Task GetFactoryUnit()
        {
            var result = await _basApi.GetFactoryUnits();

            var FactoryUnit = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                FactoryUnit.Add(new SelectListItem(result[i].UnitName, result[i].UnitNo.ToString()));
            }

            if (FactoryUnit.Count == 0)
            {
                FactoryUnit.Add(new SelectListItem("N/A", null));
            }

            ViewBag.FactoryUnitList = FactoryUnit;
        }

        /// <summary>
        /// 組件資料
        /// </summary>
        /// <returns></returns>
        private async Task GetItems()
        {
            var result = await _pcsApi.GetItems();

            var ItemsList = new List<SelectListItem>();
            ItemsList.Add(new SelectListItem("請選擇", ""));
            for (int i = 0; i < result.Count; i++)
            {
                ItemsList.Add(new SelectListItem(result[i].ItemName, result[i].ItemNo.ToString()));
            }
            ViewBag.ItemsList = ItemsList;
        }

        /// <summary>
        /// 正背面
        /// </summary>
        /// <returns></returns>
        private async Task GetMFGType()
        {
            var result = await _pcsApi.GetMFGTypes();

            var MFGType = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                MFGType.Add(new SelectListItem(result[i].MFGTypeName, result[i].MFGTypeNO.ToString()));
            }

            if (MFGType.Count == 0)
            {
                MFGType.Add(new SelectListItem("N/A", null));
            }

            ViewBag.MFGTypeList = MFGType;
        }

        /// <summary>
        /// 工單性質
        /// </summary>
        /// <returns></returns>
        private async Task GetProcessTypes()
        {
            var result = await _pcsApi.GetProcessTypes();

            var ProcessType = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                ProcessType.Add(new SelectListItem(result[i].ProcessTypeName, result[i].ProcessTypeNO.ToString()));
            }

            if (ProcessType.Count == 0)
            {
                ProcessType.Add(new SelectListItem("N/A", null));
            }

            ViewBag.ProcessTypeList = ProcessType;
        }

        /// <summary>
        /// 制令序號
        /// </summary>
        /// <returns></returns>
        private void GetWipSEQType()
        {
            var WipSEQType = new List<SelectListItem>();
            for (int i = 1; i <= 10; i++)
            {
                WipSEQType.Add(new SelectListItem(i.ToString(), i.ToString()));
            }
            ViewBag.WipSEQTypeList = WipSEQType;
        }

        /// <summary>
        /// 站別
        /// </summary>
        /// <returns></returns>
        private async Task GetStations()
        {
            var result = await _basApi.GetStationses();

            var Stations = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                Stations.Add(new SelectListItem(result[i].StationName, result[i].StationID.ToString()));
            }

            if (Stations.Count == 0)
            {
                Stations.Add(new SelectListItem("N/A", null));
            }

            ViewBag.GetStationsList = Stations;
        }

        /// <summary>
        /// 流程ID選單
        /// </summary>
        /// <returns></returns>
        private async Task GetFlowRuleList()
        {
            var result = await _basApi.GetFlowRules();

            var FlowRuleItems = new List<SelectListItem>();
            for (int i = 0; i < result.Count; i++)
            {
                FlowRuleItems.Add(new SelectListItem(result[i].FlowRuleName, result[i].FlowRuleID.ToString()));
            }

            if (FlowRuleItems.Count == 0)
            {
                FlowRuleItems.Add(new SelectListItem("N/A", null));
            }

            ViewBag.FlowRuleList = FlowRuleItems;
        }

        /// <summary>
        /// 工單狀態
        /// </summary>
        /// <returns></returns>
        private void GetWipType()
        {
            var WipType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "S:標準工單",
                    Value = "S",
                },
                new SelectListItem
                {
                    Text = "R:重工工單",
                    Value = "R",
                }
                //new SelectListItem
                //{
                //    Text = "草稿",
                //    Value = "APP",
                //}
            };

            ViewBag.GetWipTypeList = WipType;
        }



        /// <summary>
        /// 客戶類別
        /// </summary>
        /// <returns></returns>
        private void GetCustomerType()
        {
            var CustomerType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "醫療",
                    Value = "1",
                },
                new SelectListItem
                {
                    Text = "VIP",
                    Value = "2",
                },
                new SelectListItem
                {
                   Text = "其他",
                   Value = "3",
                }
            };

            ViewBag.GetCustomerTypeList = CustomerType;
        }

        /// <summary>
        /// SMD點膠
        /// </summary>
        /// <returns></returns>
        private void GetSMDType()
        {
            var SMDType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "A面全點",
                    Value = "0",
                },
                new SelectListItem
                {
                    Text = "B面全點單",
                    Value = "1",
                },
                new SelectListItem
                {
                    Text = "A面部分點膠",
                    Value = "2",
                },
                 new SelectListItem
                {
                    Text = "B面部分點膠",
                    Value = "3",
                }
                 ,
                 new SelectListItem
                {
                    Text = "不需點膠",
                    Value = "4",
                }
            };

            ViewBag.GetSMDTypeList = SMDType;
        }

        /// <summary>
        ///  DIP
        /// </summary>
        private void GetDIPType()
        {
            var DIPType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "正面",
                    Value = "正面",
                },
                new SelectListItem
                {
                    Text = "背面",
                    Value = "背面",
                }
            };

            ViewBag.GetDIPTypeList = DIPType;
        }

        /// <summary>
        /// 燒錄
        /// </summary>
        private void GetBurnType()
        {
            var BurnType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "燒錄",
                    Value = "Y",
                },
                new SelectListItem
                {
                    Text = "不需燒錄",
                    Value = "N",
                }
            };

            ViewBag.GetBurnTypeList = BurnType;
        }

        /// <summary>
        /// 零件烘烤
        /// </summary>
        private void GetPartsBakeType()
        {
            var PartsBakeType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "125℃",
                    Value = "123",
                },
                new SelectListItem
                {
                    Text = "120℃",
                    Value = "120",
                },
                new SelectListItem
                {
                    Text = "80℃",
                    Value = "80",
                },
                new SelectListItem
                {
                    Text = "60℃",
                    Value = "60",
                },
                new SelectListItem
                {
                    Text = "45℃",
                    Value = "45",
                }
            };

            ViewBag.GetPartsBakeTypeList = PartsBakeType;
        }

        /// <summary>
        /// PCB烘烤
        /// </summary>
        private void GetPCBBakeType()
        {
            var PCBBakeType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "依廠內規範",
                    Value = "0",
                },
                new SelectListItem
                {
                    Text = "125℃/2H",
                    Value = "1",
                },
                new SelectListItem
                {
                    Text = "120℃/1H(FPC)",
                    Value = "2",
                },
                new SelectListItem
                {
                    Text = "其他",
                    Value = "3",
                }
            };

            ViewBag.GetPCBBakeTypeList = PCBBakeType;
        }

        /// <summary>
        /// PCB加工
        /// </summary>
        private void GetPCBWorkingType()
        {
            var PCBWorkingType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "噴印字樣",
                    Value = "噴印字樣",
                },
                new SelectListItem
                {
                    Text = "其他",
                    Value = "其他",
                },
                new SelectListItem
                {
                    Text = "不需加工",
                    Value = "不需加工",
                }
            };

            ViewBag.GetPCBWorkingTypeList = PCBWorkingType;
        }

        /// <summary>
        /// 錫膏
        /// </summary>
        private void GetSolderPaste()
        {
            var SolderPaste = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "KOKI無鉛錫膏(S3X58-M406-3)",
                    Value = "0",
                },
                new SelectListItem
                {
                    Text = "千住無鉛錫膏(M705-221BM5-32-11.5Ka3)",
                    Value = "1",
                },
                new SelectListItem
                {
                    Text = "其他",
                    Value = "2",
                }
            };

            ViewBag.GetSolderPasteList = SolderPaste;
        }

        /// <summary>
        /// PCS List1 共用 BIOS/Checksum
        /// </summary>
        private void GetPCSList1()
        {
            var PCSList1 = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "NA",
                    Value = "NA",
                },
                new SelectListItem
                {
                    Text = "Check",
                    Value = "Check",
                },
                new SelectListItem
                {
                    Text = "Program",
                    Value = "Program",
                },
                new SelectListItem
                {
                    Text = "備註說明",
                    Value = "備註說明",
                }
            };

            ViewBag.PCSList1 = PCSList1;
        }

        /// <summary>
        /// PCS001 SOP相關下拉
        /// </summary>
        private void GetPCSOPList()
        {
            var PCSOPList = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "SOP",
                    Value = "SOP",
                },
                new SelectListItem
                {
                    Text = "技術轉移",
                    Value = "技術轉移",
                },
                new SelectListItem
                {
                    Text = "NA",
                    Value = "NA",
                },
                new SelectListItem
                {
                    Text = "暫時文件",
                    Value = "備暫時文件",
                },
                new SelectListItem
                {
                    Text = "備註說明",
                    Value = "備註說明",
                }
            };

            ViewBag.PCSOPList = PCSOPList;
        }

        /// <summary>
        /// 工單鎖定-鎖定類型
        /// </summary>
        private void GetLockType()
        {
            var LockType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "WIP",
                    Value = "WIP",
                },
                  new SelectListItem
                {
                    Text = "BAR",
                    Value = "BAR",
                }
            };

            ViewBag.GetLockTypeList = LockType;
        }

        /// <summary>
        /// 工單鎖定-鎖定原因類別
        /// </summary>
        private void GetLockReasonType()
        {
            var LockReasonType = new List<SelectListItem>(){
                new SelectListItem() {
                    Text = "3C認證工單",
                    Value = "0",
                },
                new SelectListItem
                {
                    Text = "驗證工單",
                    Value = "1",
                },
                new SelectListItem
                {
                    Text = "維修換料待分析",
                    Value = "3",
                }
            };

            //TempData["GetLockReasonTypeList"] = LockReasonType;
            ViewBag.GetLockReasonTypeList = LockReasonType;
        }
        #endregion

        #region CheckboxList
        private void GetCheckboxPrintMode(string SelectedValue = null)
        {

            List<string> values = new List<string>();
            if (SelectedValue != null)
            {
                values = SelectedValue.Split(',').ToList();
            }

            var q = Enum.GetValues(typeof(Enums.EnumPrintMode)).Cast<Enums.EnumPrintMode>()
           .Select(s => new SelectListItem
           {
               Text = Enums.GetDisplayName(s).ToString(),
               Value = s.ToString(),
               Selected = values.Where(v => v.Contains(s.ToString())).Count() != 0
           }).ToList();

            ViewBag.GetCheckboxPrintMode = q;
        }

        private void GetCheckboxApproveLogo(string SelectedValue = null)
        {
            List<string> values = new List<string>();
            if (SelectedValue != null)
            {
                values = SelectedValue.Split(',').ToList();
            }
            var q = Enum.GetValues(typeof(Enums.EnumApproveLogo)).Cast<Enums.EnumApproveLogo>()
       .Select(s => new SelectListItem
       {
           Text = Enums.GetDisplayName(s).ToString(),
           Value = s.ToString(),
           Selected = values.Where(v => v.Contains(s.ToString())).Count() != 0
       }).ToList();

            ViewBag.GetCheckboxApproveLogo = q;
        }

        private void GetCheckboxCompanyLogo(string SelectedValue = null)
        {
            List<string> values = new List<string>();
            if (SelectedValue != null)
            {
                values = SelectedValue.Split(',').ToList();
            }

            var q = Enum.GetValues(typeof(Enums.EnumCompanyLogo)).Cast<Enums.EnumCompanyLogo>()
           .Select(s => new SelectListItem
           {
               Text = Enums.GetDisplayName(s).ToString(),
               Value = s.ToString(),
               Selected = values.Where(v => v.Contains(s.ToString())).Count() != 0
           }).ToList();

            ViewBag.GetCheckboxCompanyLogo = q;
        }

        private void GetCheckboxWipAttr(string SelectedValue = null)
        {
            List<string> values = new List<string>();
            if (SelectedValue != null)
            {
                values = SelectedValue.Split(',').ToList();
            }

            var q = Enum.GetValues(typeof(Enums.EnumWipAttr)).Cast<Enums.EnumWipAttr>()
           .Select(s => new SelectListItem
           {
               Text = Enums.GetDisplayName(s).ToString(),
               Value = s.ToString(),
               Selected = values.Where(v => v.Contains(s.ToString())).Count() != 0
           }).ToList();

            ViewBag.GetCheckboxWipAttr = q;
        }
        #endregion

        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> GetWipInfoAsync()
        {
            var result = await _pcsApi.GetWipInfo();

            if (result.Count > 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result, count = result.Count });
            }
            return Json(new Table() { count = 0, data = null });
        }



        #region PCS001 工單資料維護
        public async Task<IActionResult> PCS001(WipViewModel model = null)
        {
            //await GetUnitList();
            await GetProductType();
            await GetFactoryInfo();
            await GetFactoryUnit();
            await GetLineInfo();
            await GetMFGType();
            await GetProcessTypes();
            await GetFlowRuleList();
            GetSMDType();
            GetDIPType();
            GetWipSEQType();
            GetBurnType();
            GetPartsBakeType();
            GetPCBBakeType();
            GetPCBWorkingType();
            GetSolderPaste();
            GetWipType();
            GetCustomerType();
            GetPCSList1();
            GetPCSOPList();

            GetCheckboxApproveLogo();
            GetCheckboxCompanyLogo();
            GetCheckboxPrintMode();
            GetCheckboxWipAttr();
            //var result = new WipAllViewModel();
            //return View(result);
            return View(model);
        }

        //頁面提交，id=0 添加，id>0 修改
        [HttpPost]
        public async Task<IActionResult> PCS001Async(WipViewModel model, IFormFile formFile)
        {
            #region 選單
            await GetProductType();
            await GetFactoryInfo();
            await GetFactoryUnit();
            await GetLineInfo();
            await GetMFGType();
            await GetProcessTypes();
            await GetFlowRuleList();
            GetSMDType();
            GetDIPType();
            GetWipSEQType();
            GetBurnType();
            GetPartsBakeType();
            GetPCBBakeType();
            GetPCBWorkingType();
            GetSolderPaste();
            GetWipType();
            GetCustomerType();
            GetPCSList1();
            GetPCSOPList();
            GetCheckboxApproveLogo();
            GetCheckboxCompanyLogo();
            GetCheckboxPrintMode();
            GetCheckboxWipAttr();
            #endregion

            IResultModel result;
            // Checkbox轉換
            model.wipInfo.ECNCheck = model.wipInfo.ECNCheck == "true" ? "Y" : "N";
            model.wipInfo.ModelCheck = model.wipInfo.ModelCheck == "true" ? "Y" : "N";
            model.wipInfo.InputFlag = model.wipInfo.InputFlag == "true" ? "Y" : "N";
            model.wipInfo.Priority = model.wipInfo.Priority == "true" ? "Y" : "N";
            //板卡
            model.wipBoard.DipCarrier = model.wipBoard.DipCarrier == "true" ? "Y" : "N";
            model.wipBoard.DipTape = model.wipBoard.DipTape == "true" ? "Y" : "N";
            model.wipBoard.Burn = model.wipBoard.Burn == "true" ? "Y" : "N";
            //系統
            model.wipSystem.FinePackage = model.wipSystem.FinePackage == "true" ? "Y" : "N";

            // 判斷資料填寫
            var Msg = CheckWipInfoInsert(model);


            // 判斷是否有開重複工單+生產單位
            var wipInfoQuery = await _pcsApi.GetWipInfoByWipNO(model.wipInfo.WipNO);
            if (wipInfoQuery.Any())
            {
                if (wipInfoQuery.Where(w => w.UnitNO == model.wipInfo.UnitNO).Count() != 0)
                {
                    Msg += "  同樣生產單位已建立相同工單了  ";
                }
            }

            if (!string.IsNullOrWhiteSpace(Msg))
            {
                model.wipInfo.ECNCheck = model.wipInfo.ECNCheck == "Y" ? "true" : "false";
                model.wipInfo.ModelCheck = model.wipInfo.ModelCheck == "Y" ? "true" : "false";
                model.wipInfo.InputFlag = model.wipInfo.InputFlag == "Y" ? "true" : "false";
                model.wipInfo.Priority = model.wipInfo.Priority == "Y" ? "true" : "false";
                //板卡
                model.wipBoard.DipCarrier = model.wipBoard.DipCarrier == "Y" ? "true" : "false";
                model.wipBoard.DipTape = model.wipBoard.DipTape == "Y" ? "true" : "false";
                model.wipBoard.Burn = model.wipBoard.Burn == "Y" ? "true" : "false";
                //系統
                model.wipSystem.FinePackage = model.wipSystem.FinePackage == "Y" ? "true" : "false";
                ModelState.AddModelError("error", Msg);

                return View("PCS001", model);
            }

            result = await _pcsApi.PostWipInfo(JsonConvert.SerializeObject(model.wipInfo));
            if (result.Success)
            {
                int wipID = int.Parse(result.Msg);

                // 工單屬性
                model.wipAtt.WipNO = model.wipInfo.WipNO;
                await _pcsApi.PostWipAtt(JsonConvert.SerializeObject(model.wipAtt));

                // 標籤
                model.wipLabel.ApproveLogo = model.wipLabel.ApproveLogos == null ? null : string.Join(',', model.wipLabel.ApproveLogos);
                model.wipLabel.WipNO = model.wipInfo.WipNO;
                await _pcsApi.PostWipLabel(JsonConvert.SerializeObject(model.wipLabel));

                // 新增工單Log
                WipLog wiplog = new WipLog();
                wiplog.WipID = wipID;
                wiplog.StatusNO = "N";
                wiplog.WipDesc = ".";
                await _pcsApi.PostWipLog(JsonConvert.SerializeObject(wiplog));

                // 系統
                if (model.wipInfo.UnitNO == "B" || model.wipInfo.UnitNO == "P" || model.wipInfo.UnitNO == "T")
                {
                    if (string.IsNullOrWhiteSpace(CheckWipInfoInsert_WipSystem(model.wipSystem)))
                    {
                        if (!string.IsNullOrWhiteSpace(model.wipSystem.BiTemperature))
                        {
                            model.wipSystem.ItemNo = model.wipAtt.ItemNO;
                            model.wipSystem.WipNo = model.wipInfo.WipNO;
                            await _pcsApi.PostWipSystem(JsonConvert.SerializeObject(model.wipSystem));
                        }
                    }
                }
                else
                // 板卡
                {
                    if (string.IsNullOrWhiteSpace(CheckWipInfoInsert_WipBoard(model.wipBoard)))
                    {
                        if (!string.IsNullOrWhiteSpace(model.wipBoard.BiTemperature))
                        {
                            model.wipBoard.ItemNo = model.wipAtt.ItemNO;
                            model.wipBoard.WipNo = model.wipInfo.WipNO;
                            await _pcsApi.PostWipBoard(JsonConvert.SerializeObject(model.wipBoard));
                        }
                    }
                }

                // 工單對應SOP Log
                var q = await _pcsApi.GetWipSopQuery(itemNo: model.wipAtt.ItemNO, unitNo: model.wipInfo.UnitNO, state: "Y");
                if (q.Data.Count() != 0)
                {
                    model.wipSopLog.WipSopID = q.Data.FirstOrDefault().WipSopID;
                    await _pcsApi.PostWipSopLog(JsonConvert.SerializeObject(model.wipSopLog));
                }

                // 內部條碼
                if (!string.IsNullOrWhiteSpace(model.wipBarcode.StartNO) && !string.IsNullOrWhiteSpace(model.wipBarcode.EndNO))
                {
                    model.wipBarcode.WipID = wipID;
                    model.wipBarcode.WipNO = model.wipInfo.WipNO;
                    model.wipBarcode.UnitNO = model.wipInfo.UnitNO;
                    result = await _pcsApi.PostWipBarcode(JsonConvert.SerializeObject(model.wipBarcode));

                    // 工單條碼規則設定文件檔
                    WipRule wipRule = new WipRule();
                    wipRule.WipNO = model.wipInfo.WipNO;
                    wipRule.KeyNo = "00";
                    wipRule.BarcodeLen = 14;
                    wipRule.BarcodeFormat = model.wipInfo.UnitNO;
                    result = await _pcsApi.PostWipRule(JsonConvert.SerializeObject(wipRule));
                }

                // 出貨序號
                if (!string.IsNullOrWhiteSpace(model.wipBarcodeOther.StartNO) && !string.IsNullOrWhiteSpace(model.wipBarcodeOther.EndNO))
                {
                    var type_no = await _pcsApi.GetBarcodeTypeByTypeName("客戶條碼區間");
                    if (type_no != null)
                    {
                        model.wipBarcodeOther.WipNO = model.wipInfo.WipNO;
                        model.wipBarcodeOther.TypeNO = type_no.TypeNo;
                        result = await _pcsApi.PostWipBarcodeOther(JsonConvert.SerializeObject(model.wipBarcodeOther));
                    }
                }

                // MAC
                if (!string.IsNullOrWhiteSpace(model.wipMAC.StartNO) && !string.IsNullOrWhiteSpace(model.wipMAC.EndNO))
                {
                    var mACInfo = await _pcsApi.GetMACInfo(model.wipAtt.ItemNO);
                    if (mACInfo != null)
                    {
                        model.wipMAC.WipNO = model.wipInfo.WipNO;
                        model.wipMAC.Title = mACInfo.Title;
                        model.wipMAC.ClassGroup = mACInfo.ClassGroup;
                        result = await _pcsApi.PostWipMAC(JsonConvert.SerializeObject(model.wipMAC));
                        result = await _pcsApi.PutMACInfoByClassGroup(mACInfo.ClassGroup, model.wipMAC.EndNO);
                    }
                }
            }



            if (result.Success)
            {
                var _msg = "新增成功！";
                return RedirectToAction("Refresh", "Home", new { msg = _msg });
            }
            else
            {
                if (result.Errors != null)
                {
                    ModelState.AddModelError(result.Errors[0].Id, result.Errors[0].Msg);
                }
                else
                {
                    ModelState.AddModelError("error", result.Msg);
                }
            }
            return View();
        }

        public async Task<IActionResult> PCS001R(int id)
        {

            PCS001RViewModel model = new PCS001RViewModel();
            var q = await _pcsApi.GetWipInfo(id);
            if (q.Count != 0)
            {
                model.wipInfo = q.FirstOrDefault();
                model.wipAtt = await _pcsApi.GetWipAtt(model.wipInfo.WipNO);
                model.wipBarcode = await _pcsApi.GetWipBarcode(model.wipInfo.WipNO);
                model.ruleStation = await _basApi.GetRuleStationsByFlow(model.wipInfo.FlowRuleID);
                model.ruleStation = model.ruleStation.OrderBy(o => o.Sequence);

                var q1 = await _pcsApi.GetWipSopQuery(itemNo: model.wipAtt.ItemNO);
                model.wipSop = q1.Data;
                var q2 = await _pcsApi.GetMaterialKpQuery(itemno: model.wipAtt.ItemNO);
                model.materialKp = q2.Data;

                model.wipBoard = await _pcsApi.GetWipBoard(model.wipInfo.WipNO);

                model.wipSystem = await _pcsApi.GetWipSystem(model.wipInfo.WipNO);

                model.wipMAC = await _pcsApi.GetWipMAC(model.wipInfo.WipNO);

                model.wipLabel = await _pcsApi.GetWipLabel(model.wipInfo.WipNO);

                model.wipBarcodeOther = await _pcsApi.GetWipBarcodeOther(model.wipInfo.WipNO);

            }
            await GetProductType();
            await GetFactoryInfo();
            await GetFactoryUnit();
            await GetLineInfo();
            await GetMFGType();
            await GetProcessTypes();
            await GetFlowRuleList();
            GetSMDType();
            GetDIPType();
            GetWipSEQType();
            GetBurnType();
            GetPartsBakeType();
            GetPCBBakeType();
            GetPCBWorkingType();
            GetSolderPaste();
            GetWipType();
            GetCustomerType();
            GetPCSList1();
            GetPCSOPList();
            GetCheckboxApproveLogo(model.wipLabel != null ? model.wipLabel.ApproveLogo : null);
            GetCheckboxCompanyLogo(model.wipLabel != null ? model.wipLabel.CompanyLogo : null);
            GetCheckboxPrintMode(model.wipLabel != null ? model.wipLabel.PrintMode : null);
            GetCheckboxWipAttr(model.wipLabel != null ? model.wipLabel.WipAttr : null);
            return View(model);
        }


        public async Task<JsonResult> GetMAC(string itemno, int planQTY)
        {
            var q = await _pcsApi.GetMACInfo(itemno);

            if (q != null)
            {
                // 當前值 16 進位
                var Value = q.Value;

                var Entire = new Code.Entire();

                // 最小值
                var Mix = (int.Parse(Entire.DecHex(Value, "HexToDec")) + 1);
                // 最大值
                var Max = (int.Parse(Entire.DecHex(Value, "HexToDec")) + planQTY);

                var x = new
                {
                    mix = Entire.DecHex(Mix.ToString(), "DecToHex").ToUpper(),
                    max = Entire.DecHex(Max.ToString(), "DecToHex").ToUpper(),
                };
                return Json(x);
            }
            return Json(new { _msg = "查無相關MAC對應" });
        }
        #endregion

        #region PCS004 工單條碼區間設定
        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS004()
        {
            await GetFactoryUnit();
            return View();
        }

        /// <summary>
        /// PCS004 Query
        /// </summary>
        /// <param name="unitno">生產單位</param>
        /// <param name="wipno">工單號碼</param>
        /// <returns></returns>
        public async Task<IActionResult> PCS004QueryAsync(string unitno, string wipno)
        {
            IResultModel<dynamic> result = await _pcsApi.GetWipInfoSelectParameter(unitno, wipno);

            if (result.Data != null)
            {
                return Json(new Table() { code = 0, msg = "", data = result.Data, count = 0 });
            }
            return Json(new Table() { count = 0, data = null });
        }

        //頁面提交，id=0 添加，id>0 修改
        [HttpPost]
        public async Task<IActionResult> PCS004SaveAsync(PCS004CViewModel model)
        {
            IResultModel result;
            model.WipBarcode.WipNO = model.WipInfo.WipNO;
            model.WipBarcode.WipID = model.WipInfo.WipID;
            model.WipBarcode.UnitNO = model.WipInfo.UnitNO;

            result = await _pcsApi.PostWipBarcode(JsonConvert.SerializeObject(model.WipBarcode));

            if (!result.Success)
            {
                var _msg = "新增成功！";
                return RedirectToAction("PCS004C", "PCS", new { id = model.WipInfo.WipID, msg = _msg });
            }
            else
            {
                if (result.Errors.Count > 0)
                {
                    ModelState.AddModelError(result.Errors[0].Id, result.Errors[0].Msg);
                }
                else
                {
                    ModelState.AddModelError("error", result.Msg);
                }
            }

            return RedirectToAction("PCS004C", "PCS", new { id = model.WipInfo.WipID });
        }

        public async Task<IActionResult> PCS004C(int id, string msg = null)
        {
            ViewBag.Msg = msg;
            await GetLineInfo();
            await GetFlowRuleList();
            PCS004CViewModel model = new PCS004CViewModel();
            var q = await _pcsApi.GetWipInfo(id);
            if (q.Count != 0)
            {
                model.WipInfo = q.FirstOrDefault();
                model.WipAtt = await _pcsApi.GetWipAtt(model.WipInfo.WipNO);
                model.WipBarcodes = await _pcsApi.GetWipBarcode(model.WipInfo.WipNO);
                model.RuleStation = await _basApi.GetRuleStationsByFlow(model.WipInfo.FlowRuleID);
                model.RuleStation = model.RuleStation.OrderBy(o => o.Sequence);
            }
            return View(model);
        }
        #endregion

        public async Task<JsonResult> MaterialKpQueryAsync(string itemno = null, string station = null)
        {

            IResultModel<MaterialKpDto> result = await _pcsApi.GetMaterialKpQuery(itemno: itemno, station: station);

            if (result.Data.Count() != 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result.Data, count = 0 });
            }
            return Json(new Table() { count = 0, data = null });
        }

        #region PCS005 工單資料查詢
        public IActionResult PCS005()
        {
            return View();
        }
        #endregion

        #region PCS006 工單開線收線作業
        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS006()
        {
            await GetFactoryUnit();
            return View();
        }

        /// <summary>
        /// PCS006 Query 查詢
        /// </summary>

        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS006QueryAsync(string unitno, string wipno)
        {
            // 工單基本資料
            IResultModel<dynamic> result = await _pcsApi.GetWipInfoSelectParameter(unitno, wipno);

            //if (result.Data != null)
            //{
            //    return Json(new Table() { code = 0, msg = "", data = result.Data, count = 0 });
            //}
            //return Json(new Table() { count = 0, data = null });


            // 工單狀態
            var result_StatusType = await _ppsApi.GetWipStatus();
            List<dynamic> result_dy = new List<dynamic>();
            foreach (var item in result.Data)
            {
                var itema = item;
                // 判斷是否開線資料
                var result_LineInfo = await _pcsApi.GetLineInfoByWipID((int)item.wipID);
                // 用工單ID抓最新一筆Log紀錄
                var result_Log = await _pcsApi.GetWipLog((int)item.wipID);
                result_dy.Add(new
                {
                    item.wipID,
                    item.wipNO,
                    item.itemNO,
                    item.lineID,
                    item.lineDesc,
                    item.unitName,
                    item.planQTY,
                    item.createDate,
                    result_StatusType.Where(w => w.StatusNo == (string)item.statusNO).FirstOrDefault().StatusDesc,
                    OnOff = result_LineInfo.Count() != 0 ? "ON" : "OFF",
                    ActiveStop = result_Log.StatusNO
                });
            }


            if (result_dy.Count > 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result_dy, count = result_dy.Count });
            }
            return Json(new Table() { count = 0, data = null });
        }

        [HttpPost]
        public async Task<JsonResult> PCS006ActiveStopAsync(int wipID, string statusNO, int LineID)
        {
            IActionResult result;

            WipLog wipLog = new WipLog();
            wipLog.WipID = wipID;
            wipLog.WipDesc = ".";
            wipLog.StatusNO = statusNO;

            // 當切換STOP時，強制收線
            if (statusNO == "S")
            {
                await PCS006OnOffAsync(LineID, -1);
            }

            await _pcsApi.PostWipLog(JsonConvert.SerializeObject(wipLog));
            await _pcsApi.PutWipinfoToStatusNO(wipID, statusNO);
            //if (result.)
            //{
            //    var msg = "修改失敗！";
            //    return Json(msg);
            //}
            var _msg = "修改成功！";
            return Json(_msg);
        }

        [HttpPost]
        public async Task<JsonResult> PCS006OnOffAsync(int LineID, int wipID)
        {
            IResultModel result;
            await _pcsApi.PutLineInfoToWipNO(LineID, wipID);
            var _msg = "修改成功！";
            return Json(_msg);
        }

        #endregion

        #region PCS010 工單對應站別鎖定
        public async Task<IActionResult> PCS010()
        {
            //var fileProvider = _fileServerProvider.GetProvider("/aa");
            //var fileInfo = fileProvider.GetFileInfo("/");
            await GetStations();
            GetLockReasonType();
            GetLockType();
            //var result = new WipAllViewModel();
            //return View(result);
            return View();
        }

        //[HttpPost]
        //public async Task<JsonResult> PCS010(string wipno, string locktype)
        //{
        //    ModelState.AddModelError("WipNO", "找不到相關工單");
        //    if (locktype == "WIP")
        //    {
        //        var WipInfos = await _pcsApi.GetWipInfoByWipNO(wipno);
        //        if (WipInfos.Count() == 0)
        //            ModelState.AddModelError("WipNO", "找不到相關工單");
        //    }
        //    else if (locktype == "BAR")
        //    {

        //    }

        //    return Json(wipno);
        //}

        //頁面提交，id=0 添加，id>0 修改
        [HttpPost]
        public async Task<IActionResult> PCS010Async(WipLock model, IFormFile formFile)
        {

            //if (formFile.Length > 0)
            //{
            //    var filePath = $"{_env.WebRootPath}\\PDF\\{formFile.FileName}";
            //    using (var stream = new FileStream(filePath, FileMode.Create))
            //    {
            //        await formFile.CopyToAsync(stream);
            //    }

            //    var fileProvider = _fileServerProvider.GetProvider("/aa");
            //    var fileInfo = fileProvider.GetFileInfo(formFile.FileName);
            //    using (var stream = new FileStream(fileInfo.PhysicalPath, FileMode.Create))
            //    {
            //        await formFile.CopyToAsync(stream);
            //    }
            //}


            IResultModel result;
            var q = await _pcsApi.GetWipInfoByWipNO(model.WipNO);
            if (q.Count() == 0)
                ModelState.AddModelError("error", "找不到工單號碼");


            var q1 = await _pcsApi.GetWipLockByWipNO(model.WipNO);

            if (q1.Data.Where(w => w.LockStatus == "0").Count() != 0)
            {
                ModelState.AddModelError("error", "目前此工單號碼尚未解鎖定");
            }

            if (ModelState.IsValid)
            {
                result = await _pcsApi.PostWipLock(JsonConvert.SerializeObject(model));
                if (result.Success)
                {
                    var _msg = model.WipLockID == 0 ? "新增成功！" : "修改成功！";
                    return RedirectToAction("Refresh", "Home", new { msg = _msg });
                }
                else
                {
                    ModelState.AddModelError("error", result.Msg);
                }
            }
            await GetStations();
            GetLockReasonType();
            GetLockType();
            return View(model);
        }
        #endregion

        #region PCS011 工單對應站別解鎖
        /// <summary>
        /// 
        /// </summary>
        /// <param name="id">WipLockID</param>
        /// <returns></returns>
        public async Task<IActionResult> PCS011(string id)
        {

            var q = await _pcsApi.GetWipLock(id);
            q.Data = q.Data.Where(w => w.UnLockReason == null).ToList();
            await GetStations();
            GetLockReasonType();
            GetLockType();
            //var result = new WipAllViewModel();
            //return View(result);
            return View(q.Data.FirstOrDefault());
        }

        //[HttpPost]
        //public async Task<JsonResult> PCS010(string wipno, string locktype)
        //{
        //    ModelState.AddModelError("WipNO", "找不到相關工單");
        //    if (locktype == "WIP")
        //    {
        //        var WipInfos = await _pcsApi.GetWipInfoByWipNO(wipno);
        //        if (WipInfos.Count() == 0)
        //            ModelState.AddModelError("WipNO", "找不到相關工單");
        //    }
        //    else if (locktype == "BAR")
        //    {

        //    }

        //    return Json(wipno);
        //}

        //頁面提交，id=0 添加，id>0 修改
        [HttpPost]
        public async Task<IActionResult> PCS011Async(WipLock model)
        {
            IResultModel result;

            result = await _pcsApi.PutWipLock(JsonConvert.SerializeObject(model));
            if (result.Success)
            {
                var _msg = "解鎖成功！";
                return RedirectToAction("Refresh", "Home", new { msg = _msg });
            }
            else
            {
                ModelState.AddModelError("error", result.Msg);
            }

            return View();
        }
        #endregion

        #region PCS012 製程工單鎖定查詢
        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS012()
        {


            await GetStations();
            GetLockReasonType();
            GetLockType();
            return View();
        }

        /// <summary>
        /// PCS012 Query
        /// </summary>
        /// <param name="lockStatus">工單狀態:鎖定|解鎖</param>
        /// <param name="lockType">鎖定類型</param>
        /// <param name="lockReasonType">鎖定原因類別</param>
        /// <param name="stations">站別</param>
        /// <param name="wipNO">工單</param>
        /// <param name="itemNO">料號</param>
        /// <param name="dateStr">鎖定日期起</param>
        /// <param name="dateEnd">鎖定日期迄</param>
        /// <returns></returns>
        public async Task<IActionResult> PCS012QueryAsync(string lockStatus, string lockType, string lockReasonType, string stations,
            string wipNO, string itemNO, string dateStr, string dateEnd)
        {
            IResultModel<WipLockDto> result = await _pcsApi.GetWipLockQuery(lockStatus: lockStatus, lockType: lockType, lockReasonType: lockReasonType,
                stations: stations, wipNO: wipNO, itemNO: itemNO, date_str: dateStr, date_end: dateEnd);

            if (result.Data.Count() != 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result.Data, count = 0 });
            }
            return Json(new Table() { count = 0, data = null });
        }

        #endregion

        #region PCS021 條碼輸入作業
        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS021()
        {
            await GetFactoryUnit();
            await GetLineInfo();
            return View();
        }
        #endregion

        #region PCS024組件资料维护相关

        public async Task<IActionResult> PCS024()
        {
            await GetFactoryUnit();
            return View();
        }
        //新增頁面
        public async Task<IActionResult> PCS024C(string id)
        {
            var result = await _pcsApi.GetBarcodeInfoesByNo(id);
            var tt = result[0];
            ViewBag.BarcodeID = tt.BarcodeID;
            ViewBag.WipID = tt.WipID;
            ViewBag.BarcodeNo = id;
            await GetFactoryUnit();
            //await GetStations();
            await GetItems();
            return View();
        }

        //修改页面
        [HttpGet]
        public async Task<IActionResult> PCS024UAsync(int id)
        {
            await GetItems();

            var result = await _pcsApi.GetBarcodeItem(id);

            if (result.Count == 0)
            {
                return View();
            }
            return View(result[0]);
        }

        public async Task<IActionResult> PCS024DAsync(int id)
        {
            var result = await _pcsApi.DeleteBarcodeItem(id);
            return Json(new Result() { success = true, msg = "" });
        }

        //頁面提交，id=0 添加，id>0 修改
        [HttpPost]
        public async Task<IActionResult> PCS024CSaveAsync(BarcodeItem model)
        {
            if (ModelState.IsValid)
            {
                IResultModel result;
                result = await _pcsApi.PostBarcodeItem(JsonConvert.SerializeObject(model));


                if (!result.Success)
                {
                    var _msg = "新增成功！";
                    return RedirectToAction("Refresh", "Home", new { msg = _msg });
                }
                else
                {
                    if (result.Errors.Count > 0)
                    {
                        ModelState.AddModelError(result.Errors[0].Id, result.Errors[0].Msg);
                    }
                    else
                    {
                        ModelState.AddModelError("error", result.Msg);
                    }
                }
            }
            return View("PCS024C", model);

        }

        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> GetBarcodeItemsAsync()
        {
            var result = await _pcsApi.GetBarcodeItems();

            if (result.Count > 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result, count = result.Count });
            }

            return Json(new Table() { count = 0, data = null });
        }

        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> GetBarcodeItemByUnitAsync(string ID)
        {
            string str, str1;
            var strA = ID.Split("=");
            str = strA[0];
            str1 = strA[1];
            //WO0002A10001

            if (ID is null)
                return Json(new Table() { count = 0, data = null });

            var result = await _pcsApi.GetBItemByStr(str, str1);
            //var result = await _pcsApi.GetBarcodeItemByUnit(ID);

            if (result.Count > 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result, count = result.Count });
            }

            return Json(new Table() { count = 0, data = null });
        }

        #endregion

        [ResponseCache(Duration = 0)]
        [HttpGet]
        public async Task<IActionResult> PCS030()
        {
            await GetFactoryUnit();
            return View();
        }

        /// <summary>
        /// PCS012 Query
        /// </summary>
        /// <param name="lockStatus">工單狀態:鎖定|解鎖</param>
        /// <param name="lockType">鎖定類型</param>
        /// <param name="lockReasonType">鎖定原因類別</param>
        /// <param name="stations">站別</param>
        /// <param name="wipNO">工單</param>
        /// <param name="itemNO">料號</param>
        /// <param name="dateStr">鎖定日期起</param>
        /// <param name="dateEnd">鎖定日期迄</param>
        /// <returns></returns>
        public async Task<IActionResult> PCS030QueryAsync(string itemNo, string unitNo
            , string fileName, string state, string date_str, string date_end)
        {
            IResultModel<WipSopDto> result = await _pcsApi.GetWipSopQuery(itemNo: itemNo, unitNo: unitNo
            , fileName: fileName, state: state, date_str: date_str, date_end: date_end);

            if (result.Data.Count() != 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result.Data, count = 0 });
            }
            return Json(new Table() { count = 0, data = null });
        }

        [HttpPost]
        public async Task<JsonResult> PCS030StateAsync(int wipSopID, bool state)
        {

            IResultModel result;
            if (!state)
                await _pcsApi.PutWipSop(wipSopID, "N");
            else
                await _pcsApi.PutWipSop(wipSopID, "Y");

            var _msg = "修改成功！";
            return Json(_msg);
        }

        [HttpGet]
        public async Task<IActionResult> PCS030C()
        {
            await GetFactoryUnit();
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> PCS030CAsync(WipSop model, IFormFile formFile)
        {
            string FileName = string.Empty;
            string NewName = string.Empty;
            string FilePath = string.Empty;

            //var fileProvider = _fileServerProvider.GetProvider("/aa");
            //var fileInfo = fileProvider.GetFileInfo("/");
            if (formFile != null)
            {
                if (formFile.Length > 0)
                {
                    //取得使用者上傳檔案的原始檔名
                    FileName = Path.GetFileName(formFile.FileName);
                    //取原始檔名中的副檔名
                    var fileExt = Path.GetExtension(FileName);
                    //為避免使用者上傳的檔案名稱發生重複，重新給一個亂數名稱
                    NewName = Path.GetRandomFileName() + fileExt;
                    //指定要寫入的路徑、檔名和副檔名
                    FilePath = $"\\PDF\\";//本機目錄
                    using (var stream = new FileStream(_env.WebRootPath + FilePath + NewName, FileMode.Create))
                    {
                        await formFile.CopyToAsync(stream);
                    }

                    //var fileProvider = _fileServerProvider.GetProvider("/aa");
                    //var fileInfo = fileProvider.GetFileInfo(formFile.FileName);
                    //fileInfo = fileProvider.GetFileInfo(formFile.FileName);
                    ////遠端目錄
                    //using (var stream = new FileStream(fileInfo.PhysicalPath, FileMode.Create))
                    //{
                    //    await formFile.CopyToAsync(stream);
                    //}



                    IResultModel result;
                    model.FileName = FileName;
                    model.NewName = NewName;
                    model.FilePath = FilePath;// fileInfo.PhysicalPath;

                    result = await _pcsApi.PostWipSop(JsonConvert.SerializeObject(model));
                    if (result.Success)
                    {
                        var _msg = model.WipSopID == 0 ? "新增成功！" : "修改成功！";
                        return RedirectToAction("Refresh", "Home", new { msg = _msg });
                    }
                    else
                    {
                        ModelState.AddModelError("error", result.Msg);
                    }
                }
            }
            else
            {
                ModelState.AddModelError("error", "請選擇要上傳檔案");
            }
            await GetFactoryUnit();
            return View(model);
        }

        [HttpPost]
        public JsonResult TestFunc(string number)
        {
            string hashNumber = number;
            string name = "";

            if (number == "A12345")
            {
                name = "Annie";
            };

            return Json(name);
        }

        //修改页面
        [HttpGet]
        public async Task<IActionResult> BAS001UAsync(int id)
        {
            var result = await _basApi.GetFactoryInfo(id);
            result = await _basApi.GetFactoryInfoes();

            if (result.Count > 0)
            {
                //return Json(new Table() { code = 0, msg = "", data = result, count = result.Count });
            }

            // return Json(new Table() { count = 0, data = null });
            //if (result.Count == 0)
            //{
            //    return View();
            //}
            return PartialView("~/Views/Shared/PCS/_SOPPartial", Json(new Table() { code = 0, msg = "", data = result, count = result.Count }));
        }




        [HttpGet]
        public async Task<IActionResult> SOP()
        {
            var result = await _basApi.GetFactoryInfoes();

            if (result.Count > 0)
            {
                return Json(new Table() { code = 0, msg = "", data = result, count = result.Count });
            }

            //return Json(new Table() { count = 0, data = null });

            return PartialView("_SOPPartial", Json(new Table() { count = 0, data = null }));
        }
    }

    public static class ObjectExtension
    {
        public static T GetAttributeFrom<T>(this object instance, string propertyName) where T : Attribute
        {
            var attributeType = typeof(T);
            var property = instance.GetType().GetProperty(propertyName);
            if (property == null) return default(T);
            return (T)property.GetCustomAttributes(attributeType, false).FirstOrDefault();
        }
    }
}