public async Task TestModel()
        {
            GarmentDOItems dOItems = new GarmentDOItems {
                UId = "aaa", DOCurrencyRate = 1, DesignColor = "aa", DetailReferenceId = 1, DOItemNo = "sdoitem", EPOItemId = 2, POId = 1, POItemId = 2, POSerialNumber = "pp", PRItemId = 1, ProductCode = "ss", ProductId = 2, ProductName = "name", RemainingQuantity = 100, SmallQuantity = 100, SmallUomId = 2, SmallUomUnit = "pcs", StorageCode = "ss", StorageName = "ss", StorageId = 3, RO = "@2", UnitCode = "s", UnitId = 4, UnitName = "s", URNItemId = 4
            };

            Assert.NotNull(dOItems.UId);
        }
        public async Task <int> Create(GarmentUnitDeliveryOrder garmentUnitDeliveryOrder)
        {
            int Created = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    garmentUnitDeliveryOrder.Items = garmentUnitDeliveryOrder.Items.Where(x => x.IsSave).ToList();

                    EntityExtension.FlagForCreate(garmentUnitDeliveryOrder, identityService.Username, USER_AGENT);

                    garmentUnitDeliveryOrder.UnitDONo = await GenerateNo(garmentUnitDeliveryOrder);

                    foreach (var garmentUnitDeliveryOrderItem in garmentUnitDeliveryOrder.Items)
                    {
                        EntityExtension.FlagForCreate(garmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);

                        GarmentUnitReceiptNote garmentUnitReceiptNote = dbContext.GarmentUnitReceiptNotes.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNId);

                        garmentUnitDeliveryOrderItem.DOCurrencyRate = garmentUnitReceiptNote.DOCurrencyRate;
                        if (garmentUnitDeliveryOrderItem.DOCurrencyRate == 0)
                        {
                            throw new Exception("garmentUnitDeliveryOrderItem.DOCurrencyRate tidak boleh 0");
                        }
                        garmentUnitReceiptNote.IsUnitDO = true;

                        GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNItemId);
                        garmentUnitDeliveryOrderItem.DOCurrencyRate = garmentUnitReceiptNoteItem.DOCurrencyRate;

                        EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                        garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                        // GarmentDOItems
                        GarmentDOItems garmentDOItems = dbSetGarmentDOItems.FirstOrDefault(w => w.Id == garmentUnitDeliveryOrderItem.DOItemsId);
                        if (garmentDOItems != null)
                        {
                            EntityExtension.FlagForUpdate(garmentDOItems, identityService.Username, USER_AGENT);
                            garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;
                        }
                    }

                    dbSet.Add(garmentUnitDeliveryOrder);

                    Created = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Created);
        }
        public async Task <int> Create(GarmentUnitDeliveryOrder garmentUnitDeliveryOrder)
        {
            int Created = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    garmentUnitDeliveryOrder.Items = garmentUnitDeliveryOrder.Items.Where(x => x.IsSave).ToList();

                    EntityExtension.FlagForCreate(garmentUnitDeliveryOrder, identityService.Username, USER_AGENT);

                    garmentUnitDeliveryOrder.UnitDONo = await GenerateNo(garmentUnitDeliveryOrder);

                    foreach (var garmentUnitDeliveryOrderItem in garmentUnitDeliveryOrder.Items)
                    {
                        EntityExtension.FlagForCreate(garmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);

                        GarmentDeliveryOrderDetail doDetail = dbContext.GarmentDeliveryOrderDetails.Single(s => s.Id.Equals(garmentUnitDeliveryOrderItem.DODetailId));

                        doDetail.ReturQuantity = doDetail.ReturQuantity + garmentUnitDeliveryOrderItem.ReturQuantity;

                        GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNItemId);
                        EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                        garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                        GarmentDOItems garmentDOItems = dbContext.GarmentDOItems.SingleOrDefault(x => x.URNItemId == garmentUnitDeliveryOrderItem.URNItemId);
                        if (garmentDOItems != null)
                        {
                            garmentDOItems.RemainingQuantity -= (decimal)garmentUnitDeliveryOrderItem.Quantity;
                        }
                    }

                    dbSet.Add(garmentUnitDeliveryOrder);

                    Created = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Created);
        }
        public async Task <int> Delete(int id)
        {
            int Deleted = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    var garmentUnitDeliveryOrder = dbSet
                                                   .Include(m => m.Items)
                                                   .SingleOrDefault(m => m.Id == id);

                    EntityExtension.FlagForDelete(garmentUnitDeliveryOrder, identityService.Username, USER_AGENT);
                    foreach (var garmentUnitDeliveryOrderItem in garmentUnitDeliveryOrder.Items)
                    {
                        EntityExtension.FlagForDelete(garmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);

                        GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNItemId);
                        EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                        garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;

                        // GarmentDOItems
                        GarmentDOItems garmentDOItems = dbSetGarmentDOItems.FirstOrDefault(w => w.Id == garmentUnitDeliveryOrderItem.DOItemsId);
                        if (garmentDOItems != null)
                        {
                            EntityExtension.FlagForUpdate(garmentDOItems, identityService.Username, USER_AGENT);
                            garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;
                        }
                    }

                    Deleted = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Deleted);
        }
        public async Task <int> Update(int id, GarmentUnitDeliveryOrder garmentUnitDeliveryOrder)
        {
            int Updated = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    garmentUnitDeliveryOrder.Items = garmentUnitDeliveryOrder.Items.Where(x => x.IsSave).ToList();

                    var oldGarmentUnitDeliveryOrder = dbSet
                                                      .Include(d => d.Items)
                                                      //.AsNoTracking()
                                                      .Single(m => m.Id == id);
                    //if (oldGarmentUnitDeliveryOrder.UnitDOType == "MARKETING")
                    //{
                    //    oldGarmentUnitDeliveryOrder.UnitDODate = garmentUnitDeliveryOrder.UnitDODate;
                    //}
                    EntityExtension.FlagForUpdate(oldGarmentUnitDeliveryOrder, identityService.Username, USER_AGENT);

                    foreach (var garmentUnitDeliveryOrderItem in garmentUnitDeliveryOrder.Items)
                    {
                        if (garmentUnitDeliveryOrderItem.Id != 0)
                        {
                            var oldGarmentUnitDeliveryOrderItem = oldGarmentUnitDeliveryOrder.Items.FirstOrDefault(i => i.Id == garmentUnitDeliveryOrderItem.Id);

                            EntityExtension.FlagForUpdate(oldGarmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);

                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == oldGarmentUnitDeliveryOrderItem.URNItemId);
                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity - (decimal)oldGarmentUnitDeliveryOrderItem.Quantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                            // GarmentDOItems
                            GarmentDOItems garmentDOItems = dbSetGarmentDOItems.FirstOrDefault(w => w.Id == garmentUnitDeliveryOrderItem.DOItemsId);
                            if (garmentDOItems != null)
                            {
                                EntityExtension.FlagForUpdate(garmentDOItems, identityService.Username, USER_AGENT);
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + (decimal)oldGarmentUnitDeliveryOrderItem.Quantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;
                            }

                            oldGarmentUnitDeliveryOrderItem.Quantity          = garmentUnitDeliveryOrderItem.Quantity;
                            oldGarmentUnitDeliveryOrderItem.DefaultDOQuantity = garmentUnitDeliveryOrderItem.Quantity; // Jumlah DO awal mengikuti Jumlah yang diubah (reset)
                            oldGarmentUnitDeliveryOrderItem.FabricType        = garmentUnitDeliveryOrderItem.FabricType;
                        }
                        else
                        {
                            EntityExtension.FlagForCreate(garmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);
                            GarmentUnitReceiptNote garmentUnitReceiptNote = dbContext.GarmentUnitReceiptNotes.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNId);
                            garmentUnitDeliveryOrderItem.DOCurrencyRate = garmentUnitReceiptNote.DOCurrencyRate;
                            if (garmentUnitDeliveryOrderItem.DOCurrencyRate == 0)
                            {
                                throw new Exception("oldGarmentUnitDeliveryOrderItem.DOCurrencyRate tidak boleh 0");
                            }
                            oldGarmentUnitDeliveryOrder.Items.Add(garmentUnitDeliveryOrderItem);

                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNItemId);
                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                            // GarmentDOItems
                            GarmentDOItems garmentDOItems = dbSetGarmentDOItems.FirstOrDefault(w => w.Id == garmentUnitDeliveryOrderItem.DOItemsId);
                            if (garmentDOItems != null)
                            {
                                EntityExtension.FlagForUpdate(garmentDOItems, identityService.Username, USER_AGENT);
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;
                            }
                        }
                    }

                    foreach (var oldGarmentUnitDeliveryOrderItem in oldGarmentUnitDeliveryOrder.Items)
                    {
                        var newGarmentUnitDeliveryOrderItem = garmentUnitDeliveryOrder.Items.FirstOrDefault(i => i.Id == oldGarmentUnitDeliveryOrderItem.Id);
                        if (newGarmentUnitDeliveryOrderItem == null)
                        {
                            EntityExtension.FlagForDelete(oldGarmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);

                            GarmentUnitReceiptNote garmentUnitReceiptNote = dbContext.GarmentUnitReceiptNotes.Single(s => s.Id == oldGarmentUnitDeliveryOrderItem.URNId);


                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == oldGarmentUnitDeliveryOrderItem.URNItemId);
                            oldGarmentUnitDeliveryOrderItem.DOCurrencyRate = garmentUnitReceiptNoteItem.DOCurrencyRate;

                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity - (decimal)oldGarmentUnitDeliveryOrderItem.Quantity;

                            // GarmentDOItems
                            GarmentDOItems garmentDOItems = dbSetGarmentDOItems.FirstOrDefault(w => w.Id == oldGarmentUnitDeliveryOrderItem.DOItemsId);
                            if (garmentDOItems != null)
                            {
                                EntityExtension.FlagForUpdate(garmentDOItems, identityService.Username, USER_AGENT);
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + (decimal)oldGarmentUnitDeliveryOrderItem.Quantity;
                            }
                        }
                    }

                    // dbSet.Update(garmentUnitDeliveryOrder);

                    Updated = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Updated);
        }
