public void OnGetOther(CalcData c)
{
Data = new CalcData()
{
A = 44, B = 66
};
}
public void OnGetForced(int a, int b)
{
Data = new CalcData()
{
A = a, B = b
};
}
private CalcData GetCalcData()
{
CalcData data = new CalcData((long)videoStream.NumberOfFrames, videoStream.Framerate, (ContainerType)container.SelectedItem,
videoStream.Settings.Codec, videoStream.Settings.NbBframes > 0, getAudioStreamsForBitrate());
return(data);
}
public ActionResult Calc(InputCalcData data)
{
double?result = null;
switch (data.Op)
{
case "+": result = data.Num1 + data.Num2; break;
case "-": result = data.Num1 - data.Num2; break;
case "*": result = data.Num1 * data.Num2; break;
case "/": result = (double)data.Num1 / data.Num2; break;
}
CalcData model = null;
if (result != null)
{
model = new CalcData
{
Num1 = data.Num1, Num2 = data.Num2,
Op = data.Op,
Result = result.Value
}
}
;
return(View("Calc", model));
}
}
public void SetCalcData(CalcData data)
{
if (calcData == null)
{
calcData = new CalcData();
}
calcData = data;
}
/// <summary>
/// postprocesses an audio job followed by a video job
/// this constellation happens in automated or one click encoding where we have an audio job linked
/// to a video job
/// first, any audio jobs previous to the audio job in question will be located
/// then we get the size of all audio tracks
/// from the desired final output size stored in the first video job, we calculate the video bitrate
/// we have to use to obtain the final file size, taking container overhead into account
/// the calculated bitrate is then applied to all video jobs
/// </summary>
/// <param name="firstAudio">the audio job that is linked to a video job</param>
/// <param name="firstpass">the video job to which the audio job is linked</param>
public static LogItem calculateBitrate(MainForm mainForm, Job ajob)
{
if (!(ajob is VideoJob))
{
return(null);
}
VideoJob job = (VideoJob)ajob;
if (job.BitrateCalculationInfo == null)
{
return(null);
}
BitrateCalculationInfo b = job.BitrateCalculationInfo;
LogItem log = new LogItem("Bitrate calculation for video");
List <AudioBitrateCalculationStream> audioStreams = new List <AudioBitrateCalculationStream>();
foreach (string s in b.AudioFiles)
{
audioStreams.Add(new AudioBitrateCalculationStream(s));
}
double framerate;
ulong framecount;
JobUtil.getInputProperties(out framecount, out framerate, job.Input);
CalcData data = new CalcData((long)framecount, (decimal)framerate, b.Container, job.Settings.Codec,
job.Settings.NbBframes > 0, audioStreams.ToArray());
data.TotalSize = b.DesiredSize;
try
{
data.CalcByTotalSize();
}
catch (Exception e)
{
log.LogValue("Calculation failed", e, ImageType.Error);
return(log);
}
log.LogValue("Desired size after subtracting audio", Math.Floor(data.VideoSize.KBExact) + " KBs");
log.LogValue("Calculated desired bitrate", (int)data.VideoBitrate + " kbit/s");
foreach (TaggedJob t in b.VideoJobs)
{
if (t.Job is VideoJob)
{
((VideoJob)t.Job).Settings.BitrateQuantizer = (int)data.VideoBitrate;
}
}
return(log);
}
public string GetCalculaJuros(CalcData _calcData)
{
try
{
return(_calc.GetCalculaJuros(_calcData));
}
catch (Exception ex)
{
throw new ArgumentException("Ocorreu um erro no serviço GetCalculaJuros: " + ex.Message);
}
}
private void HandleOnesRatings(ref CalcData retVal)
{
var copy = new List <int>(retVal.Ratings);
var newValues = new List <int>();
foreach (var val in copy)
{
newValues.Add(ConvertValue(val));
}
retVal.Ratings = newValues;
}
public void GetCalculaJuros()
{
CalcController controller = new CalcController();
CalcData _data = new CalcData();
_data.initialValue = 100;
_data.time = 5;
string result = controller.GetCalculaJuros(_data);
Assert.AreEqual("105,10", result);
}
public string GetCalculaJuros(CalcData _calcData)
{
try
{
string result = string.Empty;
result = (_calcData.initialValue * Math.Pow(interest + 1, _calcData.time)).ToString("n2");
return(result);
}
catch (Exception ex)
{
throw new ArgumentException("Ocorreu um erro no serviço GetCalculaJuros: " + ex.Message);
}
}
public JsonResult Run()
{
var randomDir = Guid.NewGuid().ToString();
Session["WakeSimDir"] = randomDir;
var modelGeneral = GetModelGeneral();
var modelTurbines = GetModelTurbines();
string dir = WebConfigurationManager.AppSettings["WakeSimulationDir"];
dir = Path.Combine(dir, randomDir); // root temp dir
Directory.CreateDirectory(dir);
var resultDir = Path.Combine(dir, "output");
Directory.CreateDirectory(resultDir);
var calcData = new CalcData();
var generalData = new GeneralData();
var dataWriter = new DataWriter();
var calc = new WakeCalc();
generalData.GridPointsX = modelGeneral.GridPointsX;
generalData.GridPointsY = modelGeneral.GridPointsY;
generalData.TurbinesAmount = modelTurbines.Turbines.Count;
generalData.RotationAngle = (double)modelGeneral.RotationAngle;
generalData.x_turb = new double[modelTurbines.Turbines.Count];
generalData.y_turb = new double[modelTurbines.Turbines.Count];
for (var i = 0; i < modelTurbines.Turbines.Count; i++)
{
var t = modelTurbines.Turbines[i];
generalData.x_turb[i] = (double)t.X;
generalData.y_turb[i] = (double)t.Y;
}
generalData.TurbineDiameter = (double)modelGeneral.TurbineDiameter;
generalData.TurbineHeight = (double)modelGeneral.TurbineHeight;
generalData.TurbineThrust = (double)modelGeneral.TurbineThrust;
generalData.WakeDecay = (double)modelGeneral.WakeDecay;
generalData.VelocityAtHub = (double)modelGeneral.VelocityAtHub;
generalData.AirDensity = (double)modelGeneral.AirDensity;
generalData.PowerDistance = (double)modelGeneral.PowerDistance;
calc.Initialize(generalData, calcData);
calc.Run(generalData, calcData);
dataWriter.Write(generalData, calcData, resultDir);
dataWriter.WritePower(generalData, calcData, resultDir);
SharpZipUtils.CompressFolder(resultDir, Path.Combine(dir, "output.zip"), null);
return(Json("OK", JsonRequestBehavior.AllowGet));
}
private static int Calc(CalcData data)
{
switch (data.Op)
{
case "+":
return(data.Arg1 + data.Arg2);
case "^":
return(data.Arg1 ^ data.Arg2);
default:
throw new NotSupportedException($"Operation '{data.Op}' is not supported!");
}
}
/// <summary>
/// sets the size of the output given the desired bitrate
/// </summary>
private void setTargetSize()
{
try
{
CalcData data = GetCalcData();
data.VideoBitrate = Int32.Parse(this.projectedBitrateKBits.Text);
data.CalcByVideoSize();
this.videoSize.Text = data.VideoSize.ToString();
this.targetSize.Value = new FileSize(Unit.MB, data.TotalSize.MBExact);
}
catch (Exception)
{
videoSize.Text = "";
targetSize.Value = null;
}
}
/// <summary>
/// sets the projected video bitrate field in the GUI
/// </summary>
private void setVideoBitrate()
{
try
{
CalcData data = GetCalcData();
data.TotalSize = new FileSize(targetSize.Value.Value.Bytes);
data.CalcByTotalSize();
this.videoSize.Text = data.VideoSize.ToString();
this.projectedBitrateKBits.Text = ((int)data.VideoBitrate).ToString();
}
catch (Exception)
{
this.projectedBitrateKBits.Text = "";
videoSize.Text = "";
}
}
void Visit2(Dictionary<string, CalcData> temp, DirStat dir)
{
foreach (var file in dir.Files)
{
string ext = Path.GetExtension(file.Name);
CalcData data;
if (!temp.TryGetValue(ext, out data))
{
data = new CalcData();
temp.Add(ext, data);
}
data.Bytes += file.Length;
data.FileCount++;
}
foreach (var subDir in dir.Directories)
{
Visit2(temp, subDir);
}
}
public void Advance(List <Node> points, Action <float> updateForcesFunc, float timeStep)
{
PrepareCalcData(points.Count);
Evaluate(points, updateForcesFunc, 0.0f);
for (int i = 0; i < points.Count; i++)
{
m_calcData[i].a = m_calcData[i].evalResult;
}
Evaluate(points, updateForcesFunc, timeStep * 0.5f);
for (int i = 0; i < points.Count; i++)
{
m_calcData[i].b = m_calcData[i].evalResult;
}
Evaluate(points, updateForcesFunc, timeStep * 0.5f);
for (int i = 0; i < points.Count; i++)
{
m_calcData[i].c = m_calcData[i].evalResult;
}
Evaluate(points, updateForcesFunc, timeStep);
for (int i = 0; i < points.Count; i++)
{
m_calcData[i].d = m_calcData[i].evalResult;
}
for (int i = 0; i < points.Count; i++)
{
CalcData p = m_calcData[i];
Vector3 deltaPos = (1.0f / 6.0f) * (p.a.deltaPosition + 2.0f * (p.b.deltaPosition + p.c.deltaPosition) + p.d.deltaPosition);
Vector3 deltaVel = (1.0f / 6.0f) * (p.a.deltaVelocity + 2.0f * (p.b.deltaVelocity + p.c.deltaVelocity) + p.d.deltaVelocity);
points[i].State.Position += deltaPos * timeStep;
points[i].State.Velocity += deltaVel * timeStep;
}
}
private CalcData cleanCalcData(CalcData calcData)
{
calcData.SaleItms = new List <SaleItm>();
calcData.OrderPrizes = new List <OrderPrize>();
calcData.DisAccs = new List <DisAcc>();
calcData.StockGoods = new List <StockGoods>();
//calcData.Customers = new List<Customer>();
calcData.SaleHdrs = new List <SaleHdr>();
calcData.Packages = new List <Package>();
calcData.GoodsMainSubTypes = new List <GoodsMainSubType>();
calcData.CustomerGroups = new List <CustomerGroup>();
calcData.DisSalePrizePackages = new List <DisSalePrizePackage>();
calcData.CustomerMainSubTypes = new List <CustomerMainSubType>();
calcData.Goods = new List <Goods>();
calcData.CPrices = new List <CPrice>();
calcData.Discounts = new List <Discount>();
calcData.EvcPrize = new List <EvcPrize>();
calcData.Prices = new List <Price>();
calcData.EvcPrizePackage = new List <EvcPrizePackage>();
calcData.FreeReasons = new List <FreeReason>();
calcData.DiscountGoodsPackageItems = new List <DiscountGoodsPackageItem>();
return(calcData);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
string ReportName = "ProjektDB.Reports.CalcMain.rdlc";
db = new SteinbachEntities();
host = new WindowsFormsHost();
var Calc = from p in db.kalkulationstabellen
where p.id == CalcID
select p;
var detail = from d in db.kalkulationstabelle_details
where d.id_kalkulationstabelle == CalcID
select d;
var obj = new CalcData(CalcID);
reportViewer = new Microsoft.Reporting.WinForms.ReportViewer();
reportViewer.ProcessingMode = ProcessingMode.Local;
//reportViewer.LocalReport.SubreportProcessing += new SubreportProcessingEventHandler(LocalReport_SubreportProcessing);
reportViewer.LocalReport.ReportEmbeddedResource = ReportName; //"ProjektDB.Reports.Jets_Auftrag_SI.rdlc";
ReportDataSource ds = new ReportDataSource("dsCalkProjekt", Calc);
ReportDataSource dsDetail = new ReportDataSource("dsCalcDetails", detail);
ReportDataSource dsObj = new ReportDataSource("dsObject", obj.Positionen);
reportViewer.LocalReport.DataSources.Add(ds);
reportViewer.LocalReport.DataSources.Add(dsDetail);
reportViewer.LocalReport.DataSources.Add(dsObj);
reportViewer.RefreshReport();
host.Child = reportViewer;
this.GridDisplay.Children.Add(host);
}
public ViewResult Index(CalcData calc)
{
if (ModelState.IsValid)
{
if (calc.TypeCalc)
{
double CreditPercent = calc.CreditPercent / 100 / 12;
calc.MonPay = calc.CreditCash * (decimal)CreditPercent / (decimal)(1 - 1 / Math.Pow((1 + CreditPercent), calc.CreditTime));
calc.OverPay = calc.MonPay * calc.CreditTime - calc.CreditCash;
calc.FullPay = calc.CreditCash + calc.OverPay;
return(View("Submit", calc));
}
else
{
double CreditPercent = calc.CreditPercent / 100 / 12;
decimal[] mass = new decimal[calc.CreditTime + 1];
for (int p = 1; p <= calc.CreditTime; p++)
{
mass[p] = calc.CreditCash / calc.CreditTime + calc.CreditCash * (calc.CreditTime - p + 1) * (decimal)CreditPercent / calc.CreditTime;
}
calc.MonthlyPay = mass;
decimal o = 0;
foreach (int x in mass)
{
o = o + x;
}
calc.OverPay = o - calc.CreditCash;
calc.FullPay = calc.OverPay + calc.CreditCash;
return(View("Submit_Dif", calc));
}
}
else
{
return(View());
}
}
public override CalcData ValidateAdvanceCondition(CalcData data)
{
return(data);
}
public override CalcData CalcPeriodicDiscount(CalcData data)
{
return(data);
}
public ActionResult CalculateBasePrice(decimal margin, decimal import)
{
decimal test = 0;
test = margin;
try
{
var allPB = db.GetPannebakkers().ToList();
// db.Database.ExecuteSqlCommand("TRUNCATE TABLE [Pannebakker]");
#region update import value
var pbSupplier = db.GetSupplierByAccount("PO21");
pbSupplier.ImportOffSet = Convert.ToDouble(import);
db.UpdateSupplier(pbSupplier);
#endregion
List <ImportModel.Pannebakker> newBatches = new List <ImportModel.Pannebakker>();
foreach (var b in allPB)
{
if (b.BatchId == 5313)
{
var fred = 1;
}
ImportModel.Pannebakker newB = new ImportModel.Pannebakker();
CalcData.Result result = CalcData.CalMarginPrice(b, margin);
decimal price = result.price;
if (price != 0)
{
newB.WholesalePrice = Convert.ToInt32(price);
}
else
{
newB.WholesalePrice = Convert.ToInt32(b.Price);
}
newB.Price = b.Price;
newB.FormSize = b.FormSize;
newB.Location = "PB";
newB.Name = b.Name;
newB.Sku = b.Sku;
newB.WholesalePrice = Convert.ToInt32(price);
newB.FormSizeCode = b.FormSizeCode;
newB.FromDate = b.FromDate;
if (price != b.Price)
{
newB.Comment = "Using Rule " + result.rule + "Price Modified from " + b.Price + " to " + newB.WholesalePrice;
}
if (price == b.Price)
{
newB.Comment = "Using Rule " + result.rule + " Price Not Modified";
}
if (price == 0)
{
newB.Comment = null;
}
newBatches.Add(newB);
}
db.EmptyPB();
db.BulkInsertIntoPB(newBatches);
return(View());
//return RedirectToAction("Index");
}
catch (Exception ex)
{
ViewBag.Error = ex.InnerException.Message;
return(View("shit"));
}
}
private void fillInitData(CalcData calcData)
{
var connection = new SQLiteConnection(new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid(), _db.GetDatabasePath());
calcData.SaleItms = new List <SaleItm>();
foreach (var item in connection.Table <SaleItm>())
{
calcData.SaleItms.Add(item);
}
calcData.OrderPrizes = new List <OrderPrize>();
foreach (var item in connection.Table <OrderPrize>())
{
calcData.OrderPrizes.Add(item);
}
calcData.DisAccs = new List <DisAcc>();
foreach (var item in connection.Table <DisAcc>())
{
calcData.DisAccs.Add(item);
}
calcData.StockGoods = new List <StockGoods>();
foreach (var item in connection.Table <StockGoods>())
{
calcData.StockGoods.Add(item);
}
//calcData.Customers = new List<Customer>();
//foreach (var item in connection.Table<Customer>())
//{
// calcData.Customers.Add(item);
//}
calcData.SaleHdrs = new List <SaleHdr>();
foreach (var item in connection.Table <SaleHdr>())
{
calcData.SaleHdrs.Add(item);
}
calcData.Packages = new List <Package>();
foreach (var item in connection.Table <Package>())
{
calcData.Packages.Add(item);
}
calcData.GoodsMainSubTypes = new List <GoodsMainSubType>();
foreach (var item in connection.Table <GoodsMainSubType>())
{
calcData.GoodsMainSubTypes.Add(item);
}
calcData.CustomerGroups = new List <CustomerGroup>();
foreach (var item in connection.Table <CustomerGroup>())
{
calcData.CustomerGroups.Add(item);
}
calcData.DisSalePrizePackages = new List <DisSalePrizePackage>();
foreach (var item in connection.Table <DisSalePrizePackage>())
{
calcData.DisSalePrizePackages.Add(item);
}
calcData.CustomerMainSubTypes = new List <CustomerMainSubType>();
foreach (var item in connection.Table <CustomerMainSubType>())
{
calcData.CustomerMainSubTypes.Add(item);
}
calcData.GoodsGroups = new List <GoodsGroup>();
foreach (var item in connection.Table <GoodsGroup>())
{
calcData.GoodsGroups.Add(item);
}
calcData.Goods = new List <Goods>();
foreach (var item in connection.Table <Goods>())
{
calcData.Goods.Add(item);
}
calcData.CPrices = new List <CPrice>();
foreach (var item in connection.Table <CPrice>())
{
calcData.CPrices.Add(item);
}
calcData.Discounts = new List <Discount>();
foreach (var item in connection.Table <Discount>())
{
calcData.Discounts.Add(item);
}
calcData.EvcPrize = new List <EvcPrize>();
foreach (var item in connection.Table <EvcPrize>())
{
calcData.EvcPrize.Add(item);
}
calcData.Prices = new List <Price>();
foreach (var item in connection.Table <Price>())
{
calcData.Prices.Add(item);
}
calcData.EvcPrizePackage = new List <EvcPrizePackage>();
foreach (var item in connection.Table <EvcPrizePackage>())
{
calcData.EvcPrizePackage.Add(item);
}
calcData.FreeReasons = new List <FreeReason>();
foreach (var item in connection.Table <FreeReason>())
{
calcData.FreeReasons.Add(item);
}
calcData.DiscountGoodsPackageItems = new List <DiscountGoodsPackageItem>();
foreach (var item in connection.Table <DiscountGoodsPackageItem>())
{
calcData.DiscountGoodsPackageItems.Add(item);
}
}
/// <summary>
/// Calculates by the selected method
/// </summary>
protected void Calculate()
{
if (calculating)
{
return;
}
calculating = true;
try
{
CalcData data = new CalcData((long)nbFrames.Value, fpsChooser.Value ?? 0);
data.FrameSize = new Size((int)width.Value, (int)height.Value);
data.ExtraSize = GetTotalExtraSize();
data.AudioStreams = GetAudioStreams().ToArray();
data.ContainerType = containerFormat.SelectedItem as ContainerType;
data.HasBFrames = bframes.Checked;
data.VideoCodec = SelectedVCodec.VCodec;
data.QualityCoeffient = (float)complexity.Value / 100F;
if (fileSizeRadio.Checked) // get video, bpp, qest
{
data.TotalSize = new FileSize(targetSize.Value.Value.Bytes);
data.CalcByTotalSize();
}
else if (this.bppRadio.Checked) // get video, quest, total
{
data.BitsPerPixel = (float)bpp.Value;
data.CalcByBitsPerPixel();
}
else if (this.qEstRadio.Checked) // get video, bpp, total
{
data.QualityEstimate = (float)qest.Value;
data.CalcByQualityEstimate();
}
else // given video size, get total, bpp, quest
{
data.VideoBitrate = projectedBitrate.Value;
data.CalcByVideoSize();
}
targetSize.Value = new FileSize(Unit.KB, data.TotalSize.KB);
projectedBitrate.Value = data.VideoBitrate;
videoSize.Text = new FileSize(Unit.KB, data.VideoSize.KB).ToString();
bpp.Value = (decimal)data.BitsPerPixel;
qest.Value = (decimal)data.QualityEstimate;
applyButton.Enabled = true;
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
applyButton.Enabled = false;
videoSize.Text = "";
if (fileSizeRadio.Checked)
{
bpp.Value = 0;
qest.Value = 0;
projectedBitrate.Value = 0;
}
else if (this.bppRadio.Checked)
{
qest.Value = 0;
projectedBitrate.Value = 0;
targetSize.Value = null;
}
else if (this.qEstRadio.Checked)
{
bpp.Value = 0;
projectedBitrate.Value = 0;
targetSize.Value = null;
}
else
{
bpp.Value = 0;
qest.Value = 0;
targetSize.Value = null;
}
}
calculating = false;
}
/// <summary>
/// Step 1 Read file and insert into Import Table
/// </summary>
/// <returns></returns>
public ActionResult UpLoad()
{
List <ImportModel.rawImport> recordsIn = new List <ImportModel.rawImport>();
List <ImportModel.Pannebakker> existingRecords = new List <ImportModel.Pannebakker>();
List <ImportModel.rawImport> newRecords = new List <ImportModel.rawImport>();
try
{
recordsIn = ReadInputFile();
// existingRecords = db.GetPannebakkers().ToList();
// newRecords = recordsIn.Union(existingRecords).ToList();
// newRecords = existingRecords.Union(recordsIn, new DTO.PbComparer()).ToList();
}
catch (Exception ex)
{
ViewBag.Error = ex.InnerException.Message;
return(View("version"));
}
try
{
#region import
///// empty the import tables
// db.Database.ExecuteSqlCommand("TRUNCATE TABLE [Pannebakker]");
db.EmptyImport();
/// insert into raw import and remove any duplicates just in case
// db.BulkInsert<Pannebakker>(newRecords);
db.BulkInsertIntoImport(recordsIn);
db.RemoveDuplicateImport();
#endregion import
// merge import into PB and clean form sizes
//AddBatch(records);
db.MergeImportToPB();
db.cleanPBForms();
db.cleanForms();
db.RemoveDuplicatePB();
// so PB table sould now be solid and ready
// remove any duplicates from PB and Batch
// may not be needed but just in case
// db.RemoveDuplicateBatch();
// clean all old PB's from batch as we are going to provide a new lot.
// worried about this moving frowards if quotes use batch ids from PB's i am removing
//db.RemovePBFromBatch();
var allPB = db.GetPannebakkers().ToList();
// db.Database.ExecuteSqlCommand("TRUNCATE TABLE [Pannebakker]");
List <ImportModel.Pannebakker> newBatches = new List <ImportModel.Pannebakker>();
foreach (var b in allPB)
{
ImportModel.Pannebakker newB = new ImportModel.Pannebakker();
CalcData.Result result = CalcData.CalCapPrice(b);
decimal price = result.price;
if (price != 0)
{
newB.WholesalePrice = Convert.ToInt32(price);
}
else
{
newB.WholesalePrice = Convert.ToInt32(b.Price);
}
newB.Price = b.Price;
newB.FormSize = b.FormSize;
newB.Location = "PB";
newB.Name = b.Name;
newB.Sku = b.Sku;
newB.WholesalePrice = Convert.ToInt32(price);
newB.FormSizeCode = b.FormSizeCode;
if (price != b.Price)
{
newB.Comment = "Using Rule " + result.rule + " Price Modified from " + b.Price + " to " + newB.WholesalePrice;
}
if (price == b.Price)
{
newB.Comment = "Price Not Modified";
}
if (price == 0)
{
newB.Comment = null;
}
newBatches.Add(newB);
}
//IEnumerable<ImportModel.Batch> newBatches = allPB.Select(batch => new ImportModel.Batch
//{
// Active = true,
// AllocatedQuantity = 0,
// BuyPrice = CalCapPrice(batch),
// Comment = "",
// FormSize = batch.FormSize,
// ImageExists = false,
// GrowingQuantity = 0,
// Location = "PB",
// Name = batch.Name,
// Sku = batch.Sku,
// Quantity = 5000,
// WholesalePrice = 0,
// DateStamp = DateTime.Now,
//});
db.EmptyPB();
db.BulkInsertIntoPB(newBatches);
db.MergePbToBatch();
ViewBag.Title = "done";
Response.Write("<script>console.log('Data has been saved to db');</script>");
return(View("uploadDone"));
//return RedirectToAction("Index");
}
catch (Exception ex)
{
ViewBag.Error = ex.InnerException.Message;
return(View("shit"));
}
}
public Calculation(CalcData calc)
{
calcData = calc;
}
private async Task <CalcData> GetCalcDataForSegmentAsync(string platform, string username, int season, Playlist playlist, TRNMMRObject obj)
{
CalcData retVal = new CalcData
{
Playlist = playlist,
Season = season
};
DateTime cutOff = DateTime.Now;
DateTime seasonStartDate = new DateTime(2020, 12, 09);
switch (season)
{
case 16:
{
cutOff = cutOffDates[(int)Seasons.S2];
break;
}
case 17:
{
cutOff = cutOffDates[(int)Seasons.S3];
seasonStartDate = cutOffDates[(int)Seasons.S2].AddDays(1);
break;
}
case 18:
{
cutOff = cutOffDates[(int)Seasons.S4];
seasonStartDate = cutOffDates[(int)Seasons.S3].AddDays(1);
break;
}
}
try
{
List <Datum> Datam = new List <Datum>();
var segment = await GetSeasonSegment(season, platform, username);
if (segment == null)
{
retVal.GamesPlayed = 0;
}
else
{
Datam.AddRange(segment.data);
Datam.RemoveAll(x => _acceptablePlaylists.Contains(x.attributes.playlistId) == false);
retVal.GamesPlayed = Datam.Count > 0 ? Datam.Sum(x => x.stats.matchesPlayed.value) : 0;
}
if (playlist == Playlist.ONES)
{
if (obj.data.Duel != null)
{
List <Duel> data = new List <Duel>(obj.data.Duel);
data = data.Where(x => x.collectDate <cutOff& x.collectDate> seasonStartDate).ToList();
retVal.Ratings = data.Select(x => x.rating).ToList();
HandleOnesRatings(ref retVal);
}
}
else if (playlist == Playlist.TWOS)
{
if (obj.data.Duos != null)
{
List <Duo> data = new List <Duo>(obj.data.Duos);
data = data.Where(x => x.collectDate <cutOff && x.collectDate> seasonStartDate).ToList();
retVal.Ratings = data.Select(x => x.rating).ToList();
}
}
else if (playlist == Playlist.THREES)
{
if (obj.data.Standard != null)
{
List <Standard> data = new List <Standard>(obj.data.Standard);
data = data.Where(x => x.collectDate <cutOff && x.collectDate> seasonStartDate).ToList();
retVal.Ratings = data.Select(x => x.rating).ToList();
}
}
if (Datam is null || Datam.Count == 0)
{
retVal.GamesPlayed = 0;
return(retVal);
}
switch (playlist)
{
case Playlist.ONES:
retVal.GamesPlayed = 0;
break;
case Playlist.TWOS:
retVal.GamesPlayed = Datam[0].stats.matchesPlayed.value;
break;
case Playlist.THREES:
retVal.GamesPlayed = Datam[1].stats.matchesPlayed.value;
break;
}
}
catch (Exception ex)
{
_log.Error(ex);
}
return(retVal);
}
