Пример #1
0
        private void ExportPOProjection(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, int row)
        {
            SortedDictionary<DateTime, float> dictList = new SortedDictionary<DateTime, float>(new IDateTimeDecreaseComparer());

            Dictionary<int, float> dictProj = new Dictionary<int, float>();
            UDFunction.ConvertStringToPromisedDate(POPromisedDateList(wipItemNeed), dictList);
            int dateDiff = 0;

            foreach (KeyValuePair<DateTime, float> kvp in dictList)
            {
                DateTime pDate = (DateTime)kvp.Key;
                float pQty = (float)kvp.Value;
                TimeSpan span = pDate.Subtract(DateTime.Today.AddDays(-1));
                dateDiff = span.Days;

                if (dateDiff < 0)
                    dateDiff = 0;

                if (dateDiff > TOTALDAY)
                    dateDiff = TOTALDAY;

                if (dictProj.ContainsKey(dateDiff))
                    dictProj[dateDiff] = dictProj[dateDiff] + pQty;
                else
                    dictProj.Add(dateDiff, pQty);
            }

            foreach (KeyValuePair<int, float> kvp in dictProj)
            {
                xlSht.Cells[row, COL_STARTDAY + kvp.Key] = kvp.Value;
            }
        }
Пример #2
0
        private void ListBezelRingToWIPSummary(Excel.Worksheet xlSht, int row, int col, WIPItemNeed wipItemNeed)
        {
            xlSht.Cells[row, col] = wipItemNeed.Item.ItemNo;
            xlSht.Cells[row, col + 1] = wipItemNeed.NeedQty;
            xlSht.Cells[row, col + 2] = wipItemNeed.WHQty + wipItemNeed.WHQAQty;

            ListWipItemNeedtoWIPSummary(xlSht, row, col, wipItemNeed);
        }
Пример #3
0
        public WIPItemNeed(Session session, WIPItemNeed wipItemNeed, BomLine bLine)
            : base(session)
        {
            ParentItemNeed = wipItemNeed;
            WIPTable = wipItemNeed.WIPTable;
            SalesOrderLine = wipItemNeed.SalesOrderLine;
            Item = bLine.BomItem;
            ItemSource = bLine.LineType;
            Level = wipItemNeed.Level + 1;

            if (SalesOrderLine.SaleOrderLine.OrderType.WareHouse != null)
                WareHouse = SalesOrderLine.SaleOrderLine.OrderType.WareHouse;
            else
                WareHouse = bLine.Warehouse;

            VariableScrap = bLine.VariableScrap;
            ConstantScrap = bLine.ConstantScrap;
            Qty = bLine.Qty;
            PerSeries = bLine.PerSeries;
            NeedQty = wipItemNeed.LackQty;
            NeedDate = wipItemNeed.NeedDate.AddDays(-1);
            CheckOrderTypeScrap();
            calcSubItemNeedQty();

            SetSortKey();

            WIPItemNeed childItemNeed = this;

            if (ItemSource == Item.ItemSource.Make)
            {
                RouteLine rLine = Item.GetLastRouteLine();

                if (rLine != null)
                {
                    RouteLine = CWIPRouteLine(rLine);

                    RouteLine PreviousRLine = rLine.GetPreviousRoute();

                    if (PreviousRLine != null)
                    {
                        WIPItemNeed childWipItemNeed = new WIPItemNeed(Session, this, PreviousRLine, ref childItemNeed);
                        childWipItemNeed.Save();
                    }
                    else
                    {
                        IsCheckWH = true;
                    }
                }

                InitBomItemNeed(childItemNeed);
            }
            else
            {
                IsCheckWH = true;
            }
        }
Пример #4
0
        private void ListFirstLevelItemNeedToMainSheet(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, ref int row)
        {
            try
            {
                FirstBomRow = true;
                ListSOInfo(wipItemNeed, xlSht, ref row);

                xlSht.Cells[row, COL_ONTIME] = "";

                xlSht.Cells[row, COL_SOLACK] = wipItemNeed.SalesOrderLine.SaleOrderLine.BalQty;
                xlSht.Cells[row, COL_READYSHIP] = wipItemNeed.SalesOrderLine.SaleOrderLine.ReadyShipQty;
                xlSht.Cells[row, COL_READYA] = wipItemNeed.ReadyQty;
                xlSht.Cells[row, COL_WHQTY] = wipItemNeed.WHQty;

                ListRoute(wipItemNeed, xlSht, ref row);
            }
            catch
            {
                Logger.For(this).Error(string.Format("列出主页时有问题.  行号 : {0}, \n 销售单 :{1}, 产品编码 : {2}, Level {3}, SubLevel {4} ",
                    row, wipItemNeed.SalesOrderLine.SaleOrderLine.OrderLineIndex, wipItemNeed.Item.ItemNo, wipItemNeed.Level, wipItemNeed.SubLevel));
            }
        }
