private void UpsertDailyProductReport(
string productDetailId,
ReportParameterBase reportParameterBase,
List <IGrouping <string, SaleDetail> > saleDetailsGrouped,
List <IGrouping <string, PurchaseDetail> > purchaseDetailsGrouped,
List <ProductDetail> productDetails,
List <ProductCategory> categories)
{
ProductReportParameter parameter = new ProductReportParameter(
reportParameterBase.Date,
reportParameterBase.Value,
reportParameterBase.ReportShopId);
parameter.StartingQuantity = this.GetPrevious(parameter);
var sold = saleDetailsGrouped.Exists(x => x.Key == productDetailId)
? saleDetailsGrouped.First(x => x.Key == productDetailId).ToList()
: new List <SaleDetail>();
var purchased = purchaseDetailsGrouped.Exists(x => x.Key == productDetailId)
? purchaseDetailsGrouped.First(x => x.Key == productDetailId).ToList()
: new List <PurchaseDetail>();
T productDetail = productDetails.First(x => x.Id == productDetailId);
var category = categories.First(x => x.Id == productDetail.ProductCategoryId);
var productReport = this.CreateModel(parameter, category, productDetail, purchased, sold);
Console.WriteLine(
$"Model saving - {productReport.Date} and product {productReport.ProductDetailName} and SaleQuantity {productReport.QuantitySaleToday}");
this.SaveReport(productReport);
}
private void ProcessShopClose(string shopId, IGrouping <int?, T> dailyGrouped)
{
if (dailyGrouped.Any())
{
var year = dailyGrouped.First().Modified.Year;
DateTime date = new DateTime(year, 1, 1).AddDays(dailyGrouped.Key.Value - 1);
Console.WriteLine($"Processing {date.ToString("dd-MMMM-yyyy")}");
ReportParameterBase p = new ReportParameterBase(
date,
date.ToString("dd-MMMM-yyyy"),
shopId);
var reports = this.CreateReportModels(dailyGrouped.ToList(), p).ToList();
this.SaveReports(reports);
}
}
public override IEnumerable <M> CreateReportModels(List <T> models, ReportParameterBase p)
{
string defaultAccountHeadId = new Guid().ToString();
string defaultAccountHeadName = "All";
TransactionReportParameter previousParameter = new TransactionReportParameter(
TransactionReportType.TransactionByAmount,
defaultAccountHeadName,
defaultAccountHeadId,
null,
p);
var startingAll = this.GetPreviousEnding(previousParameter);
var parameterAll = new TransactionReportParameter(
TransactionReportType.TransactionByAmount,
defaultAccountHeadName,
defaultAccountHeadId,
startingAll,
p);
var allReport = this.CreateReportModel(models, parameterAll);
yield return(allReport);
List <IGrouping <string, T> > transactionsByAccId = models.GroupBy(x => x.AccountHeadId).ToList();
foreach (var tById in transactionsByAccId)
{
var accId = tById.Key;
if (tById.Any())
{
var transaction = tById.First();
previousParameter.TransactionReportType = TransactionReportType.TransactionByAccountHead;
previousParameter.AccountHeadId = accId;
Dictionary <TransactionMedium, double> startingAmountsByAccount = GetPreviousEnding(previousParameter);
var parameterByAccount = new TransactionReportParameter(TransactionReportType.TransactionByAccountHead, transaction.AccountHeadName, accId, startingAmountsByAccount, p);
M transactionReport = this.CreateReportModel(tById.ToList(), parameterByAccount);
yield return(transactionReport);
}
}
}
private void UpsertDailyAllProduct(
string shopId,
ReportTimeType reportTimeType,
DateTime operationDate,
List <PurchaseDetail> purchaseDetails,
List <SaleDetail> saleDetails,
List <ProductDetail> productDetails,
List <ProductCategory> categories)
{
Console.WriteLine($"Operation date : {operationDate}");
var dailyPurchase = purchaseDetails.Where(x => x.Modified.Date == operationDate);
var dailySales = saleDetails.Where(x => x.Modified.Date == operationDate);
List <IGrouping <string, PurchaseDetail> > purchaseDetailsGrouped =
dailyPurchase.GroupBy(x => x.ProductDetailId).ToList();
List <IGrouping <string, SaleDetail> > saleDetailsGrouped = dailySales.GroupBy(x => x.ProductDetailId).ToList();
//List<string> dailyPurchaseIds = purchaseDetailsGrouped.Select(x => x.Key).ToList();
//List<string> dailySoldIds = saleDetailsGrouped.Select(x => x.Key).ToList();
//List<string> dailyAllIds = dailySoldIds.Union(dailyPurchaseIds).ToList();
List <string> dailyAllIds = productDetails.Select(x => x.Id).Distinct().ToList();
string value = this.GetValue(reportTimeType, operationDate);
ReportParameterBase reportParameterBase = new ReportParameterBase(operationDate, value, shopId);
//foreach (string productDetailId in dailyAllIds)
//{
// this.UpsertDailyProductReport(productDetailId, reportParameterBase, saleDetailsGrouped, purchaseDetailsGrouped, productDetails, categories);
//}
Parallel.ForEach(
dailyAllIds,
productDetailId => this.UpsertDailyProductReport(
productDetailId,
reportParameterBase,
saleDetailsGrouped,
purchaseDetailsGrouped,
productDetails,
categories));
}
public override M CreateReportModel(List <T> models, ReportParameterBase reportParameter)
{
var parameter = (TransactionReportParameter)reportParameter;
M report = new M();
report.Id = Guid.NewGuid().ToString();
report.CreatedFrom = "BizBook";
report.CreatedBy = "Automatic";
report.ModifiedBy = "Automatic";
report.Created = DateTime.Today.Date;
report.Modified = DateTime.Today.Date;
report.ShopId = reportParameter.ReportShopId;
report.ReportTimeType = reportParameter.ReportTimeType;
report.Date = reportParameter.Date.Date;
report.Value = reportParameter.Value;
report.RowsCount = models.Count;
report.TransactionReportType = parameter.TransactionReportType;
report.AccountHeadId = parameter.AccountHeadId;
report.AccountHeadName = parameter.AccountHeadName;
report.TotalStarting = parameter.TotalStarting;
report.CashStarting = parameter.CashStarting;
report.CardStarting = parameter.CardStarting;
report.ChequeStarting = parameter.ChequeStarting;
report.MobileStarting = parameter.MobileStarting;
report.OtherStarting = parameter.OtherStarting;
report.TotalRowsCount = models.Count;
report.TotalIn = models.GetIncome();
report.TotalOut = models.GetExpense();
report.TotalEnding = report.TotalStarting + report.TotalIn - report.TotalOut;
var cashTransactions = models.Where(x => x.TransactionMedium == TransactionMedium.Cash).ToList();
report.CashRowsCount = cashTransactions.Count;
report.CashIn = cashTransactions.GetIncome();
report.CashOut = cashTransactions.GetExpense();
report.CashEnding = report.CashStarting + report.CashIn - report.CashOut;
var cardTransactions = models.Where(x => x.TransactionMedium == TransactionMedium.Card).ToList();
report.CardRowsCount = cardTransactions.Count;
report.CardIn = cardTransactions.GetIncome();
report.CardOut = cardTransactions.GetExpense();
report.CardEnding = report.CardStarting + report.CardIn - report.CardOut;
var chequeTransactions = models.Where(x => x.TransactionMedium == TransactionMedium.Cheque).ToList();
report.ChequeRowsCount = chequeTransactions.Count;
report.ChequeIn = chequeTransactions.GetIncome();
report.ChequeOut = chequeTransactions.GetExpense();
report.ChequeEnding = report.ChequeStarting + report.ChequeIn - report.ChequeOut;
var mobileTransactions = models.Where(x => x.TransactionMedium == TransactionMedium.Mobile).ToList();
report.MobileRowsCount = mobileTransactions.Count;
report.MobileIn = mobileTransactions.GetIncome();
report.MobileOut = mobileTransactions.GetExpense();
report.MobileEnding = report.MobileStarting + report.MobileIn - report.MobileOut;
var otherTransactions = models.Where(x => x.TransactionMedium == TransactionMedium.Other).ToList();
report.OtherRowsCount = otherTransactions.Count;
report.OtherIn = otherTransactions.GetIncome();
report.OtherOut = otherTransactions.GetExpense();
report.OtherEnding = report.OtherStarting + report.OtherIn - report.OtherOut;
return(report);
}
public virtual void ShopClose(string shopId, DateTime start, DateTime end, ReportTimeType reportTimeType)
{
IQueryable <T> models = this.db.Set <T>().AsQueryable();
Expression <Func <T, bool> > expression = x => x.ShopId == shopId && x.Modified >= start && x.Modified <= end;
IQueryable <T> allModelsForTheShop = models.Where(expression).OrderByDescending(x => x.Modified).AsQueryable();
switch (reportTimeType)
{
case ReportTimeType.Daily:
var years = allModelsForTheShop.GroupBy(this.yearKeySelector).Select(x => x.Key).ToList();
foreach (var year in years)
{
List <IGrouping <int?, T> > dailyGroupedModels = allModelsForTheShop
.Where(x => x.Modified.Year == year).GroupBy(dayKeySelector).OrderBy(x => x.Key)
.ToList();
foreach (IGrouping <int?, T> dailyGrouped in dailyGroupedModels)
{
this.ProcessShopClose(shopId, dailyGrouped);
}
// Parallel.ForEach(dailyGroupedModels, x => ProcessShopClose(shopId, end, x));
}
break;
case ReportTimeType.Weekly:
var weeklySales = allModelsForTheShop.GroupBy(weekKeySelector).OrderBy(x => x.Key).ToList();
foreach (var week in weeklySales)
{
if (week.Any())
{
List <T> weeklySalesList = week.OrderBy(x => x.Modified).ToList();
DateTime date = weeklySalesList.First().Modified.Date;
string value = "Week " + calendar.GetWeekOfYear(
date,
CalendarWeekRule.FirstDay,
DayOfWeek.Sunday) + "-" + date.Year;
ReportParameterBase p = new ReportParameterBase(date, value, shopId);
var reports = this.CreateReportModels(weeklySalesList, p).ToList();
this.SaveReports(reports);
}
}
break;
case ReportTimeType.Monthly:
var monthlySales = allModelsForTheShop.GroupBy(monthKeySelector).OrderBy(x => x.Key).ToList();
foreach (var month in monthlySales)
{
DateTime date = new DateTime(end.Year, month.Key.Value, 1);
if (month.Any())
{
ReportParameterBase p = new ReportParameterBase(
date,
date.ToString("MMMM-yyyy"),
shopId);
var reports = this.CreateReportModels(month.ToList(), p).ToList();
this.SaveReports(reports);
}
}
break;
case ReportTimeType.Yearly:
List <IGrouping <int?, T> > yearlySales = allModelsForTheShop.GroupBy(yearKeySelector).ToList();
foreach (var yearlySale in yearlySales)
{
DateTime date = new DateTime((int)yearlySale.Key, 1, 1);
ReportParameterBase p = new ReportParameterBase(date,
date.ToString("yyyy"), shopId);
var reports = this.CreateReportModels(yearlySale.ToList(), p).ToList();
this.SaveReports(reports);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(reportTimeType), reportTimeType, null);
}
}
public abstract M CreateReportModel(List <T> models, ReportParameterBase reportParameter);
public abstract IEnumerable <M> CreateReportModels(List <T> models, ReportParameterBase p);
