Esempio n. 1
0
        public void InOutWithDR(InOutDRParam inParam)
        {
            Item   itemAfterInOut = _itemService.Find(inParam.DRItem.Item.Id);
            double oldQty         = itemAfterInOut.GetAppropriateQuantity;

            if (inParam.InOrOut == InOrOut.In)
            {
                InOutHelper.AddToAppopriateMeasurement(itemAfterInOut, inParam.DRItem.Qty);
            }
            else if (inParam.InOrOut == InOrOut.Out)
            {
                InOutHelper.SubtractToAppopriateMeasurement(itemAfterInOut, inParam.DRItem.Qty);
            }

            double newQty = itemAfterInOut.GetAppropriateQuantity;

            inParam.DRItem.Item = itemAfterInOut;
            var p = CreateHistoryParameterWithDr(inParam, oldQty, newQty);

            ItemHistory h = InOutHelper.MakeHistory(p);

            _historyService.Add(h);
            _itemService.Edit(itemAfterInOut);

            _drService.AddToDR(inParam.DRItem.DR.Id, inParam.DRItem);
        }
Esempio n. 2
0
        public void InOutGoodItems(ReturnInOutParam inOutParam)
        {
            Item   ItemAfterInOrOut = _itemService.Find(inOutParam.ItemId);
            double oldQty           = ItemAfterInOrOut.GetAppropriateQuantity;

            if (inOutParam.InOrOut == InOrOut.In)
            {
                InOutHelper.AddToAppopriateMeasurement(ItemAfterInOrOut, inOutParam.ReturnedItem.Qty);
            }
            else
            {
                InOutHelper.SubtractToAppopriateMeasurement(ItemAfterInOrOut, inOutParam.ReturnedItem.Qty);
            }

            double newQty = ItemAfterInOrOut.GetAppropriateQuantity;

            _itemService.Edit(ItemAfterInOrOut);

            if (inOutParam.InOrOut == InOrOut.In)
            {
                var         p = CreateHistoryParameterForReturnedItems(inOutParam, oldQty, newQty);
                ItemHistory h = InOutHelper.MakeHistory(p);
                _historyService.Add(h);

                _returnedHistoryService.AddReturnedGoodItem(inOutParam.ReturnedItem.ReturnedHistory.Id,
                                                            inOutParam.ReturnedItem);
            }
            else
            {
                _returnedHistoryService.DeleteGoodItem(inOutParam.ReturnedItem.Id);
                _historyService.DeleteReturnedHistoryByDRAndItem(inOutParam.DrId
                                                                 , inOutParam.ItemId);
            }
        }
Esempio n. 3
0
        public void Out(InOutParam outParam)
        {
            Item   itemAfterOut = _itemService.Find(outParam.Item.Id);
            double oldQty       = itemAfterOut.GetAppropriateQuantity;

            InOutHelper.SubtractToAppopriateMeasurement(itemAfterOut, outParam.Qty);

            double newQty = itemAfterOut.GetAppropriateQuantity;

            var         p = CreateHistoryParameter(outParam, oldQty, newQty);
            ItemHistory h = InOutHelper.MakeHistory(p);

            _historyService.Add(h);
            _itemService.Edit(itemAfterOut);
        }
Esempio n. 4
0
        public void In(InOutParam inParam)
        {
            Item   itemAfterIn = _itemService.Find(inParam.Item.Id);
            double oldQty      = itemAfterIn.GetAppropriateQuantity;

            InOutHelper.AddToAppopriateMeasurement(itemAfterIn, inParam.Qty);

            double newQty = itemAfterIn.GetAppropriateQuantity;

            var         p = CreateHistoryParameter(inParam, oldQty, newQty);
            ItemHistory h = InOutHelper.MakeHistory(p);

            _historyService.Add(h);
            _itemService.Edit(itemAfterIn);
        }
Esempio n. 5
0
        public void RemoveFromDR(InOutDRParam outParam)
        {
            Item itemAfterOut = _itemService.Find(outParam.DRItem.Item.Id);

            if (outParam.InOrOut == InOrOut.In)
            {
                InOutHelper.AddToAppopriateMeasurement(itemAfterOut, outParam.DRItem.Qty);
            }
            else
            {
                InOutHelper.SubtractToAppopriateMeasurement(itemAfterOut, outParam.DRItem.Qty);
            }

            outParam.DRItem.Item = itemAfterOut;
            _itemService.Edit(itemAfterOut);

            _historyService.DeleteHistoryByDRAndItem(outParam.DRItem.DR.Id, itemAfterOut.Id);
            _drService.DeleteDRItem(outParam.DRItem.Id);
        }