Пример #5
0
        private void ListWipItemNeedtoWIPSummary(Excel.Worksheet xlSht, int row, int col, WIPItemNeed wipItemNeed)
        {
            foreach (WIPItemNeed childNeed in wipItemNeed.ChildItemNeed)
            {
                ListWipItemNeedtoWIPSummary(xlSht, row, col, childNeed);
            }

            if (wipItemNeed.ItemSource == Item.ItemSource.Make)
            {
                switch (wipItemNeed.RouteLine.WorkOper.Name)
                {
                    case "电镀":        // "电镀";
                    case "电染":
                        if (wipItemNeed.Level == 2 && wipItemNeed.SubLevel == 1)
                        {
                            xlSht.Cells[row, col + 4] = wipItemNeed.WIPQty + wipItemNeed.ReadyQty;
                        }
                        else
                        {
                            xlSht.Cells[row, col + 4] = wipItemNeed.WIPQty + wipItemNeed.ReadyQty + wipItemNeed.WHQAQty + wipItemNeed.WHQty;
                        }
                        break;

                    case "钢机加打磨":  // "机加打磨";
                    case "铜机加打磨":
                        xlSht.Cells[row, col + 5] = wipItemNeed.WIPQty;
                        if (wipItemNeed.Level == 2 && wipItemNeed.SubLevel == 1)
                        {
                            xlSht.Cells[row, col + 6] = wipItemNeed.ReadyQty ;
                        }
                        else
                        {
                            xlSht.Cells[row, col + 6] = wipItemNeed.ReadyQty + wipItemNeed.WHQAQty + wipItemNeed.WHQty;
                        }
                        xlSht.Cells[row, col + 7] = wipItemNeed.LackQty;

                        break;

                    default:          // "其他工序数"
                        if (wipItemNeed.Level == 2 && wipItemNeed.SubLevel == 1)
                        {
                            xlSht.Cells[row, col + 3] = ExcelHelper.GetCellFloatValue(xlSht, row, col + 3) + wipItemNeed.WIPQty + wipItemNeed.ReadyQty;
                        }
                        else
                        {
                            xlSht.Cells[row, col + 3] = ExcelHelper.GetCellFloatValue(xlSht, row, col + 3) + wipItemNeed.WIPQty + wipItemNeed.WHQty + wipItemNeed.WHQAQty + wipItemNeed.ReadyQty;
                        }
                        break;
                }
            }
        }
Пример #6
0
        private void GetWHQty(WIPItemNeed wipItemNeed)
        {
            WIPWHTotal wipWHTotal = GetWHTotal(wipItemNeed.Item.ItemNo, wipItemNeed.WareHouse);

            if (wipWHTotal != null)
                wipWHTotal.calcWipItemNeed(wipItemNeed);
        }
Пример #7
0
 private void initWIPItemNeed()
 {
     foreach (WIPSalesOrderLine soLine in soLines)
     {
         WIPItemNeed wipItemNeed = new WIPItemNeed(uow, soLine, wipTable);
         wipItemNeed.Save();
     }
 }
Пример #8
0
        private void GetProdRouteQty(WIPItemNeed wipItemNeed)
        {
            string key = String.Format("{0}_{1}", wipItemNeed.Item.ItemNo, wipItemNeed.RouteLine.WorkOper.Name);

            if (dictProdRoute.ContainsKey(key))
            {
                XPCollection<WIPProdRoute> wipProdRoutes = dictProdRoute[key];

                for (int i = 0; i < wipProdRoutes.Count; i++)
                {
                    WIPProdRoute wipProdRoute = wipProdRoutes[i];

                    if (wipProdRoute.BalQty > 0 && wipItemNeed.LackQty > 0)
                    {
                        float tmpQty;

                        if (wipProdRoute.BalQty > wipItemNeed.LackQty)
                            tmpQty = wipItemNeed.LackQty;
                        else
                            tmpQty = wipProdRoute.BalQty;

                        WIPItemNeedDetail needDetail = new WIPItemNeedDetail(uow, wipItemNeed);
                        needDetail.WIPProdRoute = wipProdRoute;
                        needDetail.UsedQty = tmpQty;
                        needDetail.NeedDetailType = WIPItemNeedDetail.DetailType.Production;

                        wipItemNeed.WIPQty = wipItemNeed.WIPQty + tmpQty;
                        wipItemNeed.calcSubItemNeedQty();
                        wipItemNeed.Save();
                        wipProdRoute.UsedQty = wipProdRoute.UsedQty + tmpQty;
                        wipProdRoute.Save();
                    }
                }
            }
        }
