public void GetSummaryForCountry(string country = null)
{
string testFile = "summary.json";
var result = GetTestData <SummaryDTO>(testFile);
var result2 = FileHandler.GetTestData <SummaryDTO>(basePath + testFile);
// flytta in den här tråkiga saken i vymodellen istället
SummaryDetailDto summary = result.Countries
.Where(c => c.Country.Equals(country))
.FirstOrDefault();
// return result;
}
public async Task <SummaryViewModel> GetSummaryViewModel(string movie = null)
{
movie = movie ?? defaultMovie;
var tasks = new List <Task>(); // en lista med olika trådar
var movies = apiClient.GetAsync <IEnumerable <MovieDto> >(baseUrl + "movies"); // ett nytt uppdrag
var summary = apiClient.GetAsync <SummaryDTO>(baseUrl + "summary"); // ännu ett uppdrag
tasks.Add(movies); // koppla ihop uppdraget med trådarna
tasks.Add(summary);
await Task.WhenAll(tasks); // kör alla trådar, parallellt
SummaryDetailDto summaryDetail = summary.Result.Movies
.Where(c => c.Title.Equals(movie))
.FirstOrDefault();
return(new SummaryViewModel(movies.Result, summaryDetail));
}
public async Task <SummaryViewModel> GetSummaryViewModel(string country = null)
{
// null coalescing
country = country ?? "Sweden";
// hämta summary
var summary = GetTestData <SummaryDTO>("summary.json");
// hämta länder
var countries = GetTestData <IEnumerable <CountryDto> >("countries.json");
// hämta info från ett specifikt land
SummaryDetailDto summaryDetail = summary.Countries
.Where(c => c.Country.Equals(country))
.FirstOrDefault();
await Task.Delay(0);
// skicka in dessa båda värden till summaryviewmodel
return(new SummaryViewModel(countries, summaryDetail));
}
public SummaryViewModel(IEnumerable <MovieDto> movies, SummaryDetailDto summaryDetail)
{
// ger alla värden till våra properties
if (summaryDetail != null)
{
Title = summaryDetail.Title;
Director = summaryDetail.Director;
Plot = summaryDetail.Plot;
}
// gör om countryDto till en lista av countries
this.movies = movies
.Select(c => new Movie
{
Name = c.Movie
})
.OrderBy(x => x.Name)
.ToList();
}
public SummaryViewModel(IEnumerable <CountryDto> countries, SummaryDetailDto summaryDetail)
{
// ger alla värden till våra properties
if (summaryDetail != null)
{
NewConfirmed = summaryDetail.NewConfirmed;
TotalConfirmed = summaryDetail.TotalConfirmed;
TotalDeaths = summaryDetail.TotalDeaths;
Date = summaryDetail.Date;
}
// gör om countryDto till en lista av countries
this.countries = countries
.Select(c => new Country
{
Name = c.Country
})
.OrderBy(x => x.Name)
.ToList();
}
public async Task <JsonResult> getsummary([FromBody] SearchCondition scon)
{
//0. connect to shop db
await setConnectionString(scon.ShopId); //set connection string for shop DB
//1. create dto
SummaryDto dto = new SummaryDto();
//2. call helper method to get data set
SummaryDetailDto select_detail = await GetSummaryHelper(scon.ShopId, scon.DateFrom, scon.DateTo);
SummaryDetailDto compare_detail = await GetSummaryHelper(scon.ShopId, scon.Compare_DateFrom, scon.Compare_DateTo);
//3. mapping values
dto.ShopId = scon.ShopId;
dto.Summary_Items = new List <SummaryItem>();
dto.Summary_Items.Add(new SummaryItem
{
Name = "Total Sales",
Compare_Value = compare_detail.Total_Sales,
Value = select_detail.Total_Sales
});
dto.Summary_Items.Add(new SummaryItem
{
Name = "Number Of Transactions",
Compare_Value = compare_detail.Number_Of_Transactions,
Value = select_detail.Number_Of_Transactions
});
dto.Summary_Items.Add(new SummaryItem
{
Name = "Total Refund",
Compare_Value = compare_detail.Total_Refund,
Value = select_detail.Total_Refund
});
dto.Summary_Items.Add(new SummaryItem
{
Name = "Total Discount",
Compare_Value = compare_detail.Total_Discount,
Value = select_detail.Total_Discount
});
dto.Summary_Items.Add(new SummaryItem
{
Name = "Avg. Sales Value",
Compare_Value = compare_detail.Avg_Sales_Value,
Value = select_detail.Avg_Sales_Value
});
dto.Summary_Items.Add(new SummaryItem
{
Name = "Avg. Item Per Sale",
Compare_Value = compare_detail.Avg_Item_Per_Sale,
Value = select_detail.Avg_Item_Per_Sale
});
dto.Hourly_Summary = new HourlySummary
{
Name = "Sales by Hour",
Compare_Value = compare_detail.Hourly_Sales,
Value = select_detail.Hourly_Sales
};
dto.Payment_Summary = new PaymentSummary
{
Name = "Payment Summary",
Compare_Value = compare_detail.PaymentSum,
Value = select_detail.PaymentSum
};
dto.Custom_Data_Group = new CustomDataGroup
{
Name = "Custom Data Group",
Compare_Value = compare_detail.CustomDataSum,
Value = select_detail.CustomDataSum
};
//return dto
return(Json(dto));
}
private async Task <SummaryDetailDto> GetSummaryHelper(int shopId, DateTime DateFrom, DateTime DateTo)
{
//0. connect to shop db
var _docketDataService = new ShopDataService <Docket>();
var _returnDataService = new ShopDataService <Return>();
var _returnsLineDataService = new ShopDataService <ReturnsLine>();
var _docketLineDataService = new ShopDataService <DocketLine>();
var _paymentDataService = new ShopDataService <Payments>();
var _stockDataService = new ShopDataService <Stock>();
//1. create dto
SummaryDetailDto dto = new SummaryDetailDto();
//2. fetch values from DB
IEnumerable <Docket> dockets = await _docketDataService.Query(d => d.docket_date >= DateFrom && d.docket_date <= DateTo);
IEnumerable <int> docket_ids = dockets.Select(d => d.docket_id).ToList();
IEnumerable <Return> returns = await _returnDataService.Query(d => d.returns_date >= DateFrom && d.returns_date <= DateTo);
IEnumerable <int> returns_ids = returns.Select(r => r.returns_id).ToList();
IEnumerable <ReturnsLine> returnslines = await _returnsLineDataService.Query(rl => returns_ids.Contains(rl.returns_id));
IEnumerable <DocketLine> docketLines = await _docketLineDataService.Query(dl => docket_ids.Contains(dl.docket_id));
#region - calculate Avg_Item_Per_Sale
/** calculate Avg_Item_Per_Sale */
List <double> sum_sales_by_quantity = new List <double>(); //mean: save the total quantity for every sales
foreach (var temp_id in docket_ids)
{
double sum_dl = 0;
foreach (var dl in docketLines)
{
if (temp_id == dl.docket_id)
{
sum_dl += dl.quantity;
}
}
sum_sales_by_quantity.Add(sum_dl);
}
//will be called in value mapping of dto.Avg_Item_Per_Sale
#endregion
#region - get payment data
IEnumerable <Payments> payments = await _paymentDataService.Query(p => p.docket_date >= DateFrom && p.docket_date <= DateTo);
List <PaymentDetail> paymentDetails = new List <PaymentDetail>();
foreach (var item in payments.GroupBy(p => p.paymenttype))
{
PaymentDetail pd = new PaymentDetail();
pd.paymenttype = item.Select(i => i.paymenttype).First();
pd.amount = item.Sum(i => i.amount);
paymentDetails.Add(pd);
}
#endregion
#region - create hourly summary
double[] arr_hour_sale = new double[24];
for (int i = 1; i < 25; i++)
{
arr_hour_sale[i - 1] = (double)dockets.Where(d => d.docket_date.Hour > i - 1 && d.docket_date.Hour <= i).Sum(d => d.total_inc);
}
#endregion
#region -custom data group
var custom1_db = await _stockDataService.GetSingle(s => s.custom1 != null);
var custom2_db = await _stockDataService.GetSingle(s => s.custom2 != null);
CustomDataItem custom1 = new CustomDataItem
{
Name = custom1_db.custom1,
Quantity = 0,
Amount = 0
};
CustomDataItem custom2 = new CustomDataItem
{
Name = custom2_db.custom2,
Quantity = 0,
Amount = 0
};
CustomDataItem others = new CustomDataItem
{
Name = "others",
Quantity = 0,
Amount = 0
};
CustomDataItem extra = new CustomDataItem
{
Name = "extra",
Quantity = 0,
Amount = 0
};
foreach (var dl in docketLines)
{
string cat1 = _stockDataService.GetSingleEnity(s => s.stock_id == dl.stock_id).cat1;
if (cat1 != "TASTE" && cat1 != "EXTRA")
{
if (dl.size_level == 1)
{
custom1.Quantity = custom1.Quantity + dl.quantity;
custom1.Amount = Math.Round((custom1.Amount + (double)dl.sell_inc * dl.quantity) * 100) / 100;
}
else if (dl.size_level == 2)
{
custom2.Quantity = custom2.Quantity + dl.quantity;
custom2.Amount = Math.Round((custom2.Amount + (double)dl.sell_inc * dl.quantity) * 100) / 100;
}
else
{
others.Quantity = others.Quantity + dl.quantity;
others.Amount = Math.Round((others.Amount + (double)dl.sell_inc * dl.quantity) * 100) / 100;
}
}
else
{
extra.Quantity = extra.Quantity + dl.quantity;
extra.Amount = Math.Round((extra.Amount + (double)dl.sell_inc * dl.quantity) * 100) / 100;
}
}
List <CustomDataItem> customer_data_sum = new List <CustomDataItem>();
customer_data_sum.Add(custom1);
customer_data_sum.Add(custom2);
customer_data_sum.Add(others);
customer_data_sum.Add(extra);
#endregion
dto.Total_Sales = (double)dockets.Sum(d => d.total_inc);
dto.Number_Of_Transactions = dockets.Count();
dto.Total_Refund = (double)returns.Sum(r => r.total_inc);
dto.Total_Discount = (double)dockets.Sum(d => d.discount);
if (dto.Number_Of_Transactions == 0)
{
dto.Avg_Sales_Value = 0;
}
else
{
dto.Avg_Sales_Value = Math.Round(dto.Total_Sales / dto.Number_Of_Transactions, 2);
}
dto.Avg_Item_Per_Sale = (sum_sales_by_quantity.Count() > 0)?Math.Round(sum_sales_by_quantity.Average(), 2):0;
dto.Hourly_Sales = arr_hour_sale;
dto.PaymentSum = paymentDetails;
dto.CustomDataSum = customer_data_sum;
//return dto
return(dto);
}
