public void StoreTransaction(long accountNo, double Amount, TypeOfTranscation type, string mode, string chequeNo)
{
//// retrieving customerID based on account No
string customerID = "00000000000000";// dummy initialization to avoid warnings
foreach (Account acc in AccountDAL.ListOfAccounts)
{
if (acc.AccountNo == accountNo)
{
customerID = acc.CustomerID;
}
}
DateTime time = DateTime.Now;
string transactionID = "TRANS" + time.ToString("yyyyMMddhhmmss");//sample transactionID : TRANS20190921154525
TransactionEntities trans = new TransactionEntities();
trans.AccountNo = accountNo;
trans.CustomerID = customerID;
trans.Type = type;
trans.Amount = Amount;
trans.TransactionID = transactionID;
trans.DateOfTransaction = time;
trans.Mode = mode;
trans.ChequeNo = chequeNo;
Transactions.Add(trans);
}
public bool InsertTransaction(TransactionModel.TransactionData TransactionDetail, string UserID)
{
transactionEntities = new TransactionEntities();
try
{
var config = new MapperConfiguration(
cfg =>
{
cfg.CreateMap <TransactionModel.TransactionData, Data.Transaction>()
.ForMember(x => x.TransStartDate, y => y.MapFrom(z => z.StartDate))
.ForMember(x => x.TransEndDate, y => y.MapFrom(z => z.EndDate));
}
);
var mapper = config.CreateMapper();
var transaction = mapper.Map <Data.Transaction>(TransactionDetail);
transactionEntities.Transactions.Add(transaction);
transactionEntities.SaveChanges();
result = true;
}
catch (Exception ex)
{
log = new Logger();
log.LogError(UserID, "DataSolutions.Data", "InsertUser", ex.Message);
}
return(result);
}
public void Add(List <TransactionRecord> records)
{
var db = new TransactionEntities();
db.TransactionRecords.AddRange(records);
db.SaveChanges();
}
public List <TransactionModel.TransactionView> TransactionHistory(TransactionModel.TransactionReport TransactionDetail, string UserID)
{
transactionEntities = new TransactionEntities();
List <TransactionModel.TransactionView> results = new List <TransactionModel.TransactionView>();
try
{
var trans = from t in transactionEntities.Transactions
join p in transactionEntities.Products on t.ProductID equals p.ProductID
join u in transactionEntities.Users on t.UserID equals u.UserID
where t.UserID == TransactionDetail.UserID && t.TransEndDate == TransactionDetail.StartDate &&
t.TransEndDate == TransactionDetail.EndDate
select new TransactionModel.TransactionView
{
EndDate = TransactionDetail.EndDate,
IsSuccessful = t.IsSuccessful,
MainOrganization = u.OrganizationName,
Message = t.Message,
StartDate = TransactionDetail.StartDate,
TransID = t.TransID,
Username = u.Username
};
results = trans.ToList();
}
catch (Exception ex)
{
log = new Logger();
log.LogError(UserID, "DataSolutions.Data", "TransactionHistory", ex.Message);
}
return(results);
}
public bool ListTransactionByTransactionID_PL()
{
Console.Clear();
Console.WriteLine("------ Transaction Details ------");
Console.Write("Enter Transaction ID:");
string transactionID = Console.ReadLine();
try
{
TransactionsBL transBL = new TransactionsBL();
TransactionEntities transaction = transBL.DisplayTransactionByTransactionID_BL(transactionID);
if (transaction == null)
{
Console.WriteLine($"No Records found for {transactionID}");
return(false);
}
else
{
BusinessLogicUtil.ShowTransactionDetails(transaction);
Console.WriteLine("Press Any Key -> Previous Menu");
return(true);
}
}
catch (TransactionDetailsException e)
{
Console.WriteLine(e.Message);
Console.WriteLine("Press Any Key -> Try Again");
return(false);
}
}
static void Main(string[] args)
{
var db = new TransactionEntities();
Console.WriteLine("DB Connection Established.");
Console.WriteLine("Clearing old recommendations.");
db.ProductRecommendations.ToList().Select(p => db.ProductRecommendations.Remove(p));
db.SaveChanges();
Console.WriteLine("Calculating new recommendations.");
var records = db.TransactionRecords.ToList();
var products = records.Select(t => t.productId).Distinct().OrderBy(t => t).ToList();
var results = new List <ProductRecommendation>();
products.ForEach(p =>
{
Console.WriteLine($"Calculating recommendations for {p}");
var rec = new ProductRecommendation();
rec.ProductId = int.Parse(p);
rec.RecomendedProductIdsJson = JsonConvert.SerializeObject(CommonlyPurchasedTogether(p, records));
});
Console.WriteLine("Saving results.");
db.ProductRecommendations.AddRange(results);
db.SaveChanges();
Console.WriteLine("All done. Press the anykey to exit!");
Console.ReadLine();
}
public JsonResult UpdateStoreData(Store store)
{
using (TransactionEntities db = new TransactionEntities())
{
if (ModelState.IsValid)
{
try
{
db.Entry(store).State = EntityState.Modified;
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
var result = db.Stores.SingleOrDefault(a => a.Id == store.Id);
if (result == null)
{
return(Json(new { success = false, message = "Cannot find store to update" }, JsonRequestBehavior.AllowGet));
}
else
{
throw;
}
}
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
}
return(Json(new { success = false, message = "Invalid store given" }, JsonRequestBehavior.AllowGet));
}
public JsonResult GetProductData()
{
using (TransactionEntities db = new TransactionEntities())
{
var Product = db.Products.ToList();
var Products = Product.Select(x => new { x.Id, x.Name, x.Price });
return(Json(Products, JsonRequestBehavior.AllowGet));
}
}
public JsonResult GetSalesData()
{
using (TransactionEntities db = new TransactionEntities())
{
var sales = db.Sales.Include("Customer").Include("Product").Include("Store").ToList();
var SalesRecord = sales.Select(x => new { x.ID, CustomerName = x.Customer.Name, ProductName = x.Product.Name, StoreName = x.Store.Name, DateSold = x.DateSold.ToString("yyyy/MM/dd") });
return(Json(SalesRecord, JsonRequestBehavior.AllowGet));
}
}
public JsonResult GetCustomerData()
{
using (TransactionEntities db = new TransactionEntities())
{
var users = db.Customers.ToList();
var customers = users.Select(x => new { x.ID, x.Name, x.Address });
return(Json(customers, JsonRequestBehavior.AllowGet));
}
}
public JsonResult GetStoreData()
{
using (TransactionEntities db = new TransactionEntities())
{
var stores = db.Stores.ToList();
var storesRecord = stores.Select(x => new { x.Id, x.Name, x.Address });
return(Json(storesRecord, JsonRequestBehavior.AllowGet));
}
}
public GoOutReason GetGoOutReasonID(GoOutReasonCriteria criteria)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.GetGoOutReasonID(
goOutID: criteria.ID
).FirstOrDefault();
return(result);
}
}
public ActionResult Index()
{
var db = new TransactionEntities();
Dictionary <int, string> data = new Dictionary <int, string>();
var table_inmem = db.ProductRecommendations.ToList();
table_inmem.ForEach(r => {
data.Add((r.ProductId), r.RecomendedProductIdsJson);
});
ViewBag.data = data;
return(View());
}
public List <TransactionsDataPoints> GetTransactionsLadt10Days(int UserID)
{
List <TransactionsDataPoints> chartData = new List <TransactionsDataPoints>();
try
{
using (TransactionEntities transactions = new TransactionEntities())
{
DateTime startDate = DateTime.Now.AddDays(-10);
var trans = (from t in transactions.Transactions
where t.UserID == UserID &&
t.TransEndDate >= startDate
group t.TransID by DbFunctions.TruncateTime(t.TransEndDate) into point
select new TransactionsDataPoints
{
TransactionCount = point.ToList().Count,
TransactionDate = (DateTime)point.Key
}).ToList();
//.ToList()
//.GroupBy(t => DbFunctions.TruncateTime(t.TransEndDate))
//.Select(t => new TransactionsDataPoints
// {
// TransactionCount = t.Count(),
// TransactionDate = (DateTime)t.Key
// });
//var chartData = trans
// .GroupBy(t => DbFunctions.TruncateTime(t.TransEndDate))
// .Select(t => new TransactionsDataPoints
// {
// TransactionCount = t.Count(),
// TransactionDate = (DateTime)t.Key
// });
//foreach (var item in trans)
//{
// chartData.Add(new TransactionsDataPoints {
// TransactionCount = item.TransactionCount,
// TransactionDate = item.TransactionDate
// });
//}
return(trans);
}
}
catch (Exception ex)
{
log = new Logger();
log.LogError(UserID.ToString(), "DataSolutions.Data", "GetTransactionsLadt10Days", ex.Message);
}
return(chartData);
}
public DeleteGoOutReasonResult DeleteGoOutReason(int ID, string UserCode)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.DeleteGoOutReason(
goOutID: ID
, userCode: UserCode
).FirstOrDefault();
return(result);
}
}
public ResetPasswordResult ResetPassword(string empCodeXML, string userCode)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.ResetPassword(
empCodeXML: empCodeXML
, userCode: userCode
).FirstOrDefault();
return(result);
}
}
public List <GetDivisionComboResult> GetDivisionCombo(DivisionCriteria criteria)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.GetDivisionCombo(
prodDate: criteria.ProdDate
, userCode: criteria.UserCode
).ToList();
return(result);
}
}
public DeleteWorkShiftByEmpResult DeleteAssignWorkShiftByEmp(AssignWorkShiftByEmp entity)
{
using (TransactionEntities context = new TransactionEntities())
{
var result = context.DeleteWorkShiftByEmp(
prodDate: entity.ProdDate
, empCode: entity.EmpCode
, userCode: entity.UpdateBy
).FirstOrDefault();
return(result);
}
}
public DeleteHideOrgResult DeleteHideOrganization(HideOrg entity)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.DeleteHideOrg(
orgCode: entity.OrgCode
, hideDateFrom: entity.HideDateFrom
, userCode: entity.UpdateBy
).FirstOrDefault();
return(result);
}
}
public DeleteFixOrgByEmpResult DeleteFixOrganization(FixOrgEmp entity)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.DeleteFixOrgByEmp(
empCode: entity.EmpCode
, effectiveDateFrom: entity.EffectiveDateFrom
, userCode: entity.UpdateBy
).FirstOrDefault();
return(result);
}
}
public UpdateUserStatusResult UpdateUserStatus(string empCodeXML, string userStatus, string userCode)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.UpdateUserStatus(
empCodeXML: empCodeXML
, userStatus: userStatus
, userCode: userCode
).FirstOrDefault();
return(result);
}
}
public InsertWorkShiftByEmpResult InsertAssignWorkShiftByEmp(AssignWorkShiftByEmp entity)
{
using (TransactionEntities context = new TransactionEntities())
{
var result = context.InsertWorkShiftByEmp(
prodDateFrom: entity.ProdDateFrom
, prodDateTo: entity.ProdDateTo
, empCode: entity.EmpCode
, shiftCode: entity.ShiftCode
, userCode: entity.UpdateBy
).FirstOrDefault();
return(result);
}
}
public List <GoOutReason> SearchGoOutReason(GoOutReasonCriteria criteria)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.SearchGoOutReason(
prodDateFrom: criteria.StartTime
, prodDateTo: criteria.EndTime
, empCode: criteria.EmpCode
, empName: criteria.EmpName
, userCode: criteria.UserCode
).ToList();
return(result);
}
}
public JsonResult SaveCustomerData(Customer customer)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
db.Customers.Add(customer);
db.SaveChanges();
return(Json(new { success = true, data = customer }, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new { success = false, message = "Invalid customer given" }, JsonRequestBehavior.AllowGet));
}
}
public JsonResult SaveSalesData(Sale sale)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
db.Sales.Add(sale);
db.SaveChanges();
return(Json(new { success = true, JsonRequestBehavior.AllowGet }));
}
}
catch
{
return(Json(new { success = false, message = "Invalid" }));
}
}
public JsonResult SaveProductData(Product product)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
db.Products.Add(product);
db.SaveChanges();
return(Json(new { success = true, data = product }));
}
}
catch
{
return(Json(new { success = false, message = "Invalid" }));
}
}
public List <FixOrgEmp> SearchFixOrganization(FixOrganizationCriteria criteria)
{
using (TransactionEntities Context = new TransactionEntities())
{
var result = Context.SearchFixOrgByEmp(
prodDateFrom: criteria.ProdDateFrom
, prodDateTo: criteria.ProdDateTo
, searchEmpCode: criteria.SearchEmpCode
, searchEmpName: criteria.SearchEmpName
, empCode: criteria.EmpCode
, effectiveDateFrom: criteria.EffectiveDateFrom
).ToList();
return(result);
}
}
public JsonResult SaveStoreData(Store store)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
db.Stores.Add(store);
db.SaveChanges();
return(Json(new { success = true, data = store }));
}
}
catch
{
return(Json(new { success = false, message = "Invalid store given" }));
}
}
//Delete record from database
public JsonResult DeleteCustomerData(int id)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
Customer customer = db.Customers.Find(id);
db.Customers.Remove(customer);
db.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new { success = false, message = "Cannot delete customer" }, JsonRequestBehavior.AllowGet));
}
}
//Delete record from database
public JsonResult DeleteStoreData(int id)
{
try
{
using (TransactionEntities db = new TransactionEntities())
{
Store store = db.Stores.Find(id);
db.Stores.Remove(store);
db.SaveChanges();
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new { success = false, message = "Cannot delete Store" }, JsonRequestBehavior.AllowGet));
}
}
