public async Task <IActionResult> PutSalesModel([FromRoute] int id, [FromBody] SalesModel salesModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != salesModel.Sales_id)
{
return(BadRequest());
}
_context.Entry(salesModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//Register
public Task <TranStatus> RegisterSales(SalesModel model)
{
using (salesRepository = new SalesRepository())
{
return(salesRepository.RegisterSales(model));
}
}
public void UpdateSales(string listOfProducts)
{
List <saleItem> newSales = new List <saleItem>();
SalesModel salesModel = new SalesModel();
newSales = Newtonsoft.Json.JsonConvert.DeserializeObject <List <saleItem> > (listOfProducts);
int location = int.Parse(HttpContext.User.Claims.Where(c => c.Type == "location").FirstOrDefault().Value.ToString());
int i = 1;
foreach (saleItem item in newSales)
{
salesModel.amount = item.amount;
salesModel.productBarcodeID = item.productBarcodeID;
salesModel.locationID = location;
salesModel.personelID = item.personelID;
salesModel.saleDate = DateTime.Today;
salesModel.salesID = item.salesID;
salesModel.dueAmount = item.tutar;
salesModel.salesLineId = i;
salesModel.typeOfCollection = 0;
salesModel.saleTime = DateTime.Now;
if (_context.salesmodels.Find(salesModel.saleDate, salesModel.salesID, salesModel.salesLineId, salesModel.locationID) == null)
{
_context.salesmodels.Add(salesModel);
_context.SaveChanges();
}
i = i + 1;
}
}
public async Task <ActionResult <SalesModel> > PostSalesModel(SalesModel salesModel)
{
_context.Sales.Add(salesModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSalesModel", new { id = salesModel.SalesId }, salesModel));
}
public async Task <IActionResult> Edit(DateTime id, [Bind("saleDate,saleTime,salesID,salesLineId,personelID,amount,paidAmount,typeOfCollection,locationID,productBarcodeID")] SalesModel salesModel)
{
if (id != salesModel.saleDate)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesModelExists(salesModel.saleDate))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(salesModel));
}
public void TestChangeCustomerDetails()
{
IRepository <Customer> customerRepo = new CustomerRepository();
customerRepo.Insert(new Customer("Anthony", "Lucas"));
customerRepo.Insert(new Customer("Sophia", "Rees"));
customerRepo.Insert(new Customer("Thomas", "Perkins"));
ISalesModel model = new SalesModel(customerRepo);
model.CurrentCustomer = customerRepo.GetAll()[1];
var view = new Mock <ISalesFormView>();
view.Setup(x => x.CustomerFirstname).Returns("Victoria");
view.Setup(x => x.CustomerLastname).Returns("Briggs");
ISalesFormController controller = new SalesFormController(view.Object, model);
controller.SaveChanges();
// verify that the controller notifies the view to show the customer
view.Verify(x => x.ShowCustomerInfo(It.IsAny <Customer>()));
// confirm that the customer is set to 'new customer'
Assert.IsTrue(model.CurrentCustomer.Firstname == "Victoria");
Assert.IsTrue(model.CurrentCustomer.Surname == "Briggs");
// Verify that the model has been updated.
Assert.IsTrue(model.GetAllCustomers()[1].Firstname == "Victoria");
Assert.IsTrue(model.GetAllCustomers()[1].Surname == "Briggs");
}
public void TestSelectCustomer()
{
IRepository <Customer> customerRepo = new CustomerRepository();
customerRepo.Insert(new Customer("Anthony", "Lucas"));
customerRepo.Insert(new Customer("Sophia", "Rees"));
customerRepo.Insert(new Customer("Thomas", "Perkins"));
ISalesModel model = new SalesModel(customerRepo);
var view = new Mock <ISalesFormView>();
ISalesFormController controller = new SalesFormController(view.Object, model);
// check for each customer, that the view is notified when the selection changes.
for (int selectedCustomer = 0; selectedCustomer < customerRepo.GetAll().Length; selectedCustomer++)
{
controller.SelectedCustomerChanged(customerRepo.GetAll()[selectedCustomer].Id);
// verify that we clear the customer and show the expected customer.
view.Verify(x => x.ClearCustomerInfo(), Times.Exactly(1 + selectedCustomer)); // ;
view.Verify(x => x.ShowCustomerInfo(It.Is <Customer>(s => s.Id == customerRepo.GetAll()[selectedCustomer].Id)));
Assert.IsTrue(model.CurrentCustomer == customerRepo.GetById(model.CurrentCustomer.Id));
}
}
internal DataTable FillTransportation(SalesModel ObjSalesModel)
{
try
{
ClsCon.cmd = new SqlCommand();
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.CommandText = "SPMasters";
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.Parameters.AddWithValue("@DataInd", ObjSalesModel.Ind);
con = ClsCon.SqlConn();
ClsCon.cmd.Connection = con;
dtSales = new DataTable();
ClsCon.da = new SqlDataAdapter(ClsCon.cmd);
ClsCon.da.Fill(dtSales);
dtSales.TableName = "success";
}
catch (Exception)
{
dtSales = new DataTable();
dtSales.TableName = "error";
return(dtSales);
}
finally
{
con.Close();
con.Dispose();
ClsCon.da.Dispose();
ClsCon.cmd.Dispose();
}
return(dtSales);
}
public report()
{
InitializeComponent();
WeeklyReport.ItemsSource = SalesModel.GetSalesReport(DateTime.Today.Date.AddDays(-7), DateTime.Today.Date);
MonthlyReport.ItemsSource = SalesModel.GetSalesYearlyReport(DateTime.Today.Date.AddYears(-1), DateTime.Today.Date);
}
// Register
public async Task <TranStatus> RegisterSales(SalesModel model)
{
using (var connection = new SqlConnection(ConnectionString))
{
await connection.OpenAsync();
TranStatus transaction = new TranStatus();
DynamicParameters parameter = new DynamicParameters();
parameter.Add("@SalesName", model.SalesName);
parameter.Add("@Email", model.Email);
parameter.Add("@Password", model.Password);
parameter.Add("@Cpassword", model.Cpassword);
parameter.Add("@Createdby", model.Createdby);
parameter.Add("@Message", dbType: DbType.String, direction: ParameterDirection.Output, size: 500);
parameter.Add("@Code", dbType: DbType.Int32, direction: ParameterDirection.Output);
await connection.QueryAsync("RegisterSales", parameter, commandType : CommandType.StoredProcedure);
transaction.returnMessage = parameter.Get <string>("@Message");
transaction.code = parameter.Get <int>("@Code");
return(transaction);
}
}
public ActionResult GetSales()
{
// SalesModel model = SalesModel.ToViewModel(_salesManager.GetAll());
SalesModel model = JsonConvert.DeserializeObject <SalesModel>(_salesManager.GetAll().ToString());
return(Json(new { values = model }, JsonRequestBehavior.AllowGet));
}
public void SaveChanges(DataGridView gridView, string cashier, string salesid, string status, string customer, decimal discount, decimal total, decimal subtotal, string items)
{
SalesModel model = new SalesModel();
int rowindex = gridView.CurrentRow.Index;
ShopDataContext db = new ShopDataContext();
db.Sales.InsertOnSubmit(
new Sale
{
SalesNumber = salesid,
CashierId = cashier,
Salesdate = DateTime.Now,
Subtotal = subtotal,//Convert.ToInt32(gridView.Rows[rowindex].Cells[3].Value),
Discount = discount,
Total = total,
TotalItems = items, //Convert.ToString(gridView.Rows[rowindex].Cells[1].Value),
CustomerName = customer,
Status = status
});
db.SubmitChanges();
rowindex = 0;
}
public HttpResponseMessage CreateQuickJournal(SalesModel _SalesModel)
{
try
{
SALES_QUICK_JOURNAL qj = new SALES_QUICK_JOURNAL();
qj.QUICKJOURNAL_CODE = _SalesModel.QUICKJOURNAL_CODE;
qj.JOURNAL_DATE = _SalesModel.JOURNAL_DATE;
qj.CUSTOMER = _SalesModel.CUSTOMER;
qj.REFERENCE = _SalesModel.REFERENCE;
qj.JOURNAL_DESC = _SalesModel.JOURNAL_DESC;
qj.NL_ACC1 = _SalesModel.NL_ACC1;
qj.NL_ACC2 = _SalesModel.NL_ACC2;
qj.VAT_PER = _SalesModel.VAT_PER;
qj.TOTAL_VAT = _SalesModel.TOTAL_VAT;
qj.NET_AMOUNT = _SalesModel.NET_AMOUNT;
qj.TOTAL_AMOUNT = _SalesModel.TOTAL_AMOUNT;
qj.IS_DELETE = false;
qj.STATUS = "Un-Saved";
db.SALES_QUICK_JOURNAL.Add(qj);
db.SaveChanges();
}
catch (Exception)
{
throw;
}
return(Request.CreateResponse(HttpStatusCode.OK, "success"));
}
public async Task <IHttpActionResult> AddSales(SalesModel sales)
{
if (sales == null)
{
return(BadRequest("Please provide valid inputs!"));
}
CommonResponse validatedResponse = await AuthService.ValidateUserAndToken();
if (!validatedResponse.IsError)
{
if (await SalesService.AddSales(sales))
{
return(Ok("Transaction Successfully Entered!"));
}
else
{
return(BadRequest("Transaction Cannot be Processed!"));
}
}
else
{
return(Unauthorized());
}
}//end of add
public async Task <IHttpActionResult> UpdateSales(SalesModel sales)
{
if (sales == null)
{
return(BadRequest("Please provide valid inputs!"));
}
CommonResponse validatedResponse = await AuthService.ValidateUserAndToken();
if (!validatedResponse.IsError)
{
if (await SalesService.SalesExist(sales))
{
if (await SalesService.UpdateSales(sales))
{
return(Ok("Transaction Updated Successfully!"));
}
else
{
return(BadRequest("Failed to Update the Transaction!"));
}
}
else
{
return(BadRequest("No Such Transaction Exisits!"));
}
}
else
{
return(Unauthorized());
}
}//end of update
public void TestDeleteCustomerConfirmPrompt()
{
IRepository <Customer> repo = new CustomerRepository();
repo.Insert(new Customer()
{
Firstname = "Delete", Surname = "Me"
});
repo.Insert(new Customer()
{
Firstname = "Don't Delete", Surname = "Me"
});
ISalesModel model = new SalesModel(repo);
model.CurrentCustomer = model.GetAllCustomers()[0];
// setup the view, so that the displayed question to confirm to delete
// the custoemr is confirmed.
var view = new Mock <ISalesFormView>();
view.Setup(x => x.DisplayQuestion(It.IsAny <string>())).Returns(true);
ISalesFormController controller = new SalesFormController(view.Object, model);
controller.DeleteCustomer();
// verify the view was notified for confirmation to delete the customer
view.Verify(x => x.DisplayQuestion(It.IsAny <string>()), Times.Once);
view.Verify(x => x.ClearCustomerInfo(), Times.AtLeastOnce);
// confirm there is only one customer in the repository now.
Assert.IsTrue(model.GetAllCustomers().Count == 1);
}
internal DataSet FillBrokerDetail(SalesModel ObjSalesModel)
{
try
{
ClsCon.cmd = new SqlCommand();
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.CommandText = "SPSearchByAccount";
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.Parameters.AddWithValue("@Ind", ObjSalesModel.Ind);
ClsCon.cmd.Parameters.AddWithValue("@OrgID", ObjSalesModel.OrgID);
ClsCon.cmd.Parameters.AddWithValue("@BrID", ObjSalesModel.BrID);
ClsCon.cmd.Parameters.AddWithValue("@AccCode", ObjSalesModel.AccCode);
con = ClsCon.SqlConn();
ClsCon.cmd.Connection = con;
dsSales = new DataSet();
ClsCon.da = new SqlDataAdapter(ClsCon.cmd);
ClsCon.da.Fill(dsSales, "SuccessDataSet");
dsSales.DataSetName = "success";
}
catch (Exception)
{
dsSales = new DataSet();
dsSales.DataSetName = "error";
return(dsSales);
}
finally
{
con.Close();
con.Dispose();
ClsCon.da.Dispose();
ClsCon.cmd.Dispose();
}
return(dsSales);
}
public static DataTable GetDataTableFromCsv(string path)
{
try
{
log.Info("Initiating method to create data table from csv: " + path);
//Create Empty Data Table
DataTable dataTable = new DataTable();
//Read all lines of csv and store then in sting array
String[] csv = File.ReadAllLines(path);
//Add Table Column Schema
SalesModel.SalesCSVModel(dataTable);
//Read each row from string array and add a row in Data Table
foreach (string csvrow in csv)
{
var fields = csvrow.Split(','); // csv delimiter
var row = dataTable.NewRow();
row.ItemArray = fields;
dataTable.Rows.Add(row);
}
return(dataTable);
}
catch (Exception)
{
log.Info("Exception while creating datatable from csv");
throw;
}
}
private ProductDetails GetProductDetails()
{
ProductDetails productDetails = new ProductDetails();
productDetails.Category = categoryComboBox.Text;
productDetails.Product = productComboBox.Text;
productDetails.Quantity = Convert.ToDouble(quantityTextBox.Text);
productDetails.MRP = Convert.ToDouble(mrpTextBox.Text);
productDetails.TotalMrp = Convert.ToDouble(totalMrpTextBox.Text);
SalesModel salesModel = new SalesModel();
salesModel.Category = _salesModel.Category;
salesModel.Customer = _salesModel.Customer;
salesModel.Date = _salesModel.Date;
salesModel.Product = _salesModel.Product;
try
{
salesModel.Quantity = Convert.ToDouble(quantityTextBox.Text);
}
catch (Exception e)
{
salesModel.Quantity = 0;
}
productDetails.SalesModel = salesModel;
return(productDetails);
}
private void Simpan_Click(object sender, EventArgs e)
{
if (!validator.Validate())
{
return;
}
SalesModel sales = (SalesModel)SalesBS.Current;
sales.salesheadId = sh_coll.First(sh => sh.id == Convert.ToInt64(salesheadid.EditValue));
sales.createdAt = DateTime.Now;
sales.updatedAt = DateTime.Now;
sales.Save();
SalesXpCollection.Add(sales);
SalesUOW.CommitChanges();
SalesBS.EndEdit();
SetDisabled();
Tambah.Enabled = true;
Simpan.Enabled = false;
Batal.Enabled = false;
Edit.Enabled = true;
Hapus.Enabled = true;
gridControl1.Enabled = true;
}
// GET: Sales
public ActionResult Sales()
{
var Sales = new SalesModel()
{
};
return(View(Sales));
}
public async Task <ActionResult> Post(SalesModel salesModel)
{
var itemSales = salesModel.ItemSalesModels.Select(s => new ItemSales(s.ProductUUID, s.UnitPrice, s.Quantity));
var sales = new Sales(salesModel.ClientUUID, itemSales);
await salesService.ProcessAsync(sales);
return(Ok());
}
private void SalesBS_PositionChanged(object sender, EventArgs e)
{
SalesModel sales = (SalesModel)SalesBS.Current;
if (sales.salesheadId != null)
{
salesheadid.EditValue = sales.salesheadId.id;
}
}
public IActionResult AddSale([FromBody] SalesModel model)
{
if (ModelState.IsValid)
{
saleRepository.Insert(model);
return(Json(new { error = false, message = "Ventes enregistrées avec succès" }));
}
return(Json(new { error = true, message = "N'a pas réussi à enregistrer les ventes" }));
}
public ActionResult StoreReceipts(int?id)
{
var salesModel = new SalesModel
{
StoreId = id
};
return(View(salesModel));
}
public IActionResult AddSale([FromBody] SalesModel model)
{
if (ModelState.IsValid)
{
saleRepository.Insert(model);
return(Json(new { error = false, message = "Sales saved successfully" }));
}
return(Json(new { error = true, message = "failed to save Sales" }));
}
internal DataTable CancelSalesVoucherNo(SalesModel objSalesModel)
{
try
{
ClsCon.cmd = new SqlCommand();
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.CommandText = "SPSaleVoucher";
ClsCon.cmd.CommandType = CommandType.StoredProcedure;
ClsCon.cmd.Parameters.AddWithValue("@Ind", objSalesModel.Ind);
ClsCon.cmd.Parameters.AddWithValue("@OrgID", objSalesModel.OrgID);
ClsCon.cmd.Parameters.AddWithValue("@BrID", objSalesModel.BrID);
ClsCon.cmd.Parameters.AddWithValue("@YrCD", objSalesModel.YrCD);
ClsCon.cmd.Parameters.AddWithValue("@VchType", objSalesModel.VchType);
ClsCon.cmd.Parameters.AddWithValue("@EntryType", objSalesModel.EntryType);
ClsCon.cmd.Parameters.AddWithValue("@User", objSalesModel.User);
ClsCon.cmd.Parameters.AddWithValue("@IP", objSalesModel.IP);
ClsCon.cmd.Parameters.AddWithValue("@ByCashSale", objSalesModel.ByCashSale);
ClsCon.cmd.Parameters.AddWithValue("@PartyName", objSalesModel.PartyName);
ClsCon.cmd.Parameters.AddWithValue("@PartyGSTIN", objSalesModel.PartyGSTIN);
ClsCon.cmd.Parameters.AddWithValue("@PartyAddress", objSalesModel.PartyAddress);
ClsCon.cmd.Parameters.AddWithValue("@WareHouseID", objSalesModel.WareHouseID);
ClsCon.cmd.Parameters.AddWithValue("@TransName", objSalesModel.TransName);
ClsCon.cmd.Parameters.AddWithValue("@PONo", objSalesModel.PONo);
ClsCon.cmd.Parameters.AddWithValue("@CancelReason", objSalesModel.CancelReason);
ClsCon.cmd.Parameters.AddWithValue("@InvoiceSeries", objSalesModel.InvoiceSeries);
ClsCon.cmd.Parameters.AddWithValue("@TblSale", objSalesModel.DtSales);
ClsCon.cmd.Parameters.AddWithValue("@TblItems", objSalesModel.DtItems);
con = ClsCon.SqlConn();
ClsCon.cmd.Connection = con;
dtSales = new DataTable();
ClsCon.da = new SqlDataAdapter(ClsCon.cmd);
ClsCon.da.Fill(dtSales);
dtSales.TableName = "success";
}
catch (Exception)
{
dtSales = new DataTable();
dtSales.TableName = "error";
return(dtSales);
}
finally
{
con.Close();
con.Dispose();
ClsCon.da.Dispose();
ClsCon.cmd.Dispose();
}
return(dtSales);
}
//int comp = Convert.ToInt32(App.Current.Properties["Company_Id"].ToString());
//int comp = 46;
public RecurringSalesViewModel()
{
selectSales = new SalesModel();
//CUT_OFF_DATE = System.DateTime.Now;
//CreatVisible = "Visible";
//UpdVisible = "Collapsed";
//AddVisible = "Visible";
}
public int Update(SalesModel salesmodel)
{
var oldSalesModel = this.RetrieveOne(salesmodel.Id);
_dataContext.SqlModelMapper.TrackUpdate(oldSalesModel, salesmodel);
return(_dataContext.SqlModelMapper
.SaveChanges()
.ModifiedCount);
}
//int comp = Convert.ToInt32(App.Current.Properties["Company_Id"].ToString());
//int comp = 46;
public QuickJournalEntryViewModel()
{
selectSales = new SalesModel();
JOURNAL_DATE = System.DateTime.Now;
CreatVisible = "Visible";
UpdVisible = "Collapsed";
//AddVisible = "Visible";
}
private void NewTask1(List<SalesBusinessLayer.CSVParser.ParseItem> item,SalesModel.InputFile inputFile)
{
foreach (var c in item)
{
var customerSet = new SalesModel.Customer();
var productSet = new SalesModel.Product();
var managerSet = new SalesModel.Manager();
lock (_customerOpSync)
{
customerSet = (_contextCustomer as SalesDataLevel.CustomerRepository).GetCustomerByName(c.CustomerName);
if (customerSet == null)
{
customerSet = _contextCustomer.Add(new SalesModel.Customer() { CustomerName = c.CustomerName });
_contextCustomer.SaveChanges();
}
}
lock (_producteOpSync)
{
productSet = (_contextProduct as SalesDataLevel.ProductRepository).GetProductByName(c.ProductName);
if (productSet == null)
{
productSet = _contextProduct.Add(new SalesModel.Product() { ProductName = c.ProductName, Barcode = c.Barcode });
_contextProduct.SaveChanges();
}
}
lock (_managerOpSync)
{
managerSet = (_contextManager as SalesDataLevel.ManagerRepository).GetManagerByName(c.ManagerName);
if (managerSet == null)
{
managerSet = _contextManager.Add(new SalesModel.Manager() { ManagerName = c.ManagerName });
_contextManager.SaveChanges();
}
}
var saleItemSet =
new SalesModel.SaleItem() {
Customer = customerSet,
Product =
productSet,
InputFile = inputFile,
Manager = managerSet,
SaleSum = Convert.ToDouble(c.SaleSum),
SaleDate = c.SaleDate
};
Console.WriteLine("Sale item - {0}, {1}, {2}, {3}, {4} - sum - date - {5}, {6}",
saleItemSet.Customer.Id,
saleItemSet.Product.Id,
saleItemSet.Manager.Id,
saleItemSet.InputFile.Id,
saleItemSet.Id,
saleItemSet.SaleSum,
saleItemSet.SaleDate);
_contextSaleItem.Add(saleItemSet);
_contextSaleItem.SaveChanges();
}
}
