コード例 #1
0
 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.
 }
コード例 #2
0
        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));
        }
コード例 #3
0
        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));
        }
コード例 #4
0
        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));
        }
コード例 #5
0
        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));
        }
コード例 #6
0
        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));
        }
コード例 #7
0
        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));
        }
コード例 #8
0
        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));
        }
コード例 #9
0
        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));
        }
コード例 #10
0
        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));
        }
コード例 #11
0
        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));
        }
コード例 #12
0
        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));
        }
コード例 #13
0
        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));
        }
コード例 #14
0
        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));
        }
コード例 #15
0
ファイル: EmployeeManager.cs プロジェクト: amitdumka/eStore
 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();
 }
コード例 #16
0
        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));
        }
コード例 #17
0
ファイル: PartiesController.cs プロジェクト: amitdumka/eStore
        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));
        }
コード例 #18
0
        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));
        }
コード例 #19
0
        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));
        }
コード例 #20
0
        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));
        }
コード例 #21
0
        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));
        }
コード例 #22
0
        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));
        }
コード例 #23
0
        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));
        }
コード例 #24
0
ファイル: StoresController.cs プロジェクト: amitdumka/eStore
        // [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));
        }
コード例 #25
0
        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));
        }
コード例 #26
0
        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));
        }
コード例 #27
0
        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));
        }
コード例 #28
0
        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);
            }
        }
コード例 #29
0
        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));
        }
コード例 #30
0
        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));
        }