Example #1
0
        public void UpdateQty()
        {
            if (SubItemSummarys.Count == 0)
            {
                SubItemSummary itemSummaryNormal = new SubItemSummary(Session);
                itemSummaryNormal.SubItem = this;
                itemSummaryNormal.OrderType = SubPurchOrderLine.OrderType.Normal;
                itemSummaryNormal.Save();

                SubItemSummary itemSummaryReturn = new SubItemSummary(Session);
                itemSummaryReturn.SubItem = this;
                itemSummaryReturn.OrderType = SubPurchOrderLine.OrderType.Return;
                itemSummaryReturn.Save();

            }

            foreach (SubItemSummary itemSummary in SubItemSummarys)
            {
                itemSummary.UpdateQty();
                itemSummary.updateTimeStamp = false;
                itemSummary.Save();
            }

            UpdateSelfQty();
        }
        public static void IssuesPOReceiveByPurchOrder(SubItemSummary subItemSummary, SubPurchOrderLine.OrderType OrderType)
        {
            float remainQty = 0;
            float remainDefectQty = 0;
            float remainNWDefectQty = 0;

            // ���Ŀͻ�Ҫ��ֿ���Ʒ, ���ϲ���, ��������Ϊ3��.
            if (subItemSummary.CanShipQty > 0)
            {
                remainQty = subItemSummary.CanShipQty;
                remainDefectQty = 0;
                remainNWDefectQty = 0;

                SubPurchOrderReceive.IssuePOReceive(subItemSummary.SubItem, OrderType, null,
                                                    ref remainQty, ref remainDefectQty, ref remainNWDefectQty);
            }

            if (subItemSummary.CanShipDefectQty > 0)
            {
                remainQty = 0;
                remainDefectQty = subItemSummary.CanShipDefectQty;
                remainNWDefectQty = 0;

                SubPurchOrderReceive.IssuePOReceive(subItemSummary.SubItem, OrderType, null,
                                                    ref remainQty, ref remainDefectQty, ref remainNWDefectQty);
            }

            if (subItemSummary.CanShipNWDefectQty > 0)
            {
                remainQty = 0;
                remainDefectQty = 0;
                remainNWDefectQty = subItemSummary.CanShipNWDefectQty;

                SubPurchOrderReceive.IssuePOReceive(subItemSummary.SubItem, OrderType, null,
                                                    ref remainQty, ref remainDefectQty, ref remainNWDefectQty);
            }
        }
        public static void IssuesPOReceiveBySalesOrder(SubItemSummary subItemSummary)
        {
            float remainQty = subItemSummary.CanShipQty;
            float remainDefectQty = subItemSummary.CanShipDefectQty;
            float remainNWDefectQty = subItemSummary.CanShipNWDefectQty;

            #region  ��Ϊ��J��, Ҫ������������ı���������

            float canShipNWDefectQty = SubItemMonthly.GetCanShipNWDefectQty(
                subItemSummary.SubItem.ItemNo, DateTime.Today.Year, DateTime.Today.Month);

            if (canShipNWDefectQty < remainNWDefectQty)
                remainNWDefectQty = canShipNWDefectQty;

            if (remainNWDefectQty < 0)
                remainNWDefectQty = 0;

            #endregion

            #region Assign Qty to SalesOrderLine

            UnitOfWork uow = new UnitOfWork();
            List<SubSalesOrderLine> soLines = SubSalesOrderLine.LoadOpenBalance(uow, subItemSummary.SubItem);

            Dictionary<SubSalesOrderLine, float> dictQty = new Dictionary<SubSalesOrderLine, float>();
            Dictionary<SubSalesOrderLine, float> dictDefectQty = new Dictionary<SubSalesOrderLine, float>();
            Dictionary<SubSalesOrderLine, float> dictNWDefectQty = new Dictionary<SubSalesOrderLine, float>();

            for (int i = 0; i < soLines.Count; i++)
            {
                if (remainQty <= 0 && remainDefectQty <= 0 && remainNWDefectQty <= 0)
                    break;

                SubSalesOrderLine soline = soLines[i];
                float TmpSmallQty = 0;
                float soBal = soline.BalQty;

                TmpSmallQty = UDFunction.AssignSmallQty(ref soBal, ref remainQty);
                dictQty.Add(soline, TmpSmallQty);

                TmpSmallQty = UDFunction.AssignSmallQty(ref soBal, ref remainDefectQty);
                dictDefectQty.Add(soline, TmpSmallQty);

                TmpSmallQty = UDFunction.AssignSmallQty(ref soBal, ref remainNWDefectQty);
                dictNWDefectQty.Add(soline, TmpSmallQty);

            }

            #endregion

            #region Assign Qty from SalesOrderLine to PurchOrderReceive

            // �������� !!!!!!
            // 1.  �ȿ���Ʒ��
            // 2.  �ٿ����ϲ���.
            // 3.  ��󿴱�������.

            float Qty = 0;
            float DefectQty = 0;
            float NWDefectQty = 0;

            // 1.  �ȿ���Ʒ��
            foreach (KeyValuePair<SubSalesOrderLine, float> pair in dictQty)
            {
                SubSalesOrderLine soLine = pair.Key;
                Qty = pair.Value;
                DefectQty = 0;
                NWDefectQty = 0;

                if (Qty > 0)
                {
                    SubPurchOrderReceive.IssuePOReceive(soLine.Item, SubPurchOrderLine.OrderType.Normal, soLine,
                                                                    ref Qty, ref DefectQty, ref NWDefectQty);
                    SubSalesOrderLine.UpdateSOQty(soLine);
                }
            }

            // 2.  �ٿ����ϲ���.
            foreach (KeyValuePair<SubSalesOrderLine, float> pair in dictDefectQty)
            {
                SubSalesOrderLine soLine = pair.Key;
                Qty = 0;
                DefectQty = pair.Value;
                NWDefectQty = 0;

                if (DefectQty > 0 )
                {
                    SubPurchOrderReceive.IssuePOReceive(soLine.Item, SubPurchOrderLine.OrderType.Normal, soLine,
                                                                    ref Qty, ref DefectQty, ref NWDefectQty);
                    SubSalesOrderLine.UpdateSOQty(soLine);
                }
            }

            // 3.  ��󿴱�������.
            foreach (KeyValuePair<SubSalesOrderLine, float> pair in dictNWDefectQty)
            {
                SubSalesOrderLine soLine = pair.Key;
                Qty = 0;
                DefectQty = 0;
                NWDefectQty = pair.Value;

                if (NWDefectQty > 0)
                {
                    SubPurchOrderReceive.IssuePOReceive(soLine.Item, SubPurchOrderLine.OrderType.Normal, soLine,
                                                                ref Qty, ref DefectQty, ref NWDefectQty);
                    SubSalesOrderLine.UpdateSOQty(soLine);
                }
            }

            #endregion
        }
 public static void IssuePOReceiveFromSummary(SubItemSummary subItemSummary)
 {
     if (subItemSummary.SubItem.ShipmentWithSalesOrder == false )
     {
         SubPurchOrderReceive.IssuesPOReceiveByPurchOrder(subItemSummary, subItemSummary.OrderType);
     }
     else
     {
         if (subItemSummary.OrderType == SubPurchOrderLine.OrderType.Normal)
         {
             SubPurchOrderReceive.IssuesPOReceiveBySalesOrder(subItemSummary);
         }
         else
         {
             SubPurchOrderReceive.IssuesPOReceiveByPurchOrder(subItemSummary, SubPurchOrderLine.OrderType.Return);
         }
     }
 }