Пример #9
0
        private void GetPoQty(WIPItemNeed wipItemNeed)
        {
            string key = wipItemNeed.Item.ItemNo;

            if (dictPoLine.ContainsKey(key))
            {
                XPCollection<WIPPurchOrderLine> wipPoLines = dictPoLine[key];

                #region // Get WHQAQty - PurchLine QA Qty

                foreach (WIPPurchOrderLine wipPoLine in wipPoLines)
                {
                    if (wipPoLine.QABalQty > 0 && wipItemNeed.LackQty > 0)
                    {
                        float tmpQty;

                        if (wipPoLine.QABalQty > wipItemNeed.LackQty)
                            tmpQty = wipItemNeed.LackQty;
                        else
                            tmpQty = wipPoLine.QABalQty;

                        WIPItemNeedDetail needDetail = new WIPItemNeedDetail(uow, wipItemNeed);
                        needDetail.WIPPurchOrderLine = wipPoLine;
                        needDetail.UsedQty = tmpQty;
                        needDetail.NeedDetailType = WIPItemNeedDetail.DetailType.QA;

                        wipItemNeed.WHQAQty = wipItemNeed.WHQAQty + tmpQty;
                        wipItemNeed.calcSubItemNeedQty();
                        wipItemNeed.Save();
                        wipPoLine.QAUsedQty = wipPoLine.QAUsedQty + tmpQty;
                        wipPoLine.Save();
                    }
                }

                #endregion

                #region // Get WIPQty - PurchLine ordered qty
                foreach (WIPPurchOrderLine wipPoLine in wipPoLines)
                {
                    if (wipPoLine.BalQty > 0 && wipItemNeed.LackQty > 0)
                    {
                        float tmpQty;

                        if (wipPoLine.BalQty > wipItemNeed.LackQty)
                            tmpQty = wipItemNeed.LackQty;
                        else
                            tmpQty = wipPoLine.BalQty;

                        WIPItemNeedDetail needDetail = new WIPItemNeedDetail(uow, wipItemNeed);
                        needDetail.WIPPurchOrderLine = wipPoLine;
                        needDetail.Projection = wipPoLine.GetProjection(tmpQty);

                        needDetail.UsedQty = tmpQty;
                        needDetail.NeedDetailType = WIPItemNeedDetail.DetailType.Purch;

                        wipItemNeed.WIPQty = wipItemNeed.WIPQty + tmpQty;
                        wipItemNeed.calcSubItemNeedQty();
                        wipItemNeed.Save();
                        wipPoLine.UsedQty = wipPoLine.UsedQty + tmpQty;
                        wipPoLine.Save();
                    }
                }
                #endregion
            }
        }
Пример #10
0
        public WIPItemNeed(Session session, WIPSalesOrderLine soLine, WIPTable wipTable)
            : base(session)
        {
            WIPTable = wipTable;
            SalesOrderLine = soLine;
            Item = soLine.SaleOrderLine.Item;
            ItemSource = Item.Source;
            IsEnableCalcQty = true;
            NeedDate = soLine.SaleOrderLine.NeedDate;
            NeedQty = soLine.BalQty - soLine.ReadyShipQty;
            WareHouse = soLine.SaleOrderLine.WareHouse;
            calcSubItemNeedQty();
            Level = 1;
            SubLevel = 1;
            SetSortKey();

            // childItemNeed 的用途是取得最先那个真正要用的RouteLine的WIPItemNeed.
            // 例 : P <= M 时, P为最后的RouteLine, 但它是取M的, 所以是M的WIPItemNeed才需要找Bom作为DictChildItemNeed
            // 而 P的ChildItemNeed只是M.
            WIPItemNeed childItemNeed = this;

            if (ItemSource == Item.ItemSource.Make)
            {
                RouteLine rLine = Item.GetLastRouteLine();

                if (rLine != null)
                {
                    RouteLine = CWIPRouteLine(rLine);
                    RouteLine PreviousRLine = rLine.GetPreviousRoute();

                    if (PreviousRLine != null)
                    {
                        WIPItemNeed childWipItemNeed = new WIPItemNeed(Session, this, PreviousRLine, ref childItemNeed);
                        childWipItemNeed.Save();
                    }
                    else
                    {
                        IsCheckWH = true;
                    }
                }

                InitBomItemNeed(childItemNeed);
            }
            else
            {
                IsCheckWH = true;
            }
        }
Пример #11
0
        public WIPItemNeed(Session session, WIPItemNeed wipItemNeed, RouteLine rLine, ref WIPItemNeed childItemNeed)
            : base(session)
        {
            ParentItemNeed = wipItemNeed;
            WIPTable = wipItemNeed.WIPTable;
            SalesOrderLine = wipItemNeed.SalesOrderLine;
            //Item = rLine.wipItem;
            Item = wipItemNeed.Item;
            ItemSource = wipItemNeed.ItemSource;
            Level = wipItemNeed.Level;
            SubLevel = wipItemNeed.SubLevel + 1;
            IsEnableCalcQty = true;

            if (SalesOrderLine.SaleOrderLine.OrderType.WareHouse != null)
                WareHouse = SalesOrderLine.SaleOrderLine.OrderType.WareHouse;
            else
                WareHouse = wipItemNeed.WareHouse;

            //  TODO: calc the needDate & needQty
            NeedDate = wipItemNeed.NeedDate.AddDays(-1);
            NeedQty = wipItemNeed.LackQty;
            calcSubItemNeedQty();
            RouteLine = CWIPRouteLine(rLine);
            SetSortKey();
            CheckOrderTypeScrap();

            RouteLine PreviousRLine = rLine.GetPreviousRoute();

            if (PreviousRLine != null)
            {
                WIPItemNeed childWipItemNeed = new WIPItemNeed(Session, this, PreviousRLine, ref childItemNeed);
                childWipItemNeed.Save();
            }
            else
            {
                IsCheckWH = true;
                childItemNeed = this;
            }
        }
