public bool Update(SaleDetails saleDetails)
{
bool isUpdated = false;
//Connection
string connectionString = @"Server=LAPTOP-JECDIQLU; Database=Project1DB; Integrated Security=True";
SqlConnection sqlConnection = new SqlConnection(connectionString);
//Command
string commandString = @"Update SalesDetails set Quantity='" + saleDetails.Quantity + "' where AvailableQuantity='" + saleDetails.AvailableQuantity + "'";
SqlCommand sqlCommand = new SqlCommand(commandString, sqlConnection);
//Open
sqlConnection.Open();
int isExecuted = sqlCommand.ExecuteNonQuery();
if (isExecuted > 0)
{
isUpdated = true;
}
//Close
sqlConnection.Close();
return(isUpdated);
}
private void btnSave_Click(object sender, EventArgs e)
{
SaleORM saleOrm = new SaleORM();
Sale s = new Sale();
s.CustomerID = Convert.ToInt32(cmbCustomer.SelectedValue);
s.RoomID = Convert.ToInt32(cmbRoom.SelectedValue);
s.StaffID = StaffORM.ActiveUser.Id;
s.RoomPrice = numProdPrice.Value;
s.SaleDate = DateTime.Now;
int sId = Convert.ToInt32(saleOrm.InsertScalar(s));
if (sId > 0)
{
SaleDetailsORM sdOrm = new SaleDetailsORM();
foreach (ListViewItem lvi in listView1.Items)
{
SaleDetails sd = new SaleDetails();
sd.SaleID = sId;
sd.ProductID = (int)lvi.Tag;
sd.Price = Convert.ToDecimal(lvi.SubItems[3].Text);
sd.Quantity = Convert.ToDouble(lvi.SubItems[2].Text);
sd.Discount = Convert.ToDouble(lvi.SubItems[4].Text);
sdOrm.Insert(sd);
}
}
}
protected void AddButton_Click(object sender, EventArgs e)
{
try
{
SaleDetails _SaleDetails = new SaleDetails();
_SaleDetails.Product = ProductDropDownList.SelectedItem.ToString();
_SaleDetails.Qty = Convert.ToDecimal(txtQty.Text);
_SaleDetails.Mrp = Convert.ToDecimal(txtMrp.Text);
_SaleDetails.TotalMrp = Convert.ToDecimal(txtTotalMrp.Text);
_SaleDetails.Invoice = txtInvoice.Text;
decimal CurrentQty = Convert.ToDecimal(txtAvailableQty.Text);
if (CurrentQty > 0)
{
int Addsuccess = _SalesRepository.Add(_SaleDetails);
if (Addsuccess > 0)
{
LoadSaleDetails();
GrandTotal();
}
}
else
{
}
}
catch
{
}
}
public virtual IDictionary BooksAndQuantitys()
{
var booksAndQuantitys = new Dictionary <string, int>();
SaleDetails.ForEach(aSaleDetail => booksAndQuantitys.Add(aSaleDetail.Book, aSaleDetail.Quantity));
return(booksAndQuantitys);
}
public async Task Get_Get_Sale_By_Transaction_Id()
{
// ARRANGE
// Service provider/scope
using IServiceScope scope = this.Fixture.Services.CreateScope();
IServiceProvider services = scope.ServiceProvider;
// Services
ISaleService saleService = services.GetRequiredService <ISaleService>();
// Data
string saleTransactionId = Guid.NewGuid().ToString("N", null);
// ACT
// Add sale
SaleDetails addedSale = await saleService.AddSaleAsync(
saleTransactionId,
DateTime.UtcNow.Date,
new Random().NextDouble() * 100,
"Test sale").ConfigureAwait(false);
// Lookup sale
SaleDetails foundSale = await saleService.GetSaleAsync(saleTransactionId).ConfigureAwait(false);
// ASSERT
Assert.NotNull(foundSale);
Assert.Equal(saleTransactionId, foundSale.TransactionId);
Assert.Equal(addedSale.TransactionId, foundSale.TransactionId);
Assert.Equal(addedSale.Date, foundSale.Date);
Assert.Equal(addedSale.Amount, foundSale.Amount);
Assert.Equal(addedSale.Notes, foundSale.Notes);
}
public async Task Can_Add_Sale()
{
// ARRANGE
// Service provider/scope
using IServiceScope scope = this.Fixture.Services.CreateScope();
IServiceProvider services = scope.ServiceProvider;
// Services
ISaleService saleService = services.GetRequiredService <ISaleService>();
// Data
string saleTransactionId = Guid.NewGuid().ToString("N", null);
DateTime saleDate = DateTime.UtcNow.Date;
double saleAmount = new Random().NextDouble() * 100;
string saleNotes = "Test sale";
// ACT
// Add sale
SaleDetails sale = await saleService.AddSaleAsync(
saleTransactionId,
saleDate,
saleAmount,
saleNotes).ConfigureAwait(false);
// ASSERT
Assert.NotNull(sale);
Assert.Equal(saleTransactionId, sale.TransactionId);
Assert.Equal(saleDate, sale.Date);
Assert.Equal(saleAmount, sale.Amount);
Assert.Equal(saleNotes, sale.Notes);
}
public async Task Cannot_Add_Duplicate_Sale_Transaction_Id()
{
// ARRANGE
// Service provider/scope
using IServiceScope scope = this.Fixture.Services.CreateScope();
IServiceProvider services = scope.ServiceProvider;
// Services
ISaleService saleService = services.GetRequiredService <ISaleService>();
// Data
string saleTransactionId = Guid.NewGuid().ToString("N", null);
// ACT
// First sale
SaleDetails sale1 = await saleService.AddSaleAsync(
saleTransactionId,
DateTime.UtcNow.Date,
new Random().NextDouble() * 100,
"Test duplicate sale 1").ConfigureAwait(false);
// Duplicate sale
Func <Task> task = async() => await saleService.AddSaleAsync(
saleTransactionId,
DateTime.UtcNow.Date,
new Random().NextDouble() * 100,
"Test duplicate sale 2").ConfigureAwait(false);
// ASSERT
await Assert.ThrowsAsync <SaleExceptions.AlreadyExists>(task);
}
public bool SubmitButton(SaleDetails saleDetails)
{
bool isSubmitted = false;
//Connection
string connectionString = @"Server=LAPTOP-JECDIQLU; Database=Project1DB; Integrated Security=True";
SqlConnection sqlConnection = new SqlConnection(connectionString);
//Command
string commandString = @"INSERT INTO SalesDetails(Category,ProductCode,AvailableQuantity,Quantity,MrpTk,TotalMrpTk) VALUES('" + saleDetails.Category + "','" + saleDetails.ProductCode + "','" + saleDetails.AvailableQuantity + "','" + saleDetails.Quantity + "','" + saleDetails.MrpTk + "','" + saleDetails.TotalMrpTk + "')";
SqlCommand sqlCommand = new SqlCommand(commandString, sqlConnection);
//Open
sqlConnection.Open();
int isExecuted = sqlCommand.ExecuteNonQuery();
if (isExecuted > 0)
{
isSubmitted = true;
}
//Close
sqlConnection.Close();
return(isSubmitted);
}
public IHttpActionResult PutSaleDetails(int id, SaleDetails saleDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != saleDetails.SDetailID)
{
return(BadRequest());
}
db.Entry(saleDetails).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!SaleDetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public List <SaleDetails> DisplaySalesItem()
{
List <SaleDetails> salesDetails = new List <SaleDetails>();
string connectionString = @"Server=LAPTOP-JECDIQLU; Database=Project1DB; Integrated Security=True";
SqlConnection sqlConnection = new SqlConnection(connectionString);
sqlConnection.Open();
string query = "SELECT * FROM SalesDetails";
SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
SaleDetails saleDetail = new SaleDetails();
saleDetail.ProductCode = sqlDataReader["ProductCode"].ToString();
saleDetail.Quantity = (sqlDataReader["Quantity"]).ToString();
saleDetail.MrpTk = Convert.ToDouble(sqlDataReader["MrpTk"]);
saleDetail.TotalMrpTk = Convert.ToDouble(sqlDataReader["TotalMrpTk"]);
salesDetails.Add(saleDetail);
}
sqlConnection.Close();
return(salesDetails);
}
public async Task <IActionResult> GetAsync(
[FromRoute] string transactionId)
{
try
{
// Lookup sale
SaleDetails sale = await this.SaleService.GetSaleAsync(transactionId).ConfigureAwait(false);
// Map to DTO model
return(this.Ok(sale.ToDto()));
}
catch (SaleExceptions.NotFound)
{
return(this.NotFound());
}
catch (SaleExceptions.SaleException ex) when(
ex is SaleExceptions.TransactionIdRequired ||
ex is SaleExceptions.TransactionIdInvalid)
{
return(this.BadRequest(new ErrorDto()
{
Code = ex.GetType().Name,
}));
}
}
public async Task <IActionResult> AddAsync(
[FromBody] SaleDto dto)
{
try
{
// Parse DTO
if (string.IsNullOrWhiteSpace(dto?.Date))
{
throw new SaleExceptions.DateRequired();
}
if (!DateTime.TryParseExact(dto?.Date, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
{
throw new SaleExceptions.DateInvalid();
}
// Add sale
SaleDetails sale = await this.SaleService.AddSaleAsync(
dto?.TransactionId,
date,
dto?.Amount ?? throw new SaleExceptions.AmountRequired(),
dto?.Notes).ConfigureAwait(false);
// Map to DTO model
string actionName = nameof(this.GetAsync);
if (actionName.EndsWith("Async"))
{
actionName = actionName[0..^ 5];
public SaleServiceTest()
{
_saleService = new SaleService(_saleRepo.Object, _saleDetailRepo.Object, _itemRepo.Object, _trasactionService.Object, _customerRepo.Object);
_saleCreateDto = new SaleCreateDTO();
_saleDetailCreateDto = new SaleDetailCreateDTO();
_sale = new Sale();
_saleDetail = new SaleDetails();
}
public int createSale_details(SaleDetails SD)
{
dbCon.openCon();
cmd = new SqlCommand("insert into Sales_details (sd_id,sale_id,sd_Product,Item_id,DesignId,PSizeId,fabricId,brandId,sd_qty,sd_Product_price) values('" + SD.sd_id + "','" + SD.sale_id + "','" + SD.sd_Product + "','" + SD.Item_id + "','" + SD.DesignId + "','" + SD.PSizeId + "','" + SD.fabricId + "','" + SD.brandId + "','" + SD.sd_qty + "','" + SD.sd_Product_price + "')", dbCon.con);
int status = cmd.ExecuteNonQuery();
dbCon.closeCon();
return(status);
}
public IHttpActionResult GetSaleDetails(int id)
{
SaleDetails saleDetails = db.SaleDetails.Find(id);
if (saleDetails == null)
{
return(NotFound());
}
return(Ok(saleDetails));
}
public IHttpActionResult PostSaleDetails(SaleDetails saleDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.SaleDetails.Add(saleDetails);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = saleDetails.SDetailID }, saleDetails));
}
private void FormatDiscounts(SaleDetails saleDetails, StringBuilder messageBuilder)
{
foreach (var discount in saleDetails.Discounts)
{
messageBuilder.Append(FormatMessage(discount.Description, discount.DiscountAmount) + Environment.NewLine);
}
if (saleDetails.Discounts.Any() == false)
{
messageBuilder.Append(SalesDisplayTemplates.NoDeductions + Environment.NewLine);
}
}
public async Task <bool> SaveSale(long product_id, SaleDetails saleDetails)
{
try
{
bool isNew = false;
if (saleDetails.sale_id == 0)
{
isNew = true;
// get next sale id
var seqCollection = _db.GetCollection <BsonDocument>("sequences");
var sequences = await seqCollection.FindOneAndUpdateAsync(Builders <BsonDocument> .Filter.Empty, Builders <BsonDocument> .Update.Inc(new StringFieldDefinition <BsonDocument, long>("sale_id"), 1), new FindOneAndUpdateOptions <BsonDocument> {
IsUpsert = false, ReturnDocument = ReturnDocument.After
});
saleDetails.sale_id = sequences.GetValue("sale_id").AsInt64;
saleDetails.snaps = new Snap[0];
saleDetails.progress = 0;
}
var collection = _db.GetCollection <Product>(Product.CollectionName);
var filter = Builders <Product> .Filter;
var update = Builders <Product> .Update;
var projection = Builders <Product> .Projection;
if (isNew)
{
await collection.UpdateOneAsync(filter.Eq(p => p.id, product_id), update.Push(p => p.future_sales, saleDetails));
}
else
{
var product = await(await collection.FindAsync(filter.Eq(p => p.id, product_id), new FindOptions <Product> {
Limit = 1
})).FirstOrDefaultAsync();
var sale = product.future_sales.FirstOrDefault(s => s.sale_id == saleDetails.sale_id);
sale.starts_on = saleDetails.starts_on;
sale.ends_on = saleDetails.ends_on;
sale.sale_type = saleDetails.sale_type;
sale.stock = saleDetails.stock;
sale.required_snaps = saleDetails.required_snaps;
sale.target = saleDetails.target;
await collection.UpdateOneAsync(filter.Eq(p => p.id, product_id), update.Set(p => p.future_sales, product.future_sales));
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public IHttpActionResult DeleteSaleDetails(int id)
{
SaleDetails saleDetails = db.SaleDetails.Find(id);
if (saleDetails == null)
{
return(NotFound());
}
db.SaleDetails.Remove(saleDetails);
db.SaveChanges();
return(Ok(saleDetails));
}
public SaleToken(SaleDetails sale, bool allSnaps)
{
sale_id = sale.sale_id;
target = sale.target;
current_price = sale.current_price;
progress = sale.progress;
snaps = sale.snaps.OrderByDescending(s => s.snapped_at).Take(allSnaps ? sale.snaps_count : 20).Select(s => new SnapToken(s)).ToArray();
snaps_count = sale.snaps_count;
state = sale.state;
sale_type = sale.sale_type;
required_snaps = sale.required_snaps;
stock = sale.stock;
starts_on = sale.starts_on;
ends_on = sale.ends_on;
}
/// <summary>
/// Convert business model to DTO.
/// </summary>
/// <param name="model">The business model.</param>
/// <returns>The DTO.</returns>
public static SaleDto ToDto(this SaleDetails model)
{
if (model == null)
{
return(null);
}
return(new SaleDto()
{
TransactionId = model.TransactionId,
Date = model.Date.ToString("yyyy-MM-dd"),
Amount = model.Amount,
Notes = model.Notes,
});
}
private void CreateSaleInfo(int sessionId, CashMovement cashMovementCreated,
ISaleDocumentType saleDocumentType, string customerName, List <SaleLineDto> saleLineDtos,
string ruc, IEnumerable <ProductMovement> productMovements)
{
var saleAmount = GetSaleAmount(saleLineDtos);
var sale = new Sale
{
Date = DateTime.Now,
Status = Constants.SaleStatus.Created,
SessionId = sessionId,
CashMovement = cashMovementCreated
};
uow.SaleRepository.Insert(sale);
var saleDocument = new SaleDocument
{
DocumentType = saleDocumentType.Name,
Number = saleDocumentType.GetNextDocumentNumber(uow.GeneralConfigValuesRepository),
Date = DateTime.Now,
CustomerName = customerName,
RUC = ruc,
SubTotal = saleDocumentType.GetSubTotalForDocument(saleAmount),
IGV = saleDocumentType.GetIgvForDocument(saleAmount),
Total = saleAmount,
Status = Constants.SaleDocumentStatus.Created,
Sale = sale
};
uow.SaleDocumentRepository.Insert(saleDocument);
var zippedCollection = saleLineDtos.Zip(productMovements, (x, y) => new { SaleLineDto = x, ProductMovement = y });
foreach (var zippedItem in zippedCollection)
{
var saleDetail = new SaleDetails()
{
//TODO: Ingresar correlativo en linea del documento ([SaleDetailNumber])
ProductMovement = zippedItem.ProductMovement,
Quantity = zippedItem.SaleLineDto.Quantity,
SaleDocument = saleDocument,
SinglePrice = zippedItem.SaleLineDto.UnitPrice,
TotalPrice = zippedItem.SaleLineDto.LinePrice
};
uow.SaleDetailsRepository.Insert(saleDetail);
}
}
public IActionResult saveChanges(Guid id)
{
_propertyInfos.ChangeState(id);
var saleDetails = new SaleDetails
{
Id = Guid.NewGuid(),
Property = _propertyInfos.get(id),
Buyer = User.Identity.Name,
Saler = "Admin"
};
_propertySale.Add(saleDetails);
return(RedirectToAction("Index"));
}
private SaleDetails DetailsRow(IVehicleVendorRepository repo, OleDbDataReader reader, Sale sale)
{
var detailQty = reader["Quantity"];
if (detailQty != DBNull.Value)
{
var detailQtyInt = (int)(double)detailQty;
var vehiceId = (int)(double)reader["VehicleId"];
var details = new SaleDetails()
{
Quantity = (int)(double)detailQtyInt, VehicleId = vehiceId, Sale = sale
};
return(details);
}
return(null);
}
/// <summary>
/// Format the sales detail in a string format used to display to the UI
/// </summary>
/// <param name="saleDetails">The sale details produced from the price basket products</param>
/// <returns>A string representation of the sale</returns>
public string Format(SaleDetails saleDetails)
{
if (saleDetails == null)
{
throw new ArgumentNullException(nameof(saleDetails));
}
var messageBuilder = new StringBuilder();
messageBuilder.Append(FormatSubTotal(saleDetails.SubTotal) + Environment.NewLine);
FormatDiscounts(saleDetails, messageBuilder);
messageBuilder.Append(FormatTotal(saleDetails.Total) + Environment.NewLine);
return(messageBuilder.ToString());
}
protected void AddButton_Click(object sender, EventArgs e)
{
try
{
if (txtCustomerContact.Text != null && CategoriesDropDownList.SelectedIndex > 0 && ItemsDropDownList.SelectedIndex > 0 && txtQty.Text != null)
{
if (Convert.ToDecimal(lblStock.Text) >= Convert.ToDecimal(txtQty.Text))
{
SaleDetails _SaleDetails = new SaleDetails();
_SaleDetails.CustomerContact = txtCustomerContact.Text;
_SaleDetails.Item = ItemsDropDownList.SelectedItem.ToString();
_SaleDetails.Unit = Convert.ToDecimal(lblSellingPrice.Text);
_SaleDetails.Qty = Convert.ToDecimal(txtQty.Text);
_SaleDetails.Total = Convert.ToDecimal(lblSellingPrice.Text) * Convert.ToDecimal(txtQty.Text);
_SaleDetails.SalesId = txtSalesId.Text;
int success = _SalesRepository.Add(_SaleDetails);
if (success > 0)
{
LoadSalesOrder();
GridviewRowSum();
ItemsDropDownList.ClearSelection();
lblSellingPrice.Text = "";
lblStock.Text = "";
txtQty.Text = "";
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "alert('Failed Added');", true);
}
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "alert('Please Check Your Stock');", true);
}
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "alert", "alert('Please Check All formality');", true);
}
}
catch { }
}
private void AddSaleDetailInfo(SaleDetails detail, List <PaymentInfoDto> list)
{
List <SaleDetailInfo> infoList = new List <SaleDetailInfo>();
foreach (var item in list)
{
var entity = new SaleDetailInfo
{
PaymentInfoID = item.PaymentInfoID,
SaleDetailID = detail.ID,
AddDate = DateTime.Now,
Quantity = item.Quantity,
IMEI = item.IMEI
};
infoList.Add(entity);
}
rpsaledetailinfo.AddRange(infoList);
rpimei.SaveChanges();
rppaymentinfo.SaveChanges();
}
private void SubmitButton_Click(object sender, EventArgs e)
{
if (totalMrpTextBox.Text == "")
{
MessageBox.Show("totalMrpText field is required");
return;
}
if (mrpTextBox.Text == "")
{
MessageBox.Show("MrpText field is required");
return;
}
if (availableQuantityTextBox.Text == "")
{
MessageBox.Show("AvailableText field is required");
return;
}
SaleDetails saleDetails = new SaleDetails();
salesDataGridView.Visible = false;
submitDataGridView.Visible = true;
MessageBox.Show("Added successfully in the GridView..!!");
saleDetails.Category = (categoryComboBox.Text).ToString();
saleDetails.ProductCode = (productComboBox.Text).ToString();
saleDetails.Quantity = (quantityTextBox.Text);
saleDetails.TotalMrpTk = Convert.ToDouble(totalMrpTextBox.Text);
saleDetails.MrpTk = Convert.ToDouble(mrpTextBox.Text);
saleDetails.AvailableQuantity = availableQuantityTextBox.Text;
_saleDetailsBLL.SubmitButton(saleDetails);
submitDataGridView.DataSource = _saleDetailsBLL.ClickSubmit(saleDetails);
}
public ActionResult Create(SaleViewModel salesViewModel)
{
try
{
using (P_MarketContext db = new P_MarketContext())
{
Sale sale = new Sale
{
ClientKey = salesViewModel.ClientKey,
SaleDate = DateTime.Now
};
db.Sales.Add(sale);
db.SaveChanges();
foreach (var item in salesViewModel.SaleDetails)
{
var product = db.Products.Find(item.ProductId);
SaleDetails saleDetails = new SaleDetails
{
ProductId = item.ProductId,
SaleDetailsQuantity = item.ProductQuantity,
SaleDetailsSubTotal = product.ProductPrice * item.ProductQuantity,
SaleKey = sale.SaleKey
};
db.SaleDetails.Add(saleDetails);
db.SaveChanges();
}
}
return(RedirectToAction("Index"));
}
catch (Exception)
{
return(View(salesViewModel));
}
//return View();
}
public async Task UpdateSale(SaleModelView model)
{
Sale oldDetailSale = await GetById(model.Id);
List <SaleDetails> saleDetailList = _context.SaleDetailses.Where(x => x.SaleId == model.Id).ToList();
foreach (SaleDetails item in saleDetailList)
{
_context.Set <SaleDetails>().Remove(item);
}
_context.SaveChangesAsync();
oldDetailSale.Modify = DateTime.Now;
oldDetailSale.NoOfItem = model.NoOfProduct;
oldDetailSale.TotalAmount = model.TotalAmount;
await Update(oldDetailSale);
if (model.Id != null)
{
foreach (SaleDetailsViewModel item in model.SaleDetails)
{
SaleDetails product = new SaleDetails();
product.SaleId = model.Id;
product.Quantity = item.Quantity;
product.ProductId = item.ProductId;
product.Price = item.Price;
product.MeasureType = item.Unit.ToString();
product.Create = DateTime.Now;
product.CreateBy = Guid.NewGuid();
product.Modify = DateTime.Now;
product.ModifyBy = Guid.NewGuid();
_context.Set <SaleDetails>().AddAsync(product);
}
}
await _context.SaveChangesAsync();
}
