public static List <SalesDetails> GetChartData()
{
String ConnectionString = ConfigurationManager.ConnectionStrings["PointofSaleConstr"].ConnectionString;
DataTable dt = new DataTable();
using (SqlConnection con = new SqlConnection(ConnectionString))
{
con.Open();
SqlCommand cmd = new SqlCommand(" SELECT top 8 CONVERT(VARCHAR(10), Logdate,121 ) as [DATE] , SUM([totalpayable]) as [Total] " +
" FROM tbl_SalesPayment " +
// " WHERE CONVERT(VARCHAR(11),Logdate,106) between GETDATE() - 3330 and GETDATE() " +
" group by CONVERT(VARCHAR(10), Logdate,121 ) order by CONVERT(VARCHAR(10), Logdate,121 ) desc ", con);
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(dt);
con.Close();
}
List <SalesDetails> dataList = new List <SalesDetails>();
foreach (DataRow dtrow in dt.Rows)
{
SalesDetails details = new SalesDetails();
details.DATE = dtrow[0].ToString();
details.Total = Convert.ToInt32(dtrow[1]);
dataList.Add(details);
}
return(dataList);
}
internal void InsertSalesDetails(SalesDetails instance, string invstatus)
{
base.com.CommandText = "spInsertSalesDetailsByItem";
base.com.Parameters.AddWithValue("_InvNo", instance.InvNo);
base.com.Parameters.AddWithValue("_ProdID", instance.ProdID);
base.com.Parameters.AddWithValue("_Qty", instance.Qty);
base.com.Parameters.AddWithValue("_UnitPx", instance.UnitPx);
base.com.Parameters.AddWithValue("_Prodname", instance.ProdName_);
base.com.Parameters.AddWithValue("_IMEI", instance.IMEI_);
base.com.Parameters.AddWithValue("_Discount", instance.Discount);
base.com.Parameters.AddWithValue("_InvStatus", invstatus);
try
{
int res = Convert.ToInt32(base.com.ExecuteScalar());
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
closeConnection();
}
}
private void salesList()
{
int c = sale.Count - 1;
int addStock;
string prdName = Tbl_prdName.Text;
int prdId = (from prd in products where ((prd.productName.Equals(prdName))) select prd.productId).First();
var sales = new SalesDetails {
salesId = c + 1, productName = Tbl_prdName.Text, quantityRequired = int.Parse(Tbx_qtyRequired.Text), totalPrice = int.Parse(Tbx_totalPrice.Text)
};
sale.Add(sales);
Lbx_sales.SelectedItem = sales;
Lbx_sales.ItemsSource = sale;
DataStorage.WriteXml <ObservableCollection <SalesDetails> >(sale, "SalesDataTable.xml");
int getstockAvailable = (from prd in products where ((prd.productId.Equals(prdId))) select prd.stockAvailable).First();
addStock = getstockAvailable - int.Parse(Tbx_qtyRequired.Text);
var updateStock = from prd in products
where prd.productId == prdId
select prd;
foreach (var add in updateStock)
{
add.stockAvailable = addStock;
}
Tbx_qtyRequired.Text = "";
Tbx_totalPrice.Text = "";
storeData = true;
}
public ActionResult Save(SalesSaveViewModel salesModelVm)
{
if (ModelState.IsValid)
{
SalesDetails salesModel = new SalesDetails();
salesModel = Mapper.Map <SalesDetails>(salesModelVm);
if (_salesManager.Save(salesModel))
{
TempData["SuccessMessage"] = "Data Saved SuccessFully!";
ViewBag.SuccessMsg = "Data Saved SuccessFully!";
}
else
{
TempData["SuccessDeleteMessage"] = "Record Delete Successfully";
ViewBag.FailMsg = "Data Saved Fail!";
}
}
else
{
TempData["SuccessDeleteMessage"] = "Record Delete Successfully";
ViewBag.FailMsg = "Data Validtion Fail!";
}
salesModelVm.CustomerList = _customerManager.FindAll().Select(c => new SelectListItem()
{
Value = c.Id.ToString(),
Text = c.CustName
});
return(View(salesModelVm));
}
public List <SalesDetails> PurchasesDetailsRecord(int salesId)
{
List <SalesDetails> salesDetails = new List <SalesDetails>();
connection = new Connection();
string query = @"Select * From SalesDetailsRecord where SalesID='" + salesId + "'";
sqlCommand = new SqlCommand(query, connection.GetConnection());
reader = sqlCommand.ExecuteReader();
while (reader.Read())
{
SalesDetails salesDetail = new SalesDetails();
//purchaseDetail.PurchaseID = Convert.ToInt32(reader["ID"]);
salesDetail.ProductName = reader["ProductName"].ToString();
salesDetail.CategoryName = reader["Category"].ToString();
salesDetail.Quantity = Convert.ToDouble(reader["Quantity"]);
salesDetail.MRP = Convert.ToDouble(reader["MRP"]);
salesDetail.TotalMRP = Convert.ToDouble(reader["TotalMRP"]);
salesDetails.Add(salesDetail);
}
connection.GetClose();
return(salesDetails);
}
public bool DeleteSalesDetail(SalesDetail salesDetails)
{
SalesDetails.Remove(salesDetails);
BindSalesDetail();
return(true);
}
private void AddButton_Click(object sender, EventArgs e)
{
int status = 1;
var salesDetails = new SalesDetails();
foreach (var s in _salesDetails)
{
if (s.ProductName.Contains(productComboBox.Text))
{
MessageBox.Show("Product already in list");
status = 0;
}
}
salesDetails.CustomerID = Convert.ToInt32(customerComboBox.SelectedValue);
salesDetails.CategoryID = Convert.ToInt32(categoryComboBox.SelectedValue);
salesDetails.ProductID = Convert.ToInt32(productComboBox.SelectedValue);
var product = productManager.SearchById(salesDetails.ProductID);
salesDetails.ProductName = product.Name;
salesDetails.Quantity = Convert.ToDouble(quantityTextBox.Text);
salesDetails.MRP = Convert.ToDouble(MRPTextBox.Text);
salesDetails.TotalMRP = Convert.ToDouble(totalPriceTextBox.Text);
if (status == 1)
{
_salesDetails.Add(salesDetails);
ShowListToGridView(_salesDetails);
GetLoyaltyPint(_salesDetails);
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,SalesId")] SalesDetails salesDetails)
{
if (id != salesDetails.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(salesDetails);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SalesDetailsExists(salesDetails.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(salesDetails));
}
public override global::System.Data.DataSet Clone()
{
SalesDetails cln = ((SalesDetails)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
/// <summary>
/// Servicio que devuelve el DTO de la entidad SalesDetails (SalesDetails) con el Id dado por parametro
/// </summary>
/// <param name="id">Id del DTO requerida</param>
/// <returns>La DTO con el Id dado por parametro</returns>
public SalesDetailsDTO Get(int id)
{
using (_dbContextScopeFactory)
{
SalesDetails entity = _repository.Get(id);
return(GetDTO(entity));
}
}
/// <summary>
/// Insert and update the sales details..
/// </summary>
/// <param name="users"></param>
/// <returns></returns>
public long InsertUpdateSalesDetails(SalesDetails SalesDetails)
{
long LastId = 0;
var DbManager = new DBManager("DBConnection");
DbManager.Insert(_StoredProcedures.InsertUpdateSalesDetails_SP, CommandType.StoredProcedure, _SalesIRepository.AddParmsSalesDetails(SalesDetails), out LastId);
return(LastId);
}
/// <summary>
/// Metodo que dada una entidad devuelve su DTO
/// </summary>
/// <param name="entity">Entidad de la cual se requiere el DTO</param>
/// <returns>DTO para la entidad pasada por parametro</returns>
private SalesDetailsDTO GetDTO(SalesDetails entity)
{
SalesDetailsDTO dto = new SalesDetailsDTO();
dto.SalesDetailsId = entity.SalesDetailsId;
this.SetDTOExtras(entity, ref dto);
return(dto);
}
/// <summary>
/// Servicio que permite insertar una nueva entidad: SalesDetails (SalesDetails)
/// </summary>
/// <param name="entity">DTO de la entidad a insertar</param>
/// <param name="user">Usuario que ejecuta la inserción</param>
/// <returns>Se devulve el DTO de la entidad creada con el id asignado</returns>
public SalesDetailsDTO Insert(SalesDetailsDTO dto, string user)
{
using (var dbContextScope = new TiendaDbContext())
{
SalesDetails entity = GetEntity(dto);
entity = _repository.Insert(entity, user);
dbContextScope.SaveChanges();
return(GetDTO(entity));
}
}
/// <summary>
/// Add parameters while adding the purchase details
/// </summary>
/// <param name="users"></param>
/// <returns></returns>
public IDbDataParameter[] AddParamsGetBrandMaster(SalesDetails SalesDetails)
{
parameters.Clear();
parameters.Add(dbManager.CreateParameter("@BrandCode", 2, SalesDetails.BrandCode, DbType.Int32));
parameters.Add(dbManager.CreateParameter("@ColorCode", 2, SalesDetails.ColorCode, DbType.Int32));
parameters.Add(dbManager.CreateParameter("@PurchaseId", 2, SalesDetails.PurchaseId, DbType.Int32));
parameters.Add(dbManager.CreateParameter("@PurchaseLineId", 2, SalesDetails.PurchaseLineId, DbType.Int32));
parameters.Add(dbManager.CreateParameter("@OperationType", 2, SalesDetails.OperationType, DbType.Int16));
return(parameters.ToArray());
}
private void ShowSalesDetailsForm()
{
SalesDetails Itm = new SalesDetails();
Itm.TopLevel = false;
this.Controls.Add(Itm);
Itm.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
Itm.Dock = DockStyle.Fill;
Itm.BringToFront();
Itm.Show();
}
public async Task <IActionResult> SalesReport(ReportsViewModel model)
{
DateTime startDateTime = model.FromDate;
DateTime endDateTime = model.ToDate.AddDays(1).AddTicks(-1);
var sales = await
_context.Orders.Where(o =>
o.Status == Status.DELIVERED && o.DateOrdered >= startDateTime && o.DateOrdered <= endDateTime).ToListAsync();
var vm = new SalesReportViewModel();
vm.Sales = new List <SalesDetails>();
vm.FromDate = model.FromDate;
vm.ToDate = endDateTime;
if (sales != null && sales.Count > 0)
{
foreach (var s in sales)
{
var product = await _context.Products.FirstOrDefaultAsync(p => p.ProductID == s.ProductID);
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == s.UserID);
if (product != null && user != null)
{
var details = new SalesDetails
{
OrderID = s.OrderID,
Quantity = s.Quantity,
PaymentMethod = s.PaymentMethod,
Status = s.Status,
TotalPrice = s.Amount,
Price = product.Price,
CustomerName = user.FirstName + " " + user.LastName,
DateOrdered = s.DateOrdered,
ProductName = product.ProductName
};
vm.Sales.Add(details);
}
}
return(new ViewAsPdf("SalesReport", vm)
{
PageOrientation = Orientation.Landscape,
FileName = "SalesReport_" + DateTime.Now + ".pdf"
});
// return View("SalesReport", vm);
}
return(NotFound());
}
public async Task <IActionResult> Create([Bind("ID,SalesId")] SalesDetails salesDetails)
{
if (ModelState.IsValid)
{
_context.Add(salesDetails);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(salesDetails));
}
public static int addSalesDetails(SalesDetails sale, PusrchaseSaleAccount purchase)
{
try
{
int i = salesDetailsProvider.addSalesDetails(sale, purchase);
return(i);
}
catch (Exception ex)
{
throw ex;
}
}
public static int addSalesChallanDetails(SalesDetails saleChallan)
{
try
{
int result = SaleChallanTempProvider.addSalesChallanDetails(saleChallan);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public bool Update(SalesDetails salesModel)
{
int isExecuted = 0;
db.Entry(salesModel).State = EntityState.Modified;
isExecuted = db.SaveChanges();
if (isExecuted > 0)
{
return(true);
}
return(false);
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
SalesDetails ds = new SalesDetails();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
public static int addTempSalesDetailsForConvertChalan(SalesDetails salechalan)
{
try
{
int result = TempSaleDetailsProvider.addTempSalesDetailsForConvertChalan(salechalan);
return(result);
}
catch (Exception ae)
{
throw ae;
}
}
public JsonResult AddCustomer(string FirstName, string LastName, string CustMobile, int State, int City)
{
if (ModelState.IsValid)
{
SalesDetails _details = new SalesDetails();
return(Json(ReturnAjaxAlertMessage(_details.AddCustomer(FirstName, LastName, CustMobile, State, City)).ToList(), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(GetErrorList(), JsonRequestBehavior.AllowGet));
}
}
public JsonResult SaveReturnInvoice(InvoiceReturnDetails invoiceReturnDetails)
{
if (ModelState.IsValid)
{
SalesDetails _details = new SalesDetails();
return(Json(ReturnAjaxAlertMessage(_details.SaveReturnInvoice(invoiceReturnDetails)).ToList(), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(GetErrorList(), JsonRequestBehavior.AllowGet));
}
}
protected void gvSales_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
//
string datakey = gvSales.DataKeys[e.Row.RowIndex].Values[0].ToString();
GridView gvDetails = e.Row.FindControl("gvDetails") as GridView;
gvDetails.DataSource = SalesDetails.GetSalesDetailsByInvno(datakey);
gvDetails.DataBind();
}
}
public static int addTempSalesDetails(SalesDetails sale)
{
try
{
int i = TempSaleDetailsProvider.addTempSalesDetails(sale);
return(i);
}
catch (Exception ex)
{
throw ex;
}
}
public static int addSalesOrderDetails(SalesDetails saleChallan)
{
try
{
int i = salesDetailsProvider.addSalesOrderDetails(saleChallan);
return(i);
}
catch (Exception ex)
{
throw ex;
}
}
public List <Sales> GetSales()
{
List <Sales> salesList1 = new List <Sales>();
cls_user_responses clsUserResponses = new cls_user_responses();
List <Sales> salesList2;
try
{
using (CustomERPEntities customErpEntities = new CustomERPEntities())
{
List <Sales> list1 = customErpEntities.Sales.Select <Sales, Sales>((Expression <Func <Sales, Sales> >)(itm => itm)).ToList <Sales>();
foreach (Sales sales in list1)
{
Sales customerName = sales;
List <SalesDetails> list2 = customErpEntities.SalesDetails.Where <SalesDetails>((Expression <Func <SalesDetails, bool> >)(sl => sl.SalesID == customerName.IDNUMBER)).ToList <SalesDetails>();
if (list2.Count > 0)
{
foreach (SalesDetails salesDetails in list2)
{
SalesDetails itemName = salesDetails;
Item obj = customErpEntities.Item.Where <Item>((Expression <Func <Item, bool> >)(it => it.IDNUMBER == itemName.ItemID)).FirstOrDefault <Item>();
if (obj != null)
{
itemName.ItemName = obj.ItemName;
itemName.ProductImage = obj.ItemImage;
ItemVarient itemVarient = customErpEntities.ItemVarient.Where <ItemVarient>((Expression <Func <ItemVarient, bool> >)(itv => itv.IDNUMBER == itemName.ItemVarientID)).FirstOrDefault <ItemVarient>();
if (itemVarient != null)
{
itemName.Color = itemVarient.Color;
itemName.SKU = itemVarient.SKU;
itemName.UPC = itemVarient.UPC;
}
}
}
customerName.SalesDetails = list2;
}
Customer customer = customErpEntities.Customer.Where <Customer>((Expression <Func <Customer, bool> >)(cp => cp.IDNUMBER == customerName.CustomerID)).FirstOrDefault <Customer>();
if (customer != null)
{
customerName.CustomerName = customer.CustomerName;
}
}
salesList1 = list1;
salesList2 = salesList1;
}
}
catch (Exception ex)
{
salesList2 = salesList1;
}
return(salesList2);
}
/// <summary>
/// Metodo que actualiza la entidad SalesDetails (SalesDetails) con los datos pasados por parametro
/// </summary>
/// <param name="entity">Entidad a actualizar</param>
/// <param name="user">Usuario que actualiza la entidad</param>
public void Update(SalesDetails entity, string user)
{
try
{
Context.Entry(entity).State = EntityState.Modified;
entity.UpdateTime = DateTime.UtcNow;
Context.ChangeTracker.DetectChanges();
}
catch (Exception e)
{
throw new Exception("Error al Actualizar SalesDetails");
}
}
/// <summary>
/// Update SalesDetails
/// </summary>
/// <param name="entity"></param>
/// <returns>Message</returns>
public async Task <string> UpdateSalesDetails(SalesDetails entity)
{
try
{
var result = await new SalesDetailsRepository(logger).Update(entity);
return(result);
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw ex;
}
}