Exemple #6
0
        public async Task <int> Create(GarmentReceiptCorrection m, string user, int clientTimeZoneOffset = 7)
        {
            int Created = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    EntityExtension.FlagForCreate(m, user, USER_AGENT);

                    m.CorrectionNo = await GenerateNo(m, clientTimeZoneOffset);

                    m.CorrectionDate = DateTimeOffset.Now;

                    if (m.CorrectionType == "Konversi")
                    {
                        GarmentReceiptCorrection outCorrection = new GarmentReceiptCorrection
                        {
                            CorrectionDate = m.CorrectionDate,
                            CorrectionNo   = m.CorrectionNo,
                            Remark         = m.Remark,
                            StorageCode    = m.StorageCode,
                            StorageId      = m.StorageId,
                            StorageName    = m.StorageName,
                            CorrectionType = m.CorrectionType,
                            UnitCode       = m.UnitCode,
                            UnitName       = m.UnitName,
                            UnitId         = m.UnitId,
                            URNId          = m.URNId,
                            URNNo          = m.URNNo,
                        };
                        List <GarmentReceiptCorrectionItem> itemsOut = new List <GarmentReceiptCorrectionItem>();
                        foreach (var outs in m.Items)
                        {
                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.FirstOrDefault(a => a.Id == outs.URNItemId);
                            double SmallQuantityOut = (double)garmentUnitReceiptNoteItem.ReceiptCorrection * (double)garmentUnitReceiptNoteItem.CorrectionConversion;
                            GarmentReceiptCorrectionItem outItem = new GarmentReceiptCorrectionItem
                            {
                                PricePerDealUnit     = outs.PricePerDealUnit,
                                POItemId             = outs.POItemId,
                                Conversion           = outs.Conversion,
                                SmallQuantity        = SmallQuantityOut,
                                DODetailId           = outs.DODetailId,
                                ProductCode          = outs.ProductCode,
                                ProductId            = outs.ProductId,
                                POSerialNumber       = outs.POSerialNumber,
                                ProductName          = outs.ProductName,
                                PRItemId             = outs.PRItemId,
                                ProductRemark        = outs.ProductRemark,
                                Quantity             = outs.Quantity,
                                CorrectionConversion = outs.CorrectionConversion,
                                CorrectionId         = outs.CorrectionId,
                                CorrectionQuantity   = outs.CorrectionQuantity,
                                DesignColor          = outs.DesignColor,
                                EPOItemId            = outs.EPOItemId,
                                RONo         = outs.RONo,
                                SmallUomId   = outs.SmallUomId,
                                SmallUomUnit = outs.SmallUomUnit,
                                UomId        = outs.UomId,
                                UomUnit      = outs.UomUnit,
                                URNItemId    = outs.URNItemId
                            };
                            itemsOut.Add(outItem);
                            var garmentInventorySummaryExistingOut = dbSetGarmentInventorySummary.SingleOrDefault(s => s.ProductId == outItem.ProductId && s.StorageId == outCorrection.StorageId && s.UomId == outItem.SmallUomId);

                            var garmentInventoryMovementOut = GenerateGarmentInventoryMovement(outCorrection, outItem, garmentInventorySummaryExistingOut, "OUT");
                            dbSetGarmentInventoryMovement.Add(garmentInventoryMovementOut);

                            if (garmentInventorySummaryExistingOut == null)
                            {
                                var garmentInventorySummaryOut = GenerateGarmentInventorySummary(outCorrection, outItem, garmentInventoryMovementOut);
                                dbSetGarmentInventorySummary.Add(garmentInventorySummaryOut);
                            }
                            else
                            {
                                EntityExtension.FlagForUpdate(garmentInventorySummaryExistingOut, identityService.Username, USER_AGENT);
                                garmentInventorySummaryExistingOut.Quantity = garmentInventoryMovementOut.After;
                            }



                            await dbContext.SaveChangesAsync();
                        }
                        outCorrection.Items = itemsOut;

                        var invOut = GenerateGarmentInventoryDocumentConv(outCorrection, "OUT");
                        dbSetGarmentInventoryDocument.Add(invOut);
                    }
                    var type = "IN";
                    foreach (var item in m.Items)
                    {
                        GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.FirstOrDefault(a => a.Id == item.URNItemId);
                        GarmentDOItems             garmentDOItems             = dbContext.GarmentDOItems.SingleOrDefault(x => x.URNItemId == item.URNItemId);

                        if (item.CorrectionQuantity < 0)
                        {
                            type = "OUT";
                        }

                        if (m.CorrectionType == "Jumlah")
                        {
                            item.CorrectionConversion = 0;
                            garmentUnitReceiptNoteItem.ReceiptCorrection += (decimal)item.CorrectionQuantity;

                            var garmentInventoryDocument = GenerateGarmentInventoryDocument(m, item, type);
                            dbSetGarmentInventoryDocument.Add(garmentInventoryDocument);

                            if (garmentDOItems != null)
                            {
                                garmentDOItems.RemainingQuantity += (decimal)item.SmallQuantity;
                            }
                        }
                        else
                        {
                            //decimal qty = (garmentUnitReceiptNoteItem.ReceiptCorrection - (garmentUnitReceiptNoteItem.OrderQuantity / garmentUnitReceiptNoteItem.CorrectionConversion))* garmentUnitReceiptNoteItem.CorrectionConversion;
                            //decimal newQty = (garmentUnitReceiptNoteItem.ReceiptCorrection - (garmentUnitReceiptNoteItem.OrderQuantity / garmentUnitReceiptNoteItem.CorrectionConversion)) * (decimal)item.CorrectionConversion;
                            //decimal diff = (newQty - qty)/(decimal)item.CorrectionConversion;
                            item.SmallQuantity = (double)garmentUnitReceiptNoteItem.ReceiptCorrection * item.CorrectionConversion;
                            //garmentUnitReceiptNoteItem.ReceiptCorrection += diff;
                            garmentUnitReceiptNoteItem.CorrectionConversion = (decimal)item.CorrectionConversion;

                            if (garmentDOItems != null)
                            {
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + ((garmentUnitReceiptNoteItem.CorrectionConversion * garmentUnitReceiptNoteItem.ReceiptCorrection) - garmentDOItems.RemainingQuantity);
                            }
                        }
                        EntityExtension.FlagForCreate(item, user, USER_AGENT);

                        var garmentInventorySummaryExisting = dbSetGarmentInventorySummary.SingleOrDefault(s => s.ProductId == item.ProductId && s.StorageId == m.StorageId && s.UomId == item.SmallUomId);


                        var garmentInventoryMovement = GenerateGarmentInventoryMovement(m, item, garmentInventorySummaryExisting, type);
                        dbSetGarmentInventoryMovement.Add(garmentInventoryMovement);

                        if (garmentInventorySummaryExisting == null)
                        {
                            var garmentInventorySummary = GenerateGarmentInventorySummary(m, item, garmentInventoryMovement);

                            dbSetGarmentInventorySummary.Add(garmentInventorySummary);
                        }
                        else
                        {
                            EntityExtension.FlagForUpdate(garmentInventorySummaryExisting, identityService.Username, USER_AGENT);
                            garmentInventorySummaryExisting.Quantity = garmentInventoryMovement.After;
                        }



                        await dbContext.SaveChangesAsync();
                    }

                    if (m.CorrectionType != "Jumlah")
                    {
                        var garmentInventoryDocumentConv = GenerateGarmentInventoryDocumentConv(m, type);
                        dbSetGarmentInventoryDocument.Add(garmentInventoryDocumentConv);
                    }

                    this.dbSet.Add(m);

                    Created = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Created);
        }
        public async Task <int> Update(int id, GarmentUnitDeliveryOrder garmentUnitDeliveryOrder)
        {
            int Updated = 0;

            using (var transaction = this.dbContext.Database.BeginTransaction())
            {
                try
                {
                    garmentUnitDeliveryOrder.Items = garmentUnitDeliveryOrder.Items.Where(x => x.IsSave).ToList();

                    var oldGarmentUnitDeliveryOrder = dbSet
                                                      .Include(d => d.Items)
                                                      //.AsNoTracking()
                                                      .Single(m => m.Id == id);

                    EntityExtension.FlagForUpdate(oldGarmentUnitDeliveryOrder, identityService.Username, USER_AGENT);

                    foreach (var garmentUnitDeliveryOrderItem in garmentUnitDeliveryOrder.Items)
                    {
                        if (garmentUnitDeliveryOrderItem.Id != 0)
                        {
                            var oldGarmentUnitDeliveryOrderItem = oldGarmentUnitDeliveryOrder.Items.FirstOrDefault(i => i.Id == garmentUnitDeliveryOrderItem.Id);

                            EntityExtension.FlagForUpdate(oldGarmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);
                            GarmentDeliveryOrderDetail doDetail = dbContext.GarmentDeliveryOrderDetails.Single(s => s.Id.Equals(garmentUnitDeliveryOrderItem.DODetailId));

                            doDetail.ReturQuantity = doDetail.ReturQuantity - oldGarmentUnitDeliveryOrderItem.ReturQuantity + garmentUnitDeliveryOrderItem.ReturQuantity;

                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == oldGarmentUnitDeliveryOrderItem.URNItemId);
                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity - (decimal)oldGarmentUnitDeliveryOrderItem.Quantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                            GarmentDOItems garmentDOItems = dbContext.GarmentDOItems.SingleOrDefault(x => x.URNItemId == garmentUnitDeliveryOrderItem.URNItemId);
                            if (garmentDOItems != null)
                            {
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + (decimal)oldGarmentUnitDeliveryOrderItem.Quantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;
                            }

                            oldGarmentUnitDeliveryOrderItem.Quantity          = garmentUnitDeliveryOrderItem.Quantity;
                            oldGarmentUnitDeliveryOrderItem.ReturQuantity     = garmentUnitDeliveryOrderItem.ReturQuantity;
                            oldGarmentUnitDeliveryOrderItem.DefaultDOQuantity = garmentUnitDeliveryOrderItem.DefaultDOQuantity;
                        }
                        else
                        {
                            EntityExtension.FlagForCreate(garmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);
                            oldGarmentUnitDeliveryOrder.Items.Add(garmentUnitDeliveryOrderItem);
                            GarmentDeliveryOrderDetail doDetail = dbContext.GarmentDeliveryOrderDetails.Single(s => s.Id.Equals(garmentUnitDeliveryOrderItem.DODetailId));

                            doDetail.ReturQuantity = doDetail.ReturQuantity + garmentUnitDeliveryOrderItem.ReturQuantity;

                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == garmentUnitDeliveryOrderItem.URNItemId);
                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity + (decimal)garmentUnitDeliveryOrderItem.Quantity;

                            GarmentDOItems garmentDOItems = dbContext.GarmentDOItems.SingleOrDefault(x => x.URNItemId == garmentUnitDeliveryOrderItem.URNItemId);
                            if (garmentDOItems != null)
                            {
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity - (decimal)garmentUnitDeliveryOrderItem.Quantity;
                            }
                        }
                    }

                    foreach (var oldGarmentUnitDeliveryOrderItem in oldGarmentUnitDeliveryOrder.Items)
                    {
                        var newGarmentUnitDeliveryOrderItem = garmentUnitDeliveryOrder.Items.FirstOrDefault(i => i.Id == oldGarmentUnitDeliveryOrderItem.Id);
                        if (newGarmentUnitDeliveryOrderItem == null)
                        {
                            EntityExtension.FlagForDelete(oldGarmentUnitDeliveryOrderItem, identityService.Username, USER_AGENT);
                            GarmentDeliveryOrderDetail doDetail = dbContext.GarmentDeliveryOrderDetails.Single(s => s.Id.Equals(oldGarmentUnitDeliveryOrderItem.DODetailId));

                            doDetail.ReturQuantity = doDetail.ReturQuantity - oldGarmentUnitDeliveryOrderItem.ReturQuantity;

                            GarmentUnitReceiptNoteItem garmentUnitReceiptNoteItem = dbContext.GarmentUnitReceiptNoteItems.Single(s => s.Id == oldGarmentUnitDeliveryOrderItem.URNItemId);
                            EntityExtension.FlagForUpdate(garmentUnitReceiptNoteItem, identityService.Username, USER_AGENT);
                            garmentUnitReceiptNoteItem.OrderQuantity = garmentUnitReceiptNoteItem.OrderQuantity - (decimal)oldGarmentUnitDeliveryOrderItem.Quantity;

                            GarmentDOItems garmentDOItems = dbContext.GarmentDOItems.SingleOrDefault(x => x.URNItemId == oldGarmentUnitDeliveryOrderItem.URNItemId);
                            if (garmentDOItems != null)
                            {
                                garmentDOItems.RemainingQuantity = garmentDOItems.RemainingQuantity + (decimal)oldGarmentUnitDeliveryOrderItem.Quantity;
                            }
                        }
                    }

                    //dbSet.Update(garmentUnitDeliveryOrder);

                    Updated = await dbContext.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw new Exception(e.Message);
                }
            }

            return(Updated);
        }