Пример #12
0
        private string POPromisedDateList(WIPItemNeed wipItemNeed)
        {
            StringBuilder sbProj = new StringBuilder();

            foreach (WIPItemNeedDetail needDetail in wipItemNeed.WIPItemNeedDetails)
            {
                if (needDetail.NeedDetailType == WIPItemNeedDetail.DetailType.Purch)
                {
                    if (needDetail.Projection != "")
                    {
                        sbProj.Append(", ");
                        sbProj.Append(needDetail.Projection);
                    }
                }
            }

            if (sbProj.ToString() == "")
            {
                return "";
            }
            else
            {
                return sbProj.ToString().Substring(2, sbProj.ToString().Length - 2);
            }
        }
Пример #13
0
        private void ListWipItemNeedToMainSheet(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, ref int row)
        {
            Excel.Range range;

            xlSht.Cells[row, COL_SODATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.PoDate.ToShortDateString();
            xlSht.Cells[row, COL_SONO] = wipItemNeed.SalesOrderLine.SaleOrderLine.SalesOrder.OrderNo;
            xlSht.Cells[row, COL_SOINDEX] = wipItemNeed.SalesOrderLine.SaleOrderLine.LineNo; // **
            xlSht.Cells[row, COL_LEVEL] = wipItemNeed.Level;
            xlSht.Cells[row, COL_SUBLEVEL] = wipItemNeed.SubLevel;
            xlSht.Cells[row, COL_CUSTOMER_PN] = wipItemNeed.SalesOrderLine.SaleOrderLine.CustomerItemNo;
            xlSht.Cells[row, COL_NEEDDATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.NeedDate.ToShortDateString();

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderType != null)
                xlSht.Cells[row, COL_SOTYPE] = wipItemNeed.SalesOrderLine.SaleOrderLine.OrderType.Name;

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderStatus == Namwah.Module.BO.SalesOrderLine.SalesOrderStatus.Waiting)
            {
                xlSht.Cells[row, COL_SOSTATUS] = "Waiting";

                range = xlSht.Range[xlSht.Cells[row, COL_SOSTATUS], xlSht.Cells[row, COL_SOSTATUS]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.Red);
            }
            else if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderStatus == Namwah.Module.BO.SalesOrderLine.SalesOrderStatus.Active)
            {
                    xlSht.Cells[row, COL_SOSTATUS] = "Active";
            }

            if (wipItemNeed.Level == 1 && wipItemNeed.SubLevel == 1)
            {
                xlSht.Cells[row, COL_SOLACK] = wipItemNeed.SalesOrderLine.SaleOrderLine.BalQty;
                xlSht.Cells[row, COL_READYSHIP] = wipItemNeed.SalesOrderLine.SaleOrderLine.ReadyShipQty;
            }
            else
            {
                range = xlSht.Range[xlSht.Cells[row, COL_SODATE], xlSht.Cells[row, COL_CUSTOMER_PN]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.White);

                range = xlSht.Range[xlSht.Cells[row, COL_NEEDDATE], xlSht.Cells[row, COL_NEEDDATE]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.White);
            }

            range = xlSht.Range[xlSht.Cells[row, COL_ITEMNO], xlSht.Cells[row, COL_ITEMNO]];

            switch (wipItemNeed.Level)
            {
                case 0:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.White);
                    break;
                case 1:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.LightBlue);
                    break;
                case 2:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.LightGreen);
                    break;
                case 3:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.LightPink);
                    break;
                case 4:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.LightYellow);
                    break;
                case 5:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.LightSeaGreen);
                    break;
                case 6:
                    ExcelHelper.SetCellBGColor(range, System.Drawing.Color.Lime);
                    break;
                default:
                    break;
            }

            xlSht.Cells[row, COL_ITEMNO] = wipItemNeed.Item.ItemNo;
            xlSht.Cells[row, COL_ITEMNAME] = wipItemNeed.Item.ItemName;
            xlSht.Cells[row, COL_ITEMTYPE] = wipItemNeed.Item.ItemType.ItemTypeName;
            xlSht.Cells[row, COL_MATERIAL] = wipItemNeed.Item.Material.Name;
            //xlSht.Cells[row, COL_WEEK]
            xlSht.Cells[row, COL_WIPBOMQTY] = wipItemNeed.WIPProdBomQty;
            xlSht.Cells[row, COL_BOMQTY] = wipItemNeed.Qty;
            xlSht.Cells[row, COL_BOMPERSERIES] = wipItemNeed.PerSeries;
            xlSht.Cells[row, COL_BOMLACK] = wipItemNeed.NeedQty;

            if (wipItemNeed.ItemSource == Item.ItemSource.Make)
            {
                xlSht.Cells[row, COL_WORKOPER] = wipItemNeed.RouteLine.WorkOper.Name;
                xlSht.Cells[row, COL_ITEMSOURCE] = "做";
                ExportSOProjection(wipItemNeed, xlSht, row);
            }
            else
            {
                xlSht.Cells[row, COL_ITEMSOURCE] = "买";
                ExportPOProjection(wipItemNeed, xlSht, row);
            }

            xlSht.Cells[row, COL_WHQTY] = wipItemNeed.WHQty;
            xlSht.Cells[row, COL_WHQAQTY] = wipItemNeed.WHQAQty;
            xlSht.Cells[row, COL_WIPQTY] = wipItemNeed.WIPQty;
            xlSht.Cells[row, COL_READYWORK] = wipItemNeed.ReadyQty;
            xlSht.Cells[row, COL_WIPLACK] = wipItemNeed.LackQty;

            Excel.Range oRange = (Excel.Range)xlSht.Cells[row, COL_PROJTOTAL];
            oRange.Formula = string.Format("=SUM(AG{0}:DR{0})", row);

            string filter = "";

            if (wipItemNeed.ParentItemNeed != null)
            {
                if (wipItemNeed.ParentItemNeed.ItemSource == Item.ItemSource.Make)
                    filter = wipItemNeed.ParentItemNeed.RouteLine.WorkOper.Name;
            }

            if (wipItemNeed.ItemSource == Item.ItemSource.Make)
                filter = String.Format("{0},{1}", filter, wipItemNeed.RouteLine.WorkOper.Name);

            xlSht.Cells[row, COL_FILTER] = filter;

            row++;

            #region List SubLevel = 1  ChildItemNeed

            foreach (WIPItemNeed cItemNeed in wipItemNeed.ChildItemNeed)
            {
                //if (cItemNeed.SubLevel == 1)
                //{
                ListWipItemNeedToMainSheet(cItemNeed, xlSht, ref row);
                //}
            }

            #endregion
        }
