コード例 #1
0
        public async Task <IActionResult> PutCustomer(long id, Customer customer)
        {
            if (id != customer.CustomerId)
            {
                return(BadRequest());
            }

            _context.Entry(customer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CustomerExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #2
0
        public async Task <IActionResult> PutUnit(int id, Unit unit)
        {
            if (id != unit.UnitId)
            {
                return(BadRequest());
            }

            _context.Entry(unit).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UnitExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #3
0
        public async Task <IActionResult> PutBankInfo(int id, BankInfo bankInfo)
        {
            if (id != bankInfo.Id)
            {
                return(BadRequest());
            }

            _context.Entry(bankInfo).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BankInfoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #4
0
        public async Task <IActionResult> PutRole(long id, Role role)
        {
            if (id != role.Id)
            {
                return(BadRequest());
            }

            _context.Entry(role).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RoleExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #5
0
        public async Task <IActionResult> PutInventory(long id, Inventory inventory)
        {
            if (id != inventory.InventoryId)
            {
                return(BadRequest());
            }

            _context.Entry(inventory).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!InventoryExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #6
0
        public async Task <IActionResult> PutFabricPurchaseItem(long id, FabricPurchaseItem fabricPurchaseItem)
        {
            if (id != fabricPurchaseItem.FabricPurchaseItemId)
            {
                return(BadRequest());
            }

            _context.Entry(fabricPurchaseItem).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!FabricPurchaseItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #7
0
        public async Task <IActionResult> PutTblAccount(long id, TblAccount tblAccount)
        {
            if (id != tblAccount.AccountId)
            {
                return(BadRequest());
            }

            _context.Entry(tblAccount).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TblAccountExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #8
0
        public async Task <IActionResult> PutAccountTransaction(long id, AccountTransaction accountTransaction)
        {
            if (id != accountTransaction.AccountTransactionId)
            {
                return(BadRequest());
            }

            _context.Entry(accountTransaction).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AccountTransactionExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #9
0
        public async Task <IActionResult> PutSaleContractItem(long id, SaleContractItem saleContractItem)
        {
            if (id != saleContractItem.SaleContractItemId)
            {
                return(BadRequest());
            }
            _context.Entry(saleContractItem).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SaleContractItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            var allSaleContractItems = _context.SaleContractItems.Where(x => x.SaleContractId == saleContractItem.SaleContractId).ToList();
            var saleContract         = await _context.SaleContracts.FindAsync(saleContractItem.SaleContractId);

            saleContract.TotalAmount = 0;
            foreach (var item in allSaleContractItems)
            {
                saleContract.TotalAmount = saleContract.TotalAmount + item.Amount;
            }

            decimal?TotalFabric = 0;

            foreach (var item in allSaleContractItems)
            {
                TotalFabric = TotalFabric + item.Quantity;
            }
            saleContract.TotalFabric = TotalFabric.ToString();

            _context.Entry(saleContract).State = EntityState.Modified;
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SaleContractItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            // Get Receivable and Add Credit Entry in Account
            var receivableExist             = _context.Receivables.Where(x => x.CustomerId == saleContract.CustomerId).FirstOrDefault();
            var payableExist                = _context.Payables.Where(x => x.PayableName == saleContract.SaleContractNumber && x.IsActive == true).FirstOrDefault();
            var tblAccountReceivable        = _context.TblAccounts.Where(x => x.ReceivablesId == receivableExist.ReceivableId).FirstOrDefault();
            var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == saleContract.SaleContractNumber && x.PayableId == payableExist.PayableId).FirstOrDefault();

            // Add Double Entry of Receivable (DR) and Sale Contract Account (CR) => Update only Amount Debit and Credit
            var accountTransaction = _context.AccountTransactions.Where(x => x.AccountDebitId == tblAccountReceivable.AccountId && x.AccountCreditId == tblAccountSaleContractExist.AccountId && x.AccountCreditCode == tblAccountSaleContractExist.AccountCode).FirstOrDefault();

            accountTransaction.AmountDebit  = saleContract.TotalAmount;
            accountTransaction.AmountCredit = saleContract.TotalAmount;

            _context.Entry(accountTransaction).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SaleContractItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }


            return(NoContent());
        }
コード例 #10
0
        public async Task <IActionResult> PutFabricPurchase(long id, FabricPurchase fabricPurchase)
        {
            if (id != fabricPurchase.FabricPurchaseId)
            {
                return(BadRequest());
            }

            _context.Entry(fabricPurchase).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();

                var payableExist = _context.Payables.Where(x => x.PayableId == fabricPurchase.Weaver && x.IsActive == true).FirstOrDefault();

                if (payableExist != null)
                {
                    var tblAccountPayableExist = _context.TblAccounts.Where(x => x.AccountCode == payableExist.PayableId.ToString() && x.AccountTitle == payableExist.PayableName && x.PayableId == payableExist.PayableId).FirstOrDefault();
                    if (tblAccountPayableExist != null)
                    {
                        var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == fabricPurchase.SaleContractNumber).FirstOrDefault();
                        // Edit Double Entry of Payable (CR) and Sale Contract Account (DR)

                        var accountTransactionExist = _context.AccountTransactions.Where(x => x.AccountCreditCode == tblAccountPayableExist.AccountCode && x.AccountCreditId == tblAccountPayableExist.AccountId && x.Type == _context.TransactionTypes.Where(x => x.TransactionTypeName == "FabricPurchase").Select(x => x.TransactionTypeId).FirstOrDefault()).FirstOrDefault();


                        accountTransactionExist.Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "FabricPurchase").Select(x => x.TransactionTypeId).FirstOrDefault();
                        //accountTransactionExist.AccountDebitId = tblAccountSaleContractExist.AccountId;
                        //accountTransactionExist.AccountCreditId = tblAccountPayableExist.AccountId;
                        //accountTransactionExist.AccountDebitCode = tblAccountSaleContractExist.AccountCode;
                        //accountTransactionExist.AccountCreditCode = tblAccountPayableExist.AccountCode;
                        accountTransactionExist.Narration    = "Fabric Purchase Contract Update";
                        accountTransactionExist.AmountDebit  = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate;
                        accountTransactionExist.AmountCredit = fabricPurchase.QuantityInMeters * fabricPurchase.PerMeterRate;
                        //accountTransactionExist.SaleContractNumber = fabricPurchase.SaleContractNumber;
                        accountTransactionExist.DateUpdated = DateTime.Now;
                        accountTransactionExist.IsActive    = true;


                        _context.Entry(accountTransactionExist).State = EntityState.Modified;
                        try
                        {
                            await _context.SaveChangesAsync();
                        }
                        catch (Exception ex)
                        {
                            var x = 0;
                        }
                    }
                }
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!FabricPurchaseExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #11
0
        public async Task <IActionResult> PutSaleContractExpense(long id, SaleContractExpense saleContractExpense)
        {
            if (id != saleContractExpense.ExpenseId)
            {
                return(BadRequest());
            }

            _context.Entry(saleContractExpense).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SaleContractExpenseExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }


            var saleContractAccountExist  = _context.TblAccounts.Where(x => x.AccountCode == saleContractExpense.SaleContractNumber).FirstOrDefault();
            var paymentSourceAccountExist = _context.TblAccounts.Where(x => x.AccountId == saleContractExpense.PaymentSourceAccountId).FirstOrDefault();

            if (saleContractAccountExist != null)
            {
                var saleContractAccountTransactionExist = _context.AccountTransactions.Where(x => x.AccountDebitId == saleContractAccountExist.AccountId && x.AccountCreditId == paymentSourceAccountExist.AccountId).FirstOrDefault();

                if (saleContractAccountTransactionExist != null)
                {
                    saleContractAccountTransactionExist.Type               = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SaleContractExpense").Select(x => x.TransactionTypeId).FirstOrDefault();
                    saleContractAccountTransactionExist.AccountDebitId     = saleContractAccountExist.AccountId;
                    saleContractAccountTransactionExist.AccountCreditId    = paymentSourceAccountExist.AccountId;
                    saleContractAccountTransactionExist.AccountDebitCode   = saleContractAccountExist.AccountCode;
                    saleContractAccountTransactionExist.AccountCreditCode  = paymentSourceAccountExist.AccountCode;
                    saleContractAccountTransactionExist.Narration          = saleContractExpense.Description;
                    saleContractAccountTransactionExist.AmountDebit        = saleContractExpense.Amount;
                    saleContractAccountTransactionExist.AmountCredit       = saleContractExpense.Amount;
                    saleContractAccountTransactionExist.SaleContractNumber = saleContractExpense.SaleContractNumber;
                    saleContractAccountTransactionExist.DateAdded          = DateTime.Now;
                    saleContractAccountTransactionExist.IsActive           = true;

                    _context.Entry(saleContractAccountTransactionExist).State = EntityState.Modified;
                    try
                    {
                        await _context.SaveChangesAsync();
                    }
                    catch (Exception ex)
                    {
                        var x = 0;
                    }
                }
                else
                {
                    // Add Double Entry of Sale Contract Account (DR) and Cash/Bank Account (CR)
                    AccountTransaction accountTransaction = new AccountTransaction()
                    {
                        Type               = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SaleContractExpense").Select(x => x.TransactionTypeId).FirstOrDefault(),
                        AccountDebitId     = saleContractAccountExist.AccountId,
                        AccountCreditId    = paymentSourceAccountExist.AccountId,
                        AccountDebitCode   = saleContractAccountExist.AccountCode,
                        AccountCreditCode  = paymentSourceAccountExist.AccountCode,
                        Narration          = saleContractExpense.Description,
                        AmountDebit        = saleContractExpense.Amount,
                        AmountCredit       = saleContractExpense.Amount,
                        SaleContractNumber = saleContractExpense.SaleContractNumber,
                        DateAdded          = DateTime.Now,
                        IsActive           = true
                    };
                    _context.AccountTransactions.Add(accountTransaction);
                    try
                    {
                        await _context.SaveChangesAsync();
                    }
                    catch (Exception ex)
                    {
                        var x = 0;
                    }
                }
            }

            return(NoContent());
        }
コード例 #12
0
        public async Task <IActionResult> PutSaleContract(long id, SaleContract saleContract)
        {
            if (id != saleContract.SaleContractId)
            {
                return(BadRequest());
            }

            _context.Entry(saleContract).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();

                var receivableExist = _context.Receivables.Where(x => x.CustomerId == saleContract.CustomerId && x.IsActive == true).FirstOrDefault();

                var payableExist = _context.Payables.Where(x => x.PayableName == saleContract.SaleContractNumber && x.IsActive == true).FirstOrDefault();

                if (receivableExist != null)
                {
                    var tblAccountSaleContractExist = _context.TblAccounts.Where(x => x.AccountCode == saleContract.SaleContractNumber && x.PayableId == payableExist.PayableId).FirstOrDefault();

                    // Edit Sale Contract Account

                    tblAccountSaleContractExist.AccountCode           = saleContract.SaleContractNumber;
                    tblAccountSaleContractExist.AccountDescription    = saleContract.SaleContractNumber;
                    tblAccountSaleContractExist.AccountTitle          = saleContract.SaleContractNumber;
                    tblAccountSaleContractExist.AccountTypeId         = _context.AccountTypes.Where(x => x.AccountTypeName == "Liabilities").Select(x => x.AccountTypeId).FirstOrDefault();
                    tblAccountSaleContractExist.DateAdded             = DateTime.Now;
                    tblAccountSaleContractExist.IsActive              = true;
                    tblAccountSaleContractExist.PayableId             = payableExist.PayableId;
                    _context.Entry(tblAccountSaleContractExist).State = EntityState.Modified;
                    await _context.SaveChangesAsync();

                    var tblAccountReceivable = _context.TblAccounts.Where(x => x.AccountCode == receivableExist.ReceivableId.ToString() && x.AccountTitle == receivableExist.ReceivableName && x.ReceivablesId == receivableExist.ReceivableId).FirstOrDefault();
                    // Edit Double Entry of Receivable (DR) and Sale Contract Account (CR)

                    var accountTransactionExist = _context.AccountTransactions.Where(x => x.AccountCreditCode == tblAccountSaleContractExist.AccountCode && x.AccountCreditId == tblAccountSaleContractExist.AccountId && x.Type == _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault()).FirstOrDefault();

                    accountTransactionExist.Type               = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault();
                    accountTransactionExist.AccountDebitId     = tblAccountReceivable.AccountId;
                    accountTransactionExist.AccountCreditId    = tblAccountSaleContractExist.AccountId;
                    accountTransactionExist.AccountDebitCode   = tblAccountReceivable.AccountCode;
                    accountTransactionExist.AccountCreditCode  = tblAccountSaleContractExist.AccountCode;
                    accountTransactionExist.Narration          = "Sale Contract Creation";
                    accountTransactionExist.AmountDebit        = saleContract.TotalAmount;
                    accountTransactionExist.AmountCredit       = saleContract.TotalAmount;
                    accountTransactionExist.SaleContractNumber = saleContract.SaleContractNumber;
                    accountTransactionExist.DateUpdated        = DateTime.Now;
                    accountTransactionExist.IsActive           = true;

                    _context.Entry(accountTransactionExist).State = EntityState.Modified;
                    await _context.SaveChangesAsync();

                    //AccountTransaction accountTransaction = new AccountTransaction()
                    //{
                    //    Type = _context.TransactionTypes.Where(x => x.TransactionTypeName == "SalesContract").Select(x => x.TransactionTypeId).FirstOrDefault(),
                    //    AccountDebitId = tblAccountReceivable.AccountId,
                    //    AccountCreditId = tblAccountSaleContract.AccountId,
                    //    AccountDebitCode = tblAccountReceivable.AccountCode,
                    //    AccountCreditCode = tblAccountSaleContract.AccountCode,
                    //    Narration = "Sale Contract Creation",
                    //    AmountDebit = saleContract.TotalAmount,
                    //    AmountCredit = saleContract.TotalAmount,
                    //    SaleContractNumber = saleContract.SaleContractNumber,
                    //    DateAdded = DateTime.Now,
                    //    IsActive = true
                    //};
                }
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!SaleContractExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }