public async Task <int> CreateAsync(GarmentLeftoverWarehouseExpenditureFinishedGood model)
        {
            int Created = 0;

            using (var transaction = DbContext.Database.CurrentTransaction ?? DbContext.Database.BeginTransaction())
            {
                try
                {
                    model.FlagForCreate(IdentityService.Username, UserAgent);
                    model.FlagForUpdate(IdentityService.Username, UserAgent);

                    model.FinishedGoodExpenditureNo = GenerateNo(model);

                    foreach (var item in model.Items)
                    {
                        item.FlagForCreate(IdentityService.Username, UserAgent);
                        item.FlagForUpdate(IdentityService.Username, UserAgent);
                    }
                    DbSet.Add(model);

                    Created = await DbContext.SaveChangesAsync();

                    foreach (var item in model.Items)
                    {
                        GarmentLeftoverWarehouseStock stock = new GarmentLeftoverWarehouseStock
                        {
                            ReferenceType        = GarmentLeftoverWarehouseStockReferenceTypeEnum.FINISHED_GOOD,
                            UnitId               = item.UnitId,
                            UnitCode             = item.UnitCode,
                            UnitName             = item.UnitName,
                            RONo                 = item.RONo,
                            Quantity             = item.ExpenditureQuantity,
                            LeftoverComodityCode = item.LeftoverComodityCode,
                            LeftoverComodityId   = item.LeftoverComodityId,
                            LeftoverComodityName = item.LeftoverComodityName
                        };
                        await StockService.StockOut(stock, model.FinishedGoodExpenditureNo, model.Id, item.Id);
                    }

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

            return(Created);
        }
        public async Task <int> UpdateAsync(int id, GarmentLeftoverWarehouseExpenditureFinishedGood model)
        {
            using (var transaction = DbContext.Database.CurrentTransaction ?? DbContext.Database.BeginTransaction())
            {
                try
                {
                    int Updated = 0;

                    GarmentLeftoverWarehouseExpenditureFinishedGood existingModel = await ReadByIdAsync(id);

                    if (existingModel.ExpenditureDate != model.ExpenditureDate)
                    {
                        existingModel.ExpenditureDate = model.ExpenditureDate;
                    }
                    if (existingModel.Consignment != model.Consignment)
                    {
                        existingModel.Consignment = model.Consignment;
                    }
                    if (existingModel.Description != model.Description)
                    {
                        existingModel.Description = model.Description;
                    }
                    existingModel.FlagForUpdate(IdentityService.Username, UserAgent);

                    foreach (var existingItem in existingModel.Items)
                    {
                        GarmentLeftoverWarehouseStock stockIn = new GarmentLeftoverWarehouseStock
                        {
                            ReferenceType        = GarmentLeftoverWarehouseStockReferenceTypeEnum.FINISHED_GOOD,
                            UnitId               = existingItem.UnitId,
                            UnitCode             = existingItem.UnitCode,
                            UnitName             = existingItem.UnitName,
                            RONo                 = existingItem.RONo,
                            Quantity             = existingItem.ExpenditureQuantity,
                            LeftoverComodityCode = existingItem.LeftoverComodityCode,
                            LeftoverComodityId   = existingItem.LeftoverComodityId,
                            LeftoverComodityName = existingItem.LeftoverComodityName
                        };

                        await StockService.StockIn(stockIn, model.FinishedGoodExpenditureNo, model.Id, existingItem.Id);
                    }

                    foreach (var existingItem in existingModel.Items)
                    {
                        var item = model.Items.FirstOrDefault(i => i.Id == existingItem.Id);
                        if (item == null)
                        {
                            existingItem.FlagForDelete(IdentityService.Username, UserAgent);
                        }
                        else
                        {
                            if (existingItem.ExpenditureQuantity != item.ExpenditureQuantity)
                            {
                                existingItem.ExpenditureQuantity = item.ExpenditureQuantity;
                            }
                            existingItem.FlagForUpdate(IdentityService.Username, UserAgent);
                        }
                    }

                    foreach (var item in model.Items.Where(i => i.Id == 0))
                    {
                        item.FlagForCreate(IdentityService.Username, UserAgent);
                        item.FlagForUpdate(IdentityService.Username, UserAgent);
                        existingModel.Items.Add(item);
                    }

                    Updated = await DbContext.SaveChangesAsync();

                    foreach (var item in model.Items)
                    {
                        GarmentLeftoverWarehouseStock stock = new GarmentLeftoverWarehouseStock
                        {
                            ReferenceType        = GarmentLeftoverWarehouseStockReferenceTypeEnum.FINISHED_GOOD,
                            UnitId               = item.UnitId,
                            UnitCode             = item.UnitCode,
                            UnitName             = item.UnitName,
                            RONo                 = item.RONo,
                            Quantity             = item.ExpenditureQuantity,
                            LeftoverComodityCode = item.LeftoverComodityCode,
                            LeftoverComodityId   = item.LeftoverComodityId,
                            LeftoverComodityName = item.LeftoverComodityName
                        };

                        await StockService.StockOut(stock, model.FinishedGoodExpenditureNo, model.Id, item.Id);
                    }

                    transaction.Commit();

                    return(Updated);
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw e;
                }
            }
        }