Пример #14
0
        private void ExportSOProjection(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, int row)
        {
            int dateDiff = 0;
            Dictionary<int, float> dictProj = new Dictionary<int, float>();
            wipItemNeed.SalesOrderLine.SaleOrderLine.SalesOrderPromisedDates.Sorting.Add(new SortProperty("PromisedDate", DevExpress.Xpo.DB.SortingDirection.Descending));

            foreach (SalesOrderPromisedDate promisedDate in wipItemNeed.SalesOrderLine.SaleOrderLine.SalesOrderPromisedDates)
            {
                if (promisedDate.Item == wipItemNeed.Item && promisedDate.RouteLine.OperNo == wipItemNeed.RouteLine.OperNo)
                {
                    TimeSpan span = promisedDate.PromisedDate.Subtract(DateTime.Today.AddDays(-1));
                    dateDiff = span.Days;

                    if (dateDiff < 0)
                        dateDiff = 0;

                    if (dateDiff > TOTALDAY)
                        dateDiff = TOTALDAY;

                    if (dictProj.ContainsKey(dateDiff))
                        dictProj[dateDiff] = dictProj[dateDiff] + promisedDate.Qty;
                    else
                        dictProj.Add(dateDiff, promisedDate.Qty);
                }
            }

            float tNeedQty = wipItemNeed.NeedQty - wipItemNeed.WHQty - wipItemNeed.WHQAQty;

            foreach (KeyValuePair<int, float> kvp in dictProj)
            {
                if (tNeedQty > 0)
                {
                    if (tNeedQty > kvp.Value)
                    {
                        xlSht.Cells[row, COL_STARTDAY + kvp.Key] = kvp.Value;
                        tNeedQty = tNeedQty - kvp.Value;
                    }
                    else
                    {
                        xlSht.Cells[row, COL_STARTDAY + kvp.Key] = tNeedQty;
                        tNeedQty = 0;
                        break;
                    }
                }
            }

            dictProj = null;
        }
Пример #15
0
 private void calcWIPByBuy(WIPItemNeed wipItemNeed)
 {
     // Need Qty, WHQty, WHQAQty, WIPQty(In Purchase Order)
     GetProdBomQty(wipItemNeed);
     GetWHQty(wipItemNeed);
     GetPoQty(wipItemNeed);
 }
Пример #16
0
 private void calcWIPByMake(WIPItemNeed wipItemNeed)
 {
     // Need Qty , WHQty, No WHQAQty, WIPQty(In ProdRoute)
     GetProdBomQty(wipItemNeed);
     GetWHQty(wipItemNeed);
     GetProdRouteQty(wipItemNeed);
 }
Пример #17
0
 private void InitBomItemNeed(WIPItemNeed parentItemNeed)
 {
     // foreach (BomLine bLine in Item.BomLines)
     foreach (BomLine bLine in parentItemNeed.Item.BomLines)
     {
         if (bLine.LineType != Item.ItemSource.None)
         {
             WIPItemNeed wipItemNeed = new WIPItemNeed(Session, parentItemNeed, bLine);
             wipItemNeed.Save();
         }
     }
 }
