public async Task <IActionResult> AddEditPaymentDetails(int id, [Bind("Amount, InvoiceNumber, CardEndingNumber, CardType, EDCId, EDCTranscationId, OnDate, StoreId")] EDCTranscation eDC)
{
if (ModelState.IsValid)
{
//Insert
if (eDC.EDCTranscationId == 0)
{
db.Add(eDC);
await db.SaveChangesAsync();
}
//Update
else
{
try
{
db.Update(eDC);
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CardTranscationExists(eDC.EDCTranscationId))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "Index", db.CardTranscations.ToList()) }));
}
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "AddEditPaymentDetails", eDC) }));
//TODO: here we need to refresh index page update/add opertation if required other wise no need call this function just pass is valid or not.
}
public async Task <IActionResult> Edit(string id, [Bind("FirstName,LastName,IsEmployee,EmployeeId,IsWorking,Id,UserName,NormalizedUserName,Email,NormalizedEmail,EmailConfirmed,PasswordHash,SecurityStamp,ConcurrencyStamp,PhoneNumber,PhoneNumberConfirmed,TwoFactorEnabled,LockoutEnd,LockoutEnabled,AccessFailedCount")] AppUser appUser)
{
if (id != appUser.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(appUser);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AppUserExists(appUser.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(appUser));
}
public async Task <IActionResult> Edit(int id, [Bind("ContactId,FirstName,LastName,MobileNo,PhoneNo,EMailAddress,Remarks")] Contact contact)
{
if (id != contact.ContactId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contact);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactExists(contact.ContactId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(contact));
}
public async Task <IActionResult> Edit(int id, [Bind("ElectricityConnectionId,LocationName,ConnectioName,City,State,PinCode,ConsumerNumber,ConusumerId,Connection,ConnectinDate,DisconnectionDate,KVLoad,OwnedMetter,TotalConnectionCharges,SecurityDeposit,Remarks,StoreId,UserId,IsReadOnly")] ElectricityConnection electricityConnection)
{
if (id != electricityConnection.ElectricityConnectionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(electricityConnection);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElectricityConnectionExists(electricityConnection.ElectricityConnectionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", electricityConnection.StoreId);
return(View(electricityConnection));
}
public async Task <IActionResult> Edit(int id, [Bind("OnlineVendorId,VendorName,OnDate,IsActive,Remark,OffDate,Reason")] OnlineVendor onlineVendor)
{
if (id != onlineVendor.OnlineVendorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(onlineVendor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OnlineVendorExists(onlineVendor.OnlineVendorId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(onlineVendor));
}
public async Task <IActionResult> Edit(int id, [Bind("DueRecoverdId,PaidDate,DuesListId,AmountPaid,IsPartialPayment,Modes,Remarks,StoreId,UserId")] DueRecoverd dueRecoverd)
{
if (id != dueRecoverd.DueRecoverdId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(dueRecoverd);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DueRecoverdExists(dueRecoverd.DueRecoverdId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DuesListId"] = new SelectList(_context.DuesLists.Include(c => c.DailySale), "DuesListId", "InvNo", dueRecoverd.DuesListId);
// ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", dueRecoverd.StoreId);
return(View(dueRecoverd));
}
public async Task <IActionResult> Edit(int id, [Bind("StoreHolidayId,OnDate,Reason,Remarks,ApprovedBy,StoreId,UserId,EntryStatus,IsReadOnly")] StoreHoliday storeHoliday)
{
if (id != storeHoliday.StoreHolidayId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(storeHoliday);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StoreHolidayExists(storeHoliday.StoreHolidayId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", storeHoliday.StoreId);
return(PartialView(storeHoliday));
}
public async Task <IActionResult> Edit(int id, [Bind("CustomerId,FirstName,LastName,Age,DateOfBirth,City,MobileNo,Gender,NoOfBills,TotalAmount,CreatedDate")] Customer customer)
{
if (id != customer.CustomerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(customer);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(customer.CustomerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(customer));
}
public async Task <IActionResult> Edit(int id, [Bind("OnlineSaleReturnId,OnlineSaleId,ReturnDate,InvNo,Amount,VoyagerInvoiceNo,VoygerDate,VoyagerAmount,Remarks,IsRecived,RecivedDate")] OnlineSaleReturn onlineSaleReturn)
{
if (id != onlineSaleReturn.OnlineSaleReturnId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
// onlineSaleReturn.UserName = User.Identity.Name;
_context.Update(onlineSaleReturn);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OnlineSaleReturnExists(onlineSaleReturn.OnlineSaleReturnId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
// ViewData["OnlineSaleId"] = new SelectList(_context.OnlineSale, "OnlineSaleId", "InvNo", onlineSaleReturn.OnlineSaleId);
// ViewData["OnlineVendorId"] = new SelectList(_context.OnlineVendor, "OnlineVendorId", "OnlineVendorId", onlineSaleReturn.OnlineVendorId);
return(PartialView(onlineSaleReturn));
}
public async Task <IActionResult> Edit(int id, [Bind("TalioringDeliveryId,DeliveryDate,TalioringBookingId,InvNo,Amount,Remarks,StoreId,UserId,EntryStatus,IsReadOnly")] TalioringDelivery talioringDelivery)
{
if (id != talioringDelivery.TalioringDeliveryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
new TailorManager().OnUpdateData(_context, talioringDelivery, true, false);
_context.Update(talioringDelivery);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TalioringDeliveryExists(talioringDelivery.TalioringDeliveryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TalioringBookingId"] = new SelectList(_context.TalioringBookings, "TalioringBookingId", "BookingSlipNo", talioringDelivery.TalioringBookingId);
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", talioringDelivery.StoreId);
return(View(talioringDelivery));
}
public async Task <IActionResult> Edit(int id, [Bind("EmployeeId,FirstName,LastName,MobileNo,JoiningDate,LeavingDate,IsWorking,Category,IsTailors,EMail,DateOfBirth,AdharNumber,PanNo,OtherIdDetails,Address,City,State,FatherName,HighestQualification,StoreId,UserId,EntryStatus,IsReadOnly")] Employee employee)
{
if (id != employee.EmployeeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employee.EmployeeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
// ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", employee.StoreId);
StoreInfo storeInfo = PostLogin.ReadStoreInfo(HttpContext.Session);
ViewData["StoreId"] = storeInfo.StoreId;
ViewData["UserName"] = storeInfo.UserName;
return(PartialView(employee));
}
public async Task <IActionResult> Edit(int id, [Bind("EletricityBillId,ElectricityConnectionId,BillNumber,BillDate,MeterReadingDate,CurrentMeterReading,TotalUnit,CurrentAmount,ArrearAmount,NetDemand,StoreId,UserId,IsReadOnly")] EletricityBill eletricityBill)
{
if (id != eletricityBill.EletricityBillId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eletricityBill);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EletricityBillExists(eletricityBill.EletricityBillId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ElectricityConnectionId"] = new SelectList(_context.ElectricityConnections, "ElectricityConnectionId", "ElectricityConnectionId", eletricityBill.ElectricityConnectionId);
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", eletricityBill.StoreId);
return(PartialView(eletricityBill));
}
public async Task <IActionResult> Edit(int id, [Bind("TalioringBookingId,BookingDate,CustName,DeliveryDate,TryDate,BookingSlipNo,TotalAmount,TotalQty,ShirtQty,ShirtPrice,PantQty,PantPrice,CoatQty,CoatPrice,KurtaQty,KurtaPrice,BundiQty,BundiPrice,Others,OthersPrice,IsDelivered,StoreId,UserId,EntryStatus,IsReadOnly")] TalioringBooking talioringBooking)
{
if (id != talioringBooking.TalioringBookingId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(talioringBooking);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TalioringBookingExists(talioringBooking.TalioringBookingId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", talioringBooking.StoreId);
return(View(talioringBooking));
}
public async Task <IActionResult> Edit(int id, [Bind("CashReceiptId,InwardDate,TranscationModeId,ReceiptFrom,Amount,SlipNo,Remarks,StoreId,UserId,EntryStatus,IsReadOnly")] CashReceipt cashReceipt)
{
if (id != cashReceipt.CashReceiptId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cashReceipt);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CashReceiptExists(cashReceipt.CashReceiptId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["TranscationModeId"] = new SelectList(_context.TranscationModes, "TranscationModeId", "Transcation", cashReceipt.TranscationModeId);
// ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", cashReceipt.StoreId);
return(View(cashReceipt));
}
public static async Task AddSaleman(eStoreDbContext db, Employee employee)
{
Console.WriteLine($"Emp Name= {employee.FirstName}");
if (DBDataChecker.IsSalesmanExists(db, employee.FirstName + " " + employee.LastName, employee.StoreId))
{
var sm = db.Salesmen.Where(c => c.SalesmanName == employee.FirstName + " " + employee.LastName && c.StoreId == employee.StoreId).First();
sm.EmployeeId = employee.EmployeeId; sm.EntryStatus = EntryStatus.Updated;
db.Update(sm);
}
else
{
Console.WriteLine($"Emp Name= {employee.FirstName}");
Salesman sm = new Salesman
{
EmployeeId = employee.EmployeeId,
IsReadOnly = true,
SalesmanName = employee.FirstName + " " + employee.LastName,
StoreId = employee.StoreId,
UserId = employee.UserId,
EntryStatus = EntryStatus.Added
};
db.Salesmen.Add(sm);
}
await db.SaveChangesAsync();
}
public async Task <IActionResult> Edit(int id, [Bind("TranscationModeId,Transcation")] TranscationMode transcationMode)
{
if (id != transcationMode.TranscationModeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(transcationMode);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TranscationModeExists(transcationMode.TranscationModeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(transcationMode));
}
public async Task <IActionResult> Edit(int id, [Bind("PartyId,PartyName,OpenningDate,OpenningBalance,Address,PANNo,GSTNo,LedgerTypeId")] Party party)
{
if (id != party.PartyId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(party);
await _context.SaveChangesAsync();
AccountOperation.UpdateLedgerMaster(_context, party);
}
catch (DbUpdateConcurrencyException)
{
if (!PartyExists(party.PartyId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["LedgerTypeId"] = new SelectList(_context.LedgerTypes, "LedgerTypeId", "LedgerNameType", party.LedgerTypeId);
return(PartialView(party));
}
public async Task <IActionResult> Edit(int id, [Bind("EBillPaymentId,EletricityBillId,PaymentDate,Amount,Mode,PaymentDetails,Remarks,IsPartialPayment,IsBillCleared,StoreId,UserId,EntryStatus,IsReadOnly")] EBillPayment eBillPayment)
{
if (id != eBillPayment.EBillPaymentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eBillPayment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EBillPaymentExists(eBillPayment.EBillPaymentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EletricityBillId"] = new SelectList(_context.EletricityBills, "EletricityBillId", "BillNumber", eBillPayment.EletricityBillId);
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", eBillPayment.StoreId);
return(View(eBillPayment));
}
public async Task <IActionResult> Edit(int id, [Bind("OnlineSaleId,SaleDate,InvNo,Amount,VoyagerInvoiceNo,VoygerDate,VoyagerAmount,ShippingMode,VendorFee,ProfitValue,Remarks,OnlineVendorId")] OnlineSale OnlineSales)
{
if (id != OnlineSales.OnlineSaleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
// OnlineSales.UserName = User.Identity.Name;
_context.Update(OnlineSales);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OnlineSaleExists(OnlineSales.OnlineSaleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["OnlineVendorId"] = new SelectList(_context.Set <OnlineVendor>(), "OnlineVendorId", "OnlineVendorId", OnlineSales.OnlineVendorId);
return(PartialView(OnlineSales));
}
public async Task <IActionResult> Edit(int id, [Bind("LedgerTypeId,LedgerNameType,Category,Remark")] LedgerType ledgerType)
{
if (id != ledgerType.LedgerTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ledgerType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LedgerTypeExists(ledgerType.LedgerTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(ledgerType));
}
public async Task <IActionResult> Edit(int id, [Bind("RentId,RentedLocationId,RentType,OnDate,Period,Amount,Mode,PaymentDetails,Remarks,StoreId,UserId,EntryStatus,IsReadOnly")] Rent rent)
{
if (id != rent.RentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rent);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RentExists(rent.RentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["RentedLocationId"] = new SelectList(_context.RentedLocations, "RentedLocationId", "PlaceName", rent.RentedLocationId);
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", rent.StoreId);
return(PartialView(rent));
}
public async Task <IActionResult> Edit(int id, [Bind("PurchaseTaxTypeId,TaxName,TaxType,CompositeRate")] PurchaseTaxType purchaseTaxType)
{
if (id != purchaseTaxType.PurchaseTaxTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(purchaseTaxType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PurchaseTaxTypeExists(purchaseTaxType.PurchaseTaxTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(purchaseTaxType));
}
public async Task <IActionResult> Edit(int id, [Bind("SalesmanInfoId,SalesmanName,TotalSale,CurrentYear,CurrentMonth,LastMonth,LastYear,TotalBillCount,Average")] SalesmanInfo salesmanInfo)
{
if (id != salesmanInfo.SalesmanInfoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesmanInfo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesmanInfoExists(salesmanInfo.SalesmanInfoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(salesmanInfo));
}
// [Authorize(Roles = "Admin,PowerUser")]
public async Task <IActionResult> Edit(int id, [Bind("StoreId,StoreCode,StoreName,Address,City,PinCode,PhoneNo,StoreManagerName,StoreManagerPhoneNo,PanNo,GSTNO,NoOfEmployees,OpeningDate,ClosingDate,Status")] Store store)
{
if (id != store.StoreId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(store);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StoreExists(store.StoreId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(PartialView(store));
}
public async Task <IActionResult> Edit(int id, [Bind("RentedLocationId,PlaceName,Address,OnDate,VacatedDate,City,OwnerName,MobileNo,RentAmount,AdvanceAmount,IsRented,RentType,StoreId,UserId,IsReadOnly")] RentedLocation rentedLocation)
{
if (id != rentedLocation.RentedLocationId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rentedLocation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RentedLocationExists(rentedLocation.RentedLocationId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", rentedLocation.StoreId);
return(PartialView(rentedLocation));
}
public async Task <IActionResult> Edit(int id, [Bind("CashInHandId,CIHDate,OpenningBalance,ClosingBalance,CashIn,CashOut,StoreId")] CashInHand cashInHand)
{
if (id != cashInHand.CashInHandId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cashInHand);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CashInHandExists(cashInHand.CashInHandId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", cashInHand.StoreId);
return(View(cashInHand));
}
public async Task <IActionResult> Edit(int id, [Bind("DuesListId,Amount,IsRecovered,RecoveryDate,DailySaleId,IsPartialRecovery,StoreId,UserId")] DuesList duesList)
{
if (id != duesList.DuesListId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(duesList);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DuesListExists(duesList.DuesListId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DailySaleId"] = new SelectList(_context.DailySales, "DailySaleId", "InvNo", duesList.DailySaleId);
//ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreName", duesList.StoreId);
return(PartialView(duesList));
}
public static int UpdateLedgerMaster(eStoreDbContext db, Party party)
{
var master = db.LedgerMasters.Where(c => c.PartyId == party.PartyId).FirstOrDefault();
if (master != null)
{
master.LedgerTypeId = party.LedgerTypeId;
db.Update(master);
return(db.SaveChanges());
}
else
{
return(-1);
}
}
public async Task <IActionResult> Edit(int id, [Bind("ExpenseId,Particulars,PartyName,EmployeeId,OnDate,PayMode,BankAccountId,PaymentDetails,Amount,Remarks,PartyId,LedgerEnteryId,IsCash,StoreId,UserId")] Expense expense)
{
if (id != expense.ExpenseId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (expense.PayMode == PaymentMode.Cash)
{
expense.BankAccountId = null;
}
_context.Update(expense);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpenseExists(expense.ExpenseId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["BankAccountId"] = new SelectList(_context.BankAccounts, "BankAccountId", "Account", expense.BankAccountId);
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "StaffName", expense.EmployeeId);
ViewData["PartyId"] = new SelectList(_context.Parties, "PartyId", "PartyName", expense.PartyId);
//ViewData["StoreId"] = new SelectList(_context.Stores, "StoreId", "StoreId", expense.StoreId);
return(View(expense));
}
public async Task <IActionResult> Edit(int id, [Bind("ReceiptId,PartyName,RecieptSlipNo,OnDate,PayMode,BankAccountId,PaymentDetails,Amount,Remarks,PartyId,LedgerEnteryId,IsCash,StoreId,UserName")] Receipt receipt)
{
if (id != receipt.ReceiptId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (receipt.PayMode == PaymentMode.Cash)
{
receipt.BankAccountId = null;
}
_context.Update(receipt);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReceiptExists(receipt.ReceiptId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["BankAccountId"] = new SelectList(_context.BankAccounts, "BankAccountId", "Account", receipt.BankAccountId);
ViewData["PartyId"] = new SelectList(_context.Parties, "PartyId", "PartyName", receipt.PartyId);
ViewData["StoreId"] = ActiveSession.GetActiveSession(HttpContext.Session, HttpContext.Response, _returnUrl);
return(View(receipt));
}