Пример #18
0
        private void GetProdBomQty(WIPItemNeed wipItemNeed)
        {
            string key = "";

            if (wipItemNeed.ParentItemNeed != null)
                key = String.Format("{0}_{1}", wipItemNeed.ParentItemNeed.Item.ItemNo, wipItemNeed.Item.ItemNo);
            else
                key = wipItemNeed.Item.ItemNo;

            if (dictProdBom.ContainsKey(key))
            {
                XPCollection<WIPProdBom> wipProdBoms = dictProdBom[key];

                for (int i = 0; i < wipProdBoms.Count; i++)
                {
                    WIPProdBom wipProdBom = wipProdBoms[i];

                    if (wipProdBom.BalQty > 0 && wipItemNeed.LackQty > 0)
                    {
                        float tmpQty;

                        if (wipProdBom.BalQty > wipItemNeed.LackQty)
                            tmpQty = wipItemNeed.LackQty;
                        else
                            tmpQty = wipProdBom.BalQty;

                        WIPItemNeedDetail needDetail = new WIPItemNeedDetail(uow, wipItemNeed);
                        needDetail.WIPProdBom = wipProdBom;
                        needDetail.UsedQty = tmpQty;
                        needDetail.NeedDetailType = WIPItemNeedDetail.DetailType.Production;

                        wipItemNeed.WIPProdBomQty = wipItemNeed.WIPProdBomQty + tmpQty;
                        wipItemNeed.calcSubItemNeedQty();
                        wipItemNeed.Save();
                        wipProdBom.UsedQty = wipProdBom.UsedQty + tmpQty;
                        wipProdBom.Save();
                    }
                }
            }
        }
Пример #19
0
        private void ListRoute(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, ref int row)
        {
            bool firstLevelBom;

            if (wipItemNeed.Level == 1 && wipItemNeed.SubLevel == 1)
                firstLevelBom = true;
            else
                firstLevelBom = false;

            if (wipItemNeed.Level == 2 && wipItemNeed.SubLevel == 1)
            {
                ListSOInfo(wipItemNeed, xlSht, ref row);
                FirstBomRow = false;
                xlSht.Cells[row, COL_BOMLACK] = wipItemNeed.NeedQty;
                xlSht.Cells[row, COL_BOM_WHQTY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BOM_WHQTY) + wipItemNeed.WHQty;
                xlSht.Cells[row, COL_BOM_WHQAQTY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BOM_WHQAQTY) + wipItemNeed.WHQAQty;
                xlSht.Cells[row, COL_ALL_PARTNO] = wipItemNeed.AllPartNo;
            }

            if (wipItemNeed.ItemSource == Item.ItemSource.Buy || wipItemNeed.ItemSource == Item.ItemSource.None)
            {
                if (wipItemNeed.Level > 2 && wipItemNeed.ChildItemNeed.Count == 0)
                {
                    xlSht.Cells[row, COL_BLANK_WHQTY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_WHQTY) + wipItemNeed.WHQty;
                    xlSht.Cells[row, COL_BLANK_WHQAQTY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_WHQAQTY) + wipItemNeed.WHQAQty;
                }

                xlSht.Cells[row, COL_BLANK_LACK] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_LACK) + wipItemNeed.NeedQty - wipItemNeed.WHQty - wipItemNeed.WHQAQty;
                xlSht.Cells[row, COL_BLANK_PO] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_PO) + wipItemNeed.WIPQty;
                xlSht.Cells[row, COL_BLANK_NOPO] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_NOPO) + wipItemNeed.LackQty;

                if (wipItemNeed.Item.ItemType.ItemTypeName == "BezelBlank")
                {
                    if (wipItemNeed.SalesOrderLine.SaleOrderLine.WorkOrder != null)
                    {
                        if (wipItemNeed.SalesOrderLine.SaleOrderLine.WorkOrder.BezelBlankPromisedDate > DateTime.MinValue)
                        xlSht.Cells[row, COL_BEZELPROMISEDDATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.WorkOrder.BezelBlankPromisedDate;
                    }
                }

                if (wipItemNeed.ItemSource == Item.ItemSource.None)
                    xlSht.Cells[row, COL_ALL_PARTNO] = "定义有问题 : BOM类别定义为未定";
            }
            else
            {
                if (wipItemNeed.RouteLine == null)
                {
                    xlSht.Cells[row, COL_ALL_PARTNO] = "定义有问题 : BOM类别定义为做但没有BOM/流程资料";
                }
                else
                {
                    switch (wipItemNeed.RouteLine.WorkOper.Name)
                    {
                        case "电镀": // P
                            xlSht.Cells[row, COL_P] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_P) + wipItemNeed.WIPQty;
                            xlSht.Cells[row, COL_P_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_P_WAIT) + wipItemNeed.ReadyQty;
                            break;
                        case "移印":   // Y
                            xlSht.Cells[row, COL_Y] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_Y) + wipItemNeed.WIPQty;
                            xlSht.Cells[row, COL_Y_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_Y_WAIT) + wipItemNeed.ReadyQty;
                            break;
                        case "钢机加打磨": // CELL
                        case "铜机加打磨":
                            xlSht.Cells[row, COL_CELL] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_CELL) + wipItemNeed.WIPQty;
                            xlSht.Cells[row, COL_CELL_READY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_CELL_READY);
                            xlSht.Cells[row, COL_CELL_LACK] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_CELL_LACK) + wipItemNeed.LackQty;

                            xlSht.Cells[row, COL_BLANK_WHQTY] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_BLANK_WHQTY) + wipItemNeed.ReadyQty;
                            break;
                        case "FQC":
                            xlSht.Cells[row, COL_FQC] = wipItemNeed.WIPQty;
                            break;
                        case "TSI":
                            xlSht.Cells[row, COL_TSI] = wipItemNeed.WIPQty;
                            break;
                        case "包装":
                            xlSht.Cells[row, COL_A] = wipItemNeed.WIPQty;
                            break;
                        default:
                            xlSht.Cells[row, COL_OTHER] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_OTHER) + wipItemNeed.WIPQty;
                            xlSht.Cells[row, COL_OTHER_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_OTHER_WAIT) + wipItemNeed.ReadyQty;
                            break;
                    }
                }

                if (wipItemNeed.ChildItemNeed.Count == 1)
                {
                    WIPItemNeed childItemNeed = wipItemNeed.ChildItemNeed[0];

                    if (childItemNeed.ItemSource != Item.ItemSource.Buy)
                    {
                        switch (wipItemNeed.RouteLine.WorkOper.Name)
                        {
                            case "电镀": // P
                                xlSht.Cells[row, COL_P_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_P_WAIT) + childItemNeed.WHQAQty + childItemNeed.WHQty;
                                break;
                            case "移印":   // Y
                                xlSht.Cells[row, COL_Y_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_Y_WAIT) + childItemNeed.WHQAQty + childItemNeed.WHQty;
                                break;
                            case "钢机加打磨": // CELL
                            case "铜机加打磨":
                            case "FQC":
                            case "TSI":
                            case "包装":
                                break;
                            default:
                                xlSht.Cells[row, COL_OTHER_WAIT] = ExcelHelper.GetCellFloatValue(xlSht, row, COL_OTHER_WAIT) + childItemNeed.WHQAQty + childItemNeed.WHQty;
                                break;
                        }
                    }

                    ListRoute(childItemNeed, xlSht, ref row);
                }
                else if (wipItemNeed.ChildItemNeed.Count > 1 && firstLevelBom)
                {
                    bool isFoundBezel = false;

                    foreach (WIPItemNeed bomItemNeed in wipItemNeed.ChildItemNeed)
                    {
                        if (bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() == "BEZEL")
                        {
                            ListRoute(bomItemNeed, xlSht, ref row);
                            isFoundBezel = true;
                            row++;
                        }
                    }

                    if (isFoundBezel == false)
                        row++;

                    foreach (WIPItemNeed bomItemNeed in wipItemNeed.ChildItemNeed)
                    {
                        if (bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() == "RING")
                        {
                            ListRoute(bomItemNeed, xlSht, ref row);
                            row++;
                        }
                    }

                    foreach (WIPItemNeed bomItemNeed in wipItemNeed.ChildItemNeed)
                    {
                        if (bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() == "CASEBACK")
                        {
                            ListRoute(bomItemNeed, xlSht, ref row);
                            row++;
                        }
                    }

                    foreach (WIPItemNeed bomItemNeed in wipItemNeed.ChildItemNeed)
                    {
                        if (bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() != "BEZEL" && bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() != "RING" && bomItemNeed.Item.ItemType.ItemTypeName.ToUpper() != "CASEBACK")
                        {
                            ListRoute(bomItemNeed, xlSht, ref row);
                            row++;
                        }
                    }
                }
            }
        }
Пример #20
0
        private void GetWHQty(WIPItemNeed wipItemNeed)
        {
            string key = wipItemNeed.Item.ItemNo;

            if (dictWHTotal.ContainsKey(key))
            {
                XPCollection<WIPWHTotal> wipWHTotals = dictWHTotal[key];

                foreach (WIPWHTotal wipWHTotal in wipWHTotals)
                {
                    if (wipWHTotal.Warehouse == wipItemNeed.WareHouse && wipItemNeed.IsCheckWH == true)
                    {
                        wipWHTotal.calcWipItemNeed(wipItemNeed);
                    }
                }
            }
        }
Пример #21
0
        private void ListSOInfo(WIPItemNeed wipItemNeed, Excel.Worksheet xlSht, ref int row)
        {
            Excel.Range range;

            if (!FirstBomRow)
            {
                range = xlSht.Range[xlSht.Cells[row, COL_SODATE], xlSht.Cells[row, COL_WACANO]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.White);

                range = xlSht.Range[xlSht.Cells[row, COL_PRIORITY], xlSht.Cells[row, COL_NEW_PROMISEDDATE]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.White);
            }

            xlSht.Cells[row, COL_SODATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.PoDate.ToShortDateString();

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.WorkOrder != null)
            {
                xlSht.Cells[row, COL_SONO] = wipItemNeed.SalesOrderLine.SaleOrderLine.WorkOrder.WorkOrderNo;
                xlSht.Cells[row, COL_SOINDEX] = wipItemNeed.SalesOrderLine.SaleOrderLine.OrderLineIndex;
            }
            else
            {
                xlSht.Cells[row, COL_SONO] = wipItemNeed.SalesOrderLine.SaleOrderLine.SalesOrder.OrderNo;
                xlSht.Cells[row, COL_SOINDEX] = wipItemNeed.SalesOrderLine.SaleOrderLine.OrderLineIndex;
            }
            xlSht.Cells[row, COL_SOSTATUS] = wipItemNeed.SalesOrderLine.SaleOrderLine.OrderStatus;

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.Item.Lot != null)
            {
                xlSht.Cells[row, COL_LOT] = wipItemNeed.SalesOrderLine.SaleOrderLine.Item.Lot.LotNo;
            }

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.Style == null)
                xlSht.Cells[row, COL_CUSTOMER_PN] = wipItemNeed.SalesOrderLine.SaleOrderLine.CustomerItemNo;
            else
            {
                xlSht.Cells[row, COL_CUSTOMER_PN] = wipItemNeed.SalesOrderLine.SaleOrderLine.Style.ProjectLineNo;
                xlSht.Cells[row, COL_PROJECT] = wipItemNeed.SalesOrderLine.SaleOrderLine.Style.Project.No;

                if (wipItemNeed.SalesOrderLine.SaleOrderLine.Style.Project.LaunchDate.Year > 2010)
                    xlSht.Cells[row, COL_LAUNCH] = wipItemNeed.SalesOrderLine.SaleOrderLine.Style.Project.LaunchDate;

                if (wipItemNeed.SalesOrderLine.SaleOrderLine.Style.Project.HKBuyer != null)
                    xlSht.Cells[row, COL_BUYER] = wipItemNeed.SalesOrderLine.SaleOrderLine.Style.Project.HKBuyer.Name;
            }

            xlSht.Cells[row, COL_WACANO] = wipItemNeed.SalesOrderLine.SaleOrderLine.Item.ItemNo;

            if (wipItemNeed.Item == null)
            {
                xlSht.Cells[row, COL_ITEMNO] = "Undefined";
                xlSht.Cells[row, COL_ITEMNAME] = "Undefined";
                xlSht.Cells[row, COL_ITEMTYPE] = "Undefined";
                xlSht.Cells[row, COL_MATERIAL] = "Undefined";
            }
            else
            {
                xlSht.Cells[row, COL_ITEMNO] = wipItemNeed.Item.ItemNo;
                xlSht.Cells[row, COL_ITEMNAME] = wipItemNeed.Item.ItemName;
                xlSht.Cells[row, COL_ITEMTYPE] = wipItemNeed.Item.ItemType.ItemTypeName;
                xlSht.Cells[row, COL_MATERIAL] = wipItemNeed.Item.Material.Name;

                if (wipItemNeed.SalesOrderLine.SaleOrderLine.Item.ItemCategory != null)
                    xlSht.Cells[row, COL_CATEGORY] = wipItemNeed.SalesOrderLine.SaleOrderLine.Item.ItemCategory.ItemCategoryDescription;

            }

            xlSht.Cells[row, COL_PRIORITY] = wipItemNeed.SalesOrderLine.SaleOrderLine.Priority;
            xlSht.Cells[row, COL_NEEDDATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.NeedDate.ToShortDateString();

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.PromisedDate.Year > 2010)
                xlSht.Cells[row, COL_PROMISEDDATE] = wipItemNeed.SalesOrderLine.SaleOrderLine.PromisedDate.ToShortDateString();

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderType != null)
                xlSht.Cells[row, COL_SOTYPE] = wipItemNeed.SalesOrderLine.SaleOrderLine.OrderType.Name;

            if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderStatus == SalesOrderLine.SalesOrderStatus.Waiting)
            {
                xlSht.Cells[row, COL_SOSTATUS] = "Waiting";

                range = xlSht.Range[xlSht.Cells[row, COL_SOSTATUS], xlSht.Cells[row, COL_SOSTATUS]];
                ExcelHelper.SetFontColor(range, System.Drawing.Color.Red);
            }
            else if (wipItemNeed.SalesOrderLine.SaleOrderLine.OrderStatus == SalesOrderLine.SalesOrderStatus.Active)
            {
                xlSht.Cells[row, COL_SOSTATUS] = "Active";
            }

            xlSht.Cells[row, COL_WEEK] = "";
            xlSht.Cells[row, COL_NEW_PROMISEDDATE] = "";
        }
Пример #22
0
 public WIPItemNeedDetail(Session session, WIPItemNeed wipItemNeed)
     : base(session)
 {
     _WIPItemNeed = wipItemNeed;
     OnChanged("WIPItemNeed");
 }
Пример #23
0
        public void calcWipItemNeed(WIPItemNeed wipItemNeed)
        {
            if (BalQty > 0 && wipItemNeed.LackQty > 0)
            {
                float tmpQty = BalQty;

                wipItemNeed.WIPWHTotal = this;

                if (tmpQty > wipItemNeed.LackQty)
                {
                    tmpQty = wipItemNeed.LackQty;
                }

                wipItemNeed.WHQty = wipItemNeed.WHQty + tmpQty;
                wipItemNeed.calcSubItemNeedQty();
                wipItemNeed.Save();
                UsedQty = UsedQty + tmpQty;
            }

            if (QABalQty > 0 && wipItemNeed.LackQty > 0)
            {
                float tmpQty = QABalQty;

                wipItemNeed.WIPWHTotal = this;

                if (tmpQty > wipItemNeed.LackQty)
                {
                    tmpQty = wipItemNeed.LackQty;
                }

                wipItemNeed.WHQAQty = wipItemNeed.WHQAQty + tmpQty;
                wipItemNeed.calcSubItemNeedQty();
                wipItemNeed.Save();
                QAUsedQty = QAUsedQty + tmpQty;

            }
        }