public Output GetOutput()
{
var output = new Output();
output.SumResult = Sums.Sum() * K;
var multiple = 1;
foreach (var mul in Muls)
{
multiple *= mul;
}
output.MulResult = multiple;
var list = new List <decimal>();
list.AddRange(Sums.OrderBy(x => x));
foreach (var mul in Muls.OrderByDescending(x => x))
{
list.Add(Convert.ToDecimal(mul));
}
/*var sorted = list.OrderBy(x => x);
* output.SortedInputs = sorted.ToArray();*/
output.SortedInputs = list.ToArray();
return(output);
}
public Response <Sums> Add([FromBody] AddDto add)
{
return(Extension.Try <Sums>(() =>
{
string TrackingId = null;
string calculations = null;
Sums sum = this.serviceCalculators.Add(add.Addends);
//If a 'TrackingId’ was provided, the server should store this request’s details inside it’s
//journal, indexed by the given Id.
TrackingId = ValidateTrackingId();
if (!string.IsNullOrEmpty(TrackingId))
{
foreach (int num in add.Addends)
{
calculations += num + "+";
}
Operations operation = new Operations()
{
Id = TrackingId,
Operation = "Sum",
Date = DateTime.UtcNow.ToString("s") + "Z",
Calculation = string.Format("{0}", calculations + "=" + sum.Sum).Replace("+=", "=")
};
this.serviceCalculators.SaveJournal(operation);
}
return sum;
}, _logger));
}
public void SumRangeTestStartAtZero()
{
int manualCalculation = _manualCalculateSumRange(0, 100);
int result = Sums.SumRange(0, 100);
Assert.AreEqual(manualCalculation, result);
}
public void SumRangeTestStartAtOne()
{
int manualCalculation = _manualCalculateSumRange(0, 100);
// The sum from 0 to N should equal sum from 1 to N
Assert.AreEqual(manualCalculation, Sums.SumRange(1, 100));
}
public void SumRangeTestStartAtRandom()
{
int manualCalculation = _manualCalculateSumRange(_start, _end);
int result = Sums.SumRange(_start, _end);
Assert.AreEqual(result, manualCalculation);
}
public VismaEntrySumViewModel(Dictionary <int, double> sumEntries)
{
SumEntries = sumEntries;
// Starts by creating two standard textboxes which contains the "ID" text and the "Sum" text at the start of every row of sums.
Ids.Add(new TextBox
{
Text = "Visma ID",
FontWeight = FontWeights.Bold,
Width = 60,
Background = Brushes.WhiteSmoke,
HorizontalContentAlignment = HorizontalAlignment.Center,
IsTabStop = false
});
Sums.Add(new TextBox
{
Text = "Sum",
FontWeight = FontWeights.Bold,
Width = 60,
Background = Brushes.WhiteSmoke,
HorizontalContentAlignment = HorizontalAlignment.Center,
IsTabStop = false
});
// Then it generates the textboxes containing the sum and id pairs based on the dictionary that was sent.
GenerateTextBoxes();
}
public IActionResult Add(Sums sums)
{
try
{
// Methods
IMethods methods = new Methods();
methods.GetAddResults(sums);
// If have tracking-id, save log
_logOperations.SetOperationsLog(Request.Headers["X-Evi-Tracking-Id"], new Operations()
{
Calculation = "Sum", Operation = String.Format(Helpers.OperationString.ConvertArrayInText(sums.Addends, " + "), String.Empty, sums.Total)
});
_logs.SetLogs(DateTime.Now.ToString("dd/MM/yyyy"), JsonConvert.SerializeObject(new { Type = "Success", User = Request.Headers["X-Evi-Tracking-Id"], EntryData = JsonConvert.SerializeObject(sums.Addends), Operation = new Operations()
{
Calculation = "Sum", Operation = String.Format(Helpers.OperationString.ConvertArrayInText(sums.Addends, " + "), String.Empty, sums.Total)
} }));
return(Ok(new { Sum = sums.Total }));
}
catch (Exception ex)
{
Errors error = new Errors
{
ErrorMessage = ex.Message,
ErrorCode = "Internal Server Error",
ErrorStatus = 400
};
_logs.SetLogs(DateTime.Now.ToString("dd/MM/yyyy"), JsonConvert.SerializeObject(new { Type = "Error", User = Request.Headers["X-Evi-Tracking-Id"], EntryData = JsonConvert.SerializeObject(sums.Addends), Operation = error }));
return(BadRequest(error));
}
}
private void GenerateTextBoxes()
{
foreach (KeyValuePair <int, double> entry in SumEntries)
{
#region Create the textbox standard
var idTextbox = new TextBox();
var sumTextbox = new TextBox();
idTextbox.Width = sumTextbox.Width = 60;
idTextbox.HorizontalContentAlignment = sumTextbox.HorizontalContentAlignment = HorizontalAlignment.Center;
idTextbox.Background = Brushes.WhiteSmoke;
sumTextbox.Background = Brushes.WhiteSmoke;
#endregion
// Adds the text to the textboxes.
idTextbox.Text = entry.Key.ToString();
sumTextbox.Text = entry.Value.ToString();
// Makes them not table.
idTextbox.IsTabStop = false;
sumTextbox.IsTabStop = false;
// Make them readonly
idTextbox.IsReadOnly = true;
sumTextbox.IsReadOnly = true;
// Adds them to the collections.
Ids.Add(idTextbox);
Sums.Add(sumTextbox);
}
}
private void AnswerButton_Click(object sender, EventArgs e)
{
Sums test = new Sums();
int res = test.multiplynumbers(5, 2);
answerText.Text = res.ToString();
}
public Output CreateOutput()
{
return(new Output
{
SumResult = Sums.Sum() * K,
MulResult = Muls.Aggregate((a, b) => a * b),
SortedInputs = Sums.Concat(Muls.Select(a => (decimal)a)).OrderBy(x => x).ToArray()
});
}
private static void Add(string clientID)
{
int numberOfElements = QuantityOfNumbers();
Sums sums = new Sums();
sums.Addends = GetListOfElements(numberOfElements).ToArray();
IService _service = new Service();
_service.Add(sums, clientID);
}
/// <summary>
/// Applies the effect by rendering it onto the target bitmap.
/// </summary>
/// <param name="source">The source bitmap.</param>
/// <param name="target">The target bitmap.</param>
public override void DrawImage(Bitmap source, Bitmap target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (source.Size != target.Size)
{
throw new ArgumentException("The source bitmap and the target bitmap must be the same size.");
}
using (var graphics = Graphics.FromImage(target))
{
graphics.PageUnit = GraphicsUnit.Pixel;
for (int x = 0; x < source.Width; x += this.BlockSize)
{
for (int y = 0; y < source.Height; y += this.BlockSize)
{
var sums = new Sums();
for (int xx = 0; xx < this.BlockSize; ++xx)
{
for (int yy = 0; yy < this.BlockSize; ++yy)
{
if (x + xx >= source.Width || y + yy >= source.Height)
{
continue;
}
var color = source.GetPixel(x + xx, y + yy);
sums.A += color.A;
sums.R += color.R;
sums.G += color.G;
sums.B += color.B;
sums.T++;
}
}
var average = Color.FromArgb(
sums.A / sums.T,
sums.R / sums.T,
sums.G / sums.T,
sums.B / sums.T);
using (var brush = new SolidBrush(average))
{
graphics.FillRectangle(brush, x, y, (x + this.BlockSize), (y + this.BlockSize));
}
}
}
}
}
public Output DoOutPut()
{
var output = new Output
{
SumResult = Sums.Sum() * K,
MulResult = Muls.Aggregate((item, current) => item * current),
SortedInputs = Sums
.Concat(Muls.Select(x => (decimal)x))
.OrderBy(x => x)
.ToArray()
};
return(output);
}
public Graph(int[][] accessMatrix, double[][] costMatrix)
{
AccessMatrix = accessMatrix.Select(m => m.ToList()).ToList();
CostMatrix = costMatrix.Select(m => m.ToList()).ToList();
Vertices = AccessMatrix.Count;
Ways = GetWays();
Sums = GetSums(Ways);
IndexCrit = Sums.FindIndex(s => s == Sums.Max());
Crit = Sums.Max();
Budgets = Sums.ToList();
var max = Sums.Max();
Budgets = Budgets.Select(b => max - b).ToList();
}
/// <summary>
/// This method serves UC-CALC-ADD external interface
/// </summary>
/// <param name="Addends">the input of the arithmetic operation.</param>
/// <returns>the arithmetic operation result</returns>
public Sums Add(List <int> Addends)
{
Sums sum = new Sums();
try
{
sum.Sum = Addends.Sum();
}
catch (Exception ex)
{
throw new DataException("Error dao Add.", ex);
}
return(sum);
}
public void Add(Sums what)
{
if (!fact.EqualTo(what.fact))
{
System.Diagnostics.Debug.Assert(false, "PartialSums.Sums.Add: instances of PartialSums.Factory must be equal");
}
var a = this.items;
var b = what.items;
for (int i = fact.itemsCount - 1; i >= 0; i--)
{
a[i].SumValues += b[i].SumValues;
a[i].SumWeights += b[i].SumWeights;
}
}
public void AddResultsTest(object[] values, string expected)
{
try
{
string[] arrayString = Array.ConvertAll <object, string>(values, CalculatorService.Server.Helpers.Objects.ConvertObjectToString);
Sums sums = new Sums
{
Addends = arrayString
};
new CalculatorService.Server.Objects.Methods().GetAddResults(sums);
Assert.AreEqual(Convert.ToDouble(expected), sums.Total);
}
catch (Exception ex)
{
Assert.AreEqual(expected, ex.Message);
}
}
public void GetAddResults(Sums sums)
{
try
{
// Check if the values are numbers
var allNumbers = CalculatorService.Server.Helpers.Numbers.AllNumbers(sums.Addends);
if (allNumbers)
{
var valuesToOperate = CalculatorService.Server.Helpers.Numbers.ConvertStringArrayToDoubleArray(sums.Addends);
var result = valuesToOperate.Sum(x => x);
sums.Total = result;
}
else
{
throw new Exception("Some of the elements are not numerics");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Activator(Menu attachToMenu)
{
AMenu = attachToMenu;
AMenu = MainMenu.AddMenu("Aka´s Activator", "AkasActivator");
AMenu.Add("Combo", new CheckBox("Use Items in Combo"));
AMenu.Add("Harass", new CheckBox("Use Items in Harass"));
AMenu.Add("LaneClear", new CheckBox("Use Items in LaneClear"));
AMenu.Add("JungleClear", new CheckBox("Use Items in JungleClear"));
AMenu.Add("Flee", new CheckBox("Use Items in Flee"));
Offensive = AMenu.AddSubMenu("Offensive", "Offensive");
Offensive.AddGroupLabel("Offensive Items");
Offensive.AddLabel("Blade Of The Ruined King");
Offensive.Add("botrkManager", new CheckBox("Blade Of The Ruined King"));
Offensive.Add("botrkManagerMinMeHP", new Slider("Self HP %", 80));
Offensive.Add("botrkManagerMinEnemyHP", new Slider("Enemy HP HP %", 80));
Offensive.AddLabel("Cutlass");
Offensive.Add("cutlassManager", new CheckBox("Cutlass"));
Offensive.Add("cutlassManagerMinMeHP", new Slider("Self HP %", 80));
Offensive.Add("cutlassManagerMinEnemyHP", new Slider("Enemy HP HP %", 80));
if (Player.Instance.IsMelee)
{
Offensive.AddLabel("Tiamat");
Offensive.Add("tiamatManager", new CheckBox("Use Tiamat"));
Offensive.Add("tiamatManagerMinMeHP", new Slider("Self HP %", 99));
Offensive.Add("tiamatManagerMinEnemyHP", new Slider("Enemy HP HP %", 99));
Offensive.AddLabel("Hydra");
Offensive.Add("hydraManager", new CheckBox("Use Hydra"));
Offensive.Add("hydraManagerMinMeHP", new Slider("Self HP %", 99));
Offensive.Add("hydraManagerMinEnemyHP", new Slider("Enemy HP HP %", 99));
}
Offensive.AddLabel("Gunblade");
Offensive.Add("gunbladeManager", new CheckBox("Use Gunblade"));
Offensive.Add("gunbladeManagerMinMeHP", new Slider("Self HP %", 99));
Offensive.Add("gunbladeManagerMinEnemyHP", new Slider("Enemy HP HP %", 99));
Offensive.AddLabel("GhostBlade");
Offensive.Add("ghostbladeManager", new CheckBox("Use GhostBlade"));
Offensive.Add("ghostbladeManagerMinMeHP", new Slider("Self HP %", 99));
Offensive.Add("ghostbladeManagerMinEnemyHP", new Slider("Enemy HP HP %", 99));
Potions = AMenu.AddSubMenu("Potions", "potions");
Potions.AddGroupLabel("Potion Items");
Potions.Add("healthPotionManager", new CheckBox("Health Potion"));
Potions.Add("healthPotionManagerMinMeHP", new Slider("Min HP %", 65));
Potions.AddSeparator();
Potions.Add("biscuitPotionManager", new CheckBox("Biscuit"));
Potions.Add("biscuitPotionManagerMinMeHP", new Slider("Min HP %", 65));
Potions.AddSeparator();
Potions.Add("refillPotManager", new CheckBox("Refill Potion"));
Potions.Add("refillPotManagerMinMeHP", new Slider("Min HP %", 60));
Potions.AddSeparator();
Potions.Add("corruptpotManager", new CheckBox("Corrupt Potion"));
Potions.Add("corruptpotManagerMinMeHP", new Slider("Min HP %", 60));
Potions.Add("corruptpotManagerMinMeMana", new Slider("Min Mana %", 30));
Potions.AddSeparator();
Potions.Add("huntersPotManager", new CheckBox("Hunter's Potion"));
Potions.Add("huntersPotManagerMinMeHP", new Slider("Min HP %", 60));
Potions.Add("huntersPotManagerMinMeMana", new Slider("Min Mana %", 30));
Qss = AMenu.AddSubMenu("Qss", "qss");
Qss.AddGroupLabel("Qss Settings");
Qss.Add("Polymorph", new CheckBox("Polymorph"));
Qss.Add("Stun", new CheckBox("Stun"));
Qss.Add("Taunt", new CheckBox("Taunt"));
Qss.Add("Knockup", new CheckBox("Knock-up"));
Qss.Add("Fear", new CheckBox("Fear"));
Qss.Add("Snare", new CheckBox("Snare"));
Qss.Add("Slow", new CheckBox("Slow"));
Qss.Add("Blind", new CheckBox("Blind"));
Qss.Add("Silence", new CheckBox("Silence"));
Qss.Add("Charm", new CheckBox("Charm"));
Qss.Add("Suppression", new CheckBox("Suppression"));
Qss.Add("delay", new Slider("Activation Delay", 1000, 0, 2000));
Qss.AddSeparator();
Qss.AddLabel("Cleanse Items / Summoner Spell");
Qss.Add("mikaelsCleanser", new CheckBox("Mikael's Cruicble"));
Qss.Add("mercurialScimitarCleanser", new CheckBox("Mercurial Scimitar"));
Qss.Add("quicksilverSashCleanser", new CheckBox("Quicksilver Sash"));
Qss.Add("summonerSpellCleanse", new CheckBox("Summoner Cleanse"));
Defensive = AMenu.AddSubMenu("Defensive Items", "defmenuactiv");
Defensive.AddGroupLabel("Shield/Heal Items (self)");
Defensive.Add("Archangels_Staff", new CheckBox("Serahph's Embrace"));
Defensive.AddGroupLabel("Shield/Heal Items (ally/self)");
Defensive.Add("Mikaels_Crucible_Heal", new CheckBox("Mikaels Crucible"));
Defensive.AddLabel("Locket of the Iron Solari");
Defensive.Add("Locket_of_the_Iron_Solari", new CheckBox("Locket of the Iron Solari"));
Defensive.AddSeparator(0);
Defensive.Add("Locket_of_the_Iron_Solari_ally", new CheckBox("Ally"));
Defensive.Add("Locket_of_the_Iron_Solari_self", new CheckBox("Self"));
Defensive.AddLabel("Face of the Mountain");
Defensive.Add("Face_of_the_Mountain", new CheckBox("Face of the Mountain"));
Defensive.AddSeparator(0);
Defensive.Add("Face_of_the_Mountain_ally", new CheckBox("Ally"));
Defensive.Add("Face_of_the_Mountain_self", new CheckBox("Self"));
Sums = AMenu.AddSubMenu("Summoners", "sums");
Sums.AddLabel("Heal");
Sums.Add("healManager", new CheckBox("Use Heal"));
Sums.Add("healManagerMinMeHP", new Slider("Self HP %", 30));
Sums.Add("healManagerMinEnemyHP", new Slider("Enemy HP HP %", 30));
Sums.AddLabel("Ignite");
Sums.Add("igniteManager", new CheckBox("Use Ignite"));
Sums.AddLabel("Barrier");
Sums.Add("barrierManager", new CheckBox("Use Barrier"));
Sums.Add("barrierManagerMinMeHP", new Slider("Self HP %", 30));
Sums.Add("barrierManagerMinEnemyHP", new Slider("Enemy HP HP %", 30));
SmiteMenu = AMenu.AddSubMenu("Smite Settings");
SmiteMenu.AddGroupLabel("Camps");
SmiteMenu.AddLabel("Epics");
SmiteMenu.Add("SRU_Baron", new CheckBox("Baron"));
SmiteMenu.Add("SRU_Dragon", new CheckBox("Dragon"));
SmiteMenu.AddLabel("Buffs");
SmiteMenu.Add("SRU_Blue", new CheckBox("Blue"));
SmiteMenu.Add("SRU_Red", new CheckBox("Red"));
SmiteMenu.AddLabel("Small Camps");
SmiteMenu.Add("SRU_Gromp", new CheckBox("Gromp", false));
SmiteMenu.Add("SRU_Murkwolf", new CheckBox("Murkwolf", false));
SmiteMenu.Add("SRU_Krug", new CheckBox("Krug", false));
SmiteMenu.Add("SRU_Razorbeak", new CheckBox("Razerbeak", false));
SmiteMenu.Add("Sru_Crab", new CheckBox("Skuttles", false));
SmiteMenu.AddSeparator();
SmiteMenu.Add("smiteActive",
new KeyBind("Smite Active (toggle)", true, KeyBind.BindTypes.PressToggle, 'M'));
SmiteMenu.AddSeparator();
SmiteMenu.Add("useSlowSmite", new CheckBox("KS with Slow Smite"));
SmiteMenu.Add("comboWithDuelSmite", new CheckBox("Combo With Duel Smite"));
Smite = new Spell.Targeted(ObjectManager.Player.GetSpellSlotFromName("summonersmite"), 500);
Game.OnUpdate += GameOnOnUpdate;
Obj_AI_Base.OnBuffGain += Obj_AI_Base_OnBuffGain;
}
public void SumRangeOddTestStartAtOne()
{
int manualCalculation = _manualCalculateSumRangeOdd(0, 100);
Assert.AreEqual(manualCalculation, Sums.SumRangeOdd(1, 100));
}
public void Add(Sums sums, string clientID)
{
GetHttpResponse(clientID, sums, "api/calculator/add");
}
public void SumRangeTestNegativeRange()
{
Assert.AreEqual(0, Sums.SumRange(10, 9));
}
public void SumDigitsFromStringTest()
{
Assert.AreEqual(8, Sums.sumDigits("1232"));
Assert.AreEqual(0, Sums.sumDigits("0"));
Assert.AreEqual(0, Sums.sumDigits(""));
}
public void EvalReportInfo(ReportName reportName, ScaffoldContext context, ReportDates reportDates,
int currShiftIndex=-1,
int export_excel = 0,
string selectedSortOfProduction=null,
string[] baseStrings=null,//хранится выгрузки в base64 рисунки графиков
Controller curr_controller = null
)
{
//В некоторых случаях, вроде экспорта в эксель, можно использовать уже вычисленные данные
if (
#region IsNeedCachedDateForReport
(this.Successfull
&&(export_excel==1
&&!ReportListForRebuildForExcel.Contains(reportName.Eng))//Некоторые отчёты требуют не округлённые данные для экселя, так что формируем их заново
|| shiftsReportNames.Contains(reportName.Eng))//Или для смен
&& this.ReportName != null
&& reportName.Eng == this.ReportName.Eng
&& this.ReportDates.StartDate == reportDates.StartDate
&& this.ReportDates.EndDate == reportDates.EndDate
#endregion
)
{
//Данные по сменам формируются из списка смен в периоде, но выводится только одна, так что обновляем эти данные
if (shiftsReportNames.Contains(reportName.Eng))
{
this.CurrShiftIndex = currShiftIndex;
ReportDates.RecalcShiftsDate(this);//Пересчитываем края текущей смены
}
if (baseStrings != null)
{
this.BaseStrings = baseStrings;
}
this.SelectedSortOfProduction = selectedSortOfProduction;
return;
}
#region init var
this.Successfull = false;
this.stopwatch.Restart();
this.CurrShiftIndex = currShiftIndex;
this.ReportDates = reportDates;
this.SelectedSortOfProduction = selectedSortOfProduction;
this.BaseStrings = baseStrings;
this.ReportName = reportName;
this.Dbcontext = context;
this.Curr_controller = curr_controller;
this.IsByDay = IsByDay_report_list.Contains(reportName.Eng);
isBDM1 = BDM1_reports_list.Contains(reportName.Eng);
this.PlaceName = isBDM1 ? "БДМ-1" : "БДМ-2";
placeId = isBDM1 ? 1:2;
this.roundNum = 3;
this.Sums = new Dictionary<string, double[]>();
this.Records_List = new Dictionary<string, List<object>>();
this.Records = new List<object>();
#endregion
switch (reportName.Eng)//на основе названия отчёта дополнительные операции над записями
{
case "ConsumptionByCycleByBDM1"://БДМ-1 по видам продукции
case "ConsumptionByCycleByBDM2"://БДМ-2 по видам продукции
case "ConsumptionByBDM1ByDay"://БДМ-1(Суточный)
case "ConsumptionByBDM2ByDay"://БДМ-2(Суточный)
//делаем итого для нужных категорий
//double[] sums = StaticMethods.Generate_sums(RecordsToShow_ConsumptionByCycleByBDM);
Records = Form_records<ConsumptionByCycleOfProduction>("ConsumptionByCycle").Select(r=>(object)r).ToList();
var t_sum = Sums_CycleOfProduction(Records.Select(r => (ISums_CycleOfProduction)r).ToList());
if (t_sum!=null)
{
Sums.Add("ConsumptionByCycleByBDM", t_sum);
}
break;
case "TERperMonthperTonne"://Средневзвешенное ТЭР на тонну по циклам производства
//В данном отчете ограничение по датам используется для ограничения SKU по которым выводить годовой отчет, год передается отдельно
Records_List = new Dictionary<string, List<object>>();
Records_List.Add("TERperMonthperTonne",Form_records<TERperMonthperTonne>("TERperMonthperTonne").Select(r => (object)r).ToList());
Records_List.Add("TERperCycleperTonne", Form_records<TERperCycleperTonne>("TERperCycleperTonne").Select(r => (object)r).ToList());
Records_List.Add("TER_Plan", Form_records<TERperMonthperTonne>("TER_Plan").Select(r => (object)r).ToList());
break;
case "EnergyConsumptionByManufactureByHour"://Часовой расход электроэнергии по производству
#region case "EnergyConsumptionByManufactureByHour"
//Задача для каждого поля для указного для подсчёта, посчитать данные в разрезе списка индификаторов в Constants.places
//Довольно интересный алгоритм, позволяющий делать группировку по динамическому Id закреплённому за местами Constants.places
// причем за одно место может быть закреленно несколько ID
//Получаем в результате массив double, где индекс массива это индекс места в Constants.places
// А сам массив содержит информацию в разрезе часа, по всем местам.
var precompute_data = Form_records<EnergyConsumptionByManufactureByHour>();
if (precompute_data == null || precompute_data.Count == 0)
{
break;
}
//Собираем id по которым будем считать итоговую сумму по производству(колонка итого:)
List<int> total_sums_place_ids_EnergyConsumptionByManufactureByHour = new List<int>();
Constants.places_total.Values.ToList()
.ForEach(r =>
{ total_sums_place_ids_EnergyConsumptionByManufactureByHour.AddRange(r); }
);
////строка итого, храним Dictionary<string, double> для поддержки и других видов ТЭР, газа, пара и т.д.
//List<Dictionary<string, double>> sums_EnergyConsumptionByManufactureByHour = new List<Dictionary<string, double>>();
//подсчитываем данные по местам
//var data_EnergyConsumptionByManufactureByHour; //= new Dictionary<string, List<double>>();
var field_name_EnergyConsumptionByManufactureByHour = "EnergyConsumption";
Records= precompute_data
.Select(r => ((IHaveMeasureDate)r).Measure_Date)
.Distinct()
.Select(Measure_Date => {
var values = SumField_byPlaceId(field_name_EnergyConsumptionByManufactureByHour, precompute_data.Where(r => ((IHaveMeasureDate)r).Measure_Date == Measure_Date).Select(r=>(EnergyConsumptionByManufactureByHour)r) .ToList(), roundNum, total_sums_place_ids_EnergyConsumptionByManufactureByHour);
return new Data_EnergyConsumptionByManufactureByHour
{
Date = Measure_Date.ToShortDateString(),
Time = Measure_Date.ToShortTimeString(),
Values = values//массив из double с показаниями за текущий слайс на время и дату
};
}).ToList<object>();
//Добавляем строковые итоги
//Нужно пробежатся по срезам по часам и посчитать итоговые данные по каждому месту
//напомню что индекс в массиве data это индекс места массиве Constants.places_total
var sums_row_EnergyConsumptionByManufactureByHour = new double[places.Count + 1];//разменость +1 потому что ещё считаем последную колонку итого
var param_values = typeof(Data_EnergyConsumptionByManufactureByHour).GetProperty("Values");
foreach (var data in Records)
{
var curr_data = (List<double>)param_values.GetValue(data);
for (int i = 0; i < curr_data.Count; i++)
{
sums_row_EnergyConsumptionByManufactureByHour[i] += curr_data[i];
}
}
Sums.Add("row_EnergyConsumptionByManufactureByHour", sums_row_EnergyConsumptionByManufactureByHour);
break;
#endregion
case "EnergyConsumptionByDevicesByDay"://Суточный расход электроэнергии по учётам
case "EnergyConsumptionByDevicesByHour"://Часовой расход электроэнергии по учётам
#region EnergyConsumptionByDevicesBy
Stopwatch tempWatch = new Stopwatch();
tempWatch.Start();
//отличия только в группировках между этими отчетами, так что формируем признак
//EnergyConsumptionByDevices
//Собираем записи для формирования вывода
//Т.к список устройств динамический, то под него нельзя создать класс, так что делаем группировки по ходу
Records = Form_records<EnergyConsumptionByDevices>("EnergyConsumptionByDevicesByDay").Select(r => (object)r).ToList();
tempWatch.Stop();
//Для строки Итого:
Sums.Add("EnergyConsumptionByDevices",
Records
.Select(r=>(EnergyConsumptionByDevices)r)
.GroupBy(r => r.Device_Name,
(g, r) => Math.Round(r.Sum(e => e.EnergyConsumption ?? 0), 3))
.Append(0)
.ToArray());
//Для колонки Итого по производству:
Sums.Add("EnergyConsumptionByDevices_col_production",
Records
.Select(r => (EnergyConsumptionByDevices)r)
.Where(r => Constants.EnergyConsumptionByDevices_total_devices.ContainsKey(r.Device_Name))//итого для строк считаем только для определенных колонок
.GroupBy(r => r.Measure_Date, (g, rs) => rs.Sum(r => r.EnergyConsumption) ?? 0).ToArray());
//Добавляем сумму по производству
Sums["EnergyConsumptionByDevices"][Sums["EnergyConsumptionByDevices"].Length-1] = (Sums["EnergyConsumptionByDevices_col_production"].Sum(r => r));
break;
#endregion
case "ConsumptionByManufactureByPeriod"://общая по производству
#region "ConsumptionByManufactureByPeriod"
Records = Form_records<ConsumptionByManufactureByPeriod>().Select(r=>(object)r).ToList();
//Подготавливаем лист id мест по которым будем считать данные для итогов
List<int> total_sums_place_ids = new List<int>();
Constants.places_total.Values.ToList()
.ForEach(r =>
{ total_sums_place_ids.AddRange(r); }
);
//Задача для каждого поля для указного для подсчёта,
//посчитать данные в разрезе списка индификаторов в Constants.places
var fInfo_ConsumptionByManufactureByPeriod = typeof(ConsumptionByManufactureByPeriod).GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
Records_List = new Dictionary<string, List<object>>(Constants.fields_to_sum_ConsumptionByManufactureByPeriod.Count);
foreach (var field_name in Constants.fields_to_sum_ConsumptionByManufactureByPeriod)
{
//подсчитываем данные по местам
Records_List.Add(field_name,
SumField_byPlaceId(
field_name,
Records
.Select(r=>(ConsumptionByManufactureByPeriod)r)
.ToList(),
roundNum,
total_sums_place_ids)
.Select(r=>(object)r)
.ToList());
}
break;
#endregion
case "ConsumptionByBDM1ByHour"://БДМ-1(Часовой)
case "ConsumptionByBDM2ByHour"://БДМ-2(Часовой)
#region ConsumptionByBDMByHour
Records = Form_records<ConsumptionByBDMbyHour>("ConsumptionByBDMByHour").Select(r=>(object)r).ToList();
if (Records==null||Records.Count==0)
{
break;
}
//Из-за того что для вывода по часового мы берем сетку по часам,
//а циклы могот заканчиватся и начинатся внутри часа, то на эти цикла происходит дублирование по параметрам,
//так что пробегаемся по записям и ищем такие случаи, и объединяем их в одну запись
//берем элементы по count-2 потому что сравниваем два элемента и последний не счем сравнивать
var temp_recs = new List<ConsumptionByBDMbyHour>();
for (int i = 0; i < Records.Count - 1; i++)
{
var curr = (IHaveComposition)Records.ElementAt(i);
var next = (IHaveComposition)Records.ElementAt(i + 1);
var excludeProp = new Dictionary<string, bool>() {["ID"]=false,["Composition"]=false};
if (IsEqualPropValue(firstObject: curr, secondObject: next, excludePropList: excludeProp))
{
curr.Composition += ", " + next.Composition;
i++;
}
temp_recs.Add((ConsumptionByBDMbyHour)curr);
}
Records = temp_recs.Select(r=>(object)r).ToList();
//Для строки Итого:
Sums.Add("ConsumptionByBDMByHour",
value:
//чтобы получить итого по записям, выделяем нужные столбцы и добаляем столбец по кторому будем вести группировку
GetSumsAndAvgProp(
Records.Select(r => (ConsumptionByBDMbyHour)r).ToList(),
propForSumList: tesSumList.ToDictionary(r => r, r => false),
propForAvgList: tesAvgList.ToDictionary(r => r, r => false))
.Select(d => (double)(d??0.0)).ToArray());//распаковываем в дабл
break;
#endregion
case "SkuDataByShifts_BDM1":
case "SkuDataByShifts_BDM2":
#region SkuDataByShifts
var ter_list_shifts = Constants.ter_list_shifts;
//нарезаем указный период на смены
var shifts_list = new List<Shift>();
int shift_index = 0;
reportDates.CurrShiftStart = reportDates.CurrShiftStart.AddHours(-reportDates.ShiftLength);
reportDates.CurrShiftEnd = reportDates.CurrShiftEnd.AddHours(-reportDates.ShiftLength);
while (true)
{
if (reportDates.CurrShiftStart > DateTime.Now || reportDates.CurrShiftStart > reportDates.EndDate)//поледняя смена не должна выходить за текущюю дату или конец преиода
{
break;
}
else
{
shifts_list.Add(new Shift() { shift_start = reportDates.CurrShiftStart, shift_end = reportDates.CurrShiftEnd, shift_index = shift_index });
}
reportDates.CurrShiftStart = reportDates.CurrShiftStart.AddHours(reportDates.ShiftLength);
reportDates.CurrShiftEnd = reportDates.CurrShiftEnd.AddHours(reportDates.ShiftLength);
shift_index++;
}
var shiftStart = DateTime.Now;
var shiftEnd = DateTime.Now;
//если смена не выбрана(-1) то выводим последнию смену в нарезке, иначе выбраную смену
if (shifts_list.Count > 0)
{
shiftStart = shifts_list[GetCurShiftIndex(currShiftIndex, shifts_list.Count)].shift_start;
shiftEnd = shifts_list[GetCurShiftIndex(currShiftIndex, shifts_list.Count)].shift_end;
}
else
{
shiftStart = reportDates.CurrShiftStart;
shiftEnd = reportDates.CurrShiftEnd;
}
reportDates.CurrShiftStart= shiftStart;
reportDates.CurrShiftEnd = shiftEnd;
Records_List.Add("SkuDataByShifts",
Form_records<SkuDataByShifts>("SkuDataByShifts")
.OrderBy(r => r.CycleDateBegin)
.Select(r=>(object)r)
.ToList());
var sku_list = Records_List["SkuDataByShifts"]
.Select(r => ((IHaveSku)r).Sku)
.ToList();
Records_List.Add("Shifts_plan",
context.StgPlanTer
.Where(r => r.Year == shiftStart.Year
&& r.Month == shiftStart.Month
&& sku_list.Contains(r.Sku)
&& r.PlaceId == (isBDM1 ? 1 : 2))
.Select(r=>(object)r)
.ToList());
Records_List.Add("Shifts_index_list", shifts_list.Select(r => (object)r.shift_index.ToString()).ToList());
Records_List.Add("Shifts_dates_list", shifts_list
.Select(r => $"{r.shift_start.ToShortDateString()} {r.shift_start.ToShortTimeString()}-{r.shift_end.ToShortDateString()} {r.shift_end.ToShortTimeString()}")
.Select(r=>(object)r)
.ToList());
//if (export_excel == 1)
//{ return Excel_methods.Export_to_Excel_SkuDataByShifts(new ExcelExport(), report_name, shiftStart, shiftEnd, placeName: place_name, this, baseStrings, RecordsToShow_SkuDataByShifts, ter_list_shifts, shiftId: RecordsToShow_SkuDataByShifts.Count > 0 ? RecordsToShow_SkuDataByShifts.FirstOrDefault().ShiftId : 0, machinist_name: RecordsToShow_SkuDataByShifts.Count > 0 ? RecordsToShow_SkuDataByShifts.FirstOrDefault().Machinist_name : ""); }
break;
#endregion
default:
break;
}
//Если нужен список продуктов
if (Records?.Count>0? Records?.FirstOrDefault().GetType().GetInterface("IListSortOfProd") != null:false)
{
ListSortOfProd = Records.OrderBy(m => ((IListSortOfProd)m).SortofProduction).Select(m => ((IListSortOfProd)m).SortofProduction).Distinct().ToArray();
if (SelectedSortOfProduction != null && SelectedSortOfProduction != "All")
Records = Records.Where(r => ((IListSortOfProd)r).SortofProduction == SelectedSortOfProduction).ToList();
}
//Округляем все поля
RoundProps();
this.Successfull = true;
}
public virtual void ChangeState(States newState)
{
if (newState == State)
{
return;
}
string exceptionMessage = $"Некорректная операция. Не предусмотрена смена статуса с {State} на {newState}";
switch (newState)
{
//Подана
case States.Submited:
if (State == States.New || State == States.OnClarification)
{
State = newState;
}
else
{
throw new InvalidOperationException(exceptionMessage);
}
break;
//На уточнении
case States.OnClarification:
if (State == States.Agreed ||
State == States.GivenForTake ||
State == States.Canceled ||
State == States.PartiallyClosed)
{
State = newState;
}
else
{
throw new InvalidOperationException(exceptionMessage);
}
break;
//Согласована
case States.Agreed:
if (State == States.Submited)
{
State = newState;
}
else
{
throw new InvalidOperationException(exceptionMessage);
}
break;
//Передана на выдачу
case States.GivenForTake:
if (State == States.Agreed)
{
State = newState;
}
else
{
throw new InvalidOperationException(exceptionMessage);
}
break;
case States.Canceled:
if (State == States.Submited ||
State == States.New ||
State == States.OnClarification ||
State == States.GivenForTake ||
State == States.Agreed)
{
State = newState;
}
else
{
throw new InvalidOperationException(exceptionMessage);
}
break;
case States.Closed:
State = Sums.All(x => x.Sum == x.ObservableExpenses.Sum(e => e.Money)) ? newState : States.PartiallyClosed;
break;
case States.PartiallyClosed:
break;
default:
throw new NotImplementedException($"Не реализовано изменение статуса для {newState}");
}
}
/// <summary>
/// Method for averaging colors by given block size of pixelation ratio, replacing alpha
/// color with random neutral for source image color which get turned back to alpha once
/// the pixelization finishes as averagedAlphaIgnore color that gets drawn back as transparent.
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public Image DrawImage(Bitmap source, Bitmap target)
{
if (source == null)
{
throw new ArgumentNullException("Source cannot be null!");
}
else if (target == null)
{
throw new ArgumentNullException("Target cannot be null!");
}
if (source.Size != target.Size)
{
throw new ArgumentException("Source and Target don't match sizes!");
}
List <Color> localPalette = new List <Color>();
Color alphaIgnore = Color.FromArgb(255, 0, 0, 0);
int alphaX = -1;
int alphaY = -1;
bool coordinatesPicked = false;
for (int x = 0; x < source.Width; x++)
{
for (int y = 0; y < source.Height; y++)
{
var local = source.GetPixel(x, y);
if (!localPalette.Contains(local))
{
localPalette.Add(local);
}
if (local.A == 0 && coordinatesPicked == false)
{
coordinatesPicked = true;
alphaX = x;
alphaY = y;
}
}
}
while (true)
{
var randomGenerator = new Random();
int genR = randomGenerator.Next(0, 256);
int genG = randomGenerator.Next(0, 256);
int genB = randomGenerator.Next(0, 256);
Color randomColor = Color.FromArgb(255, genR, genG, genB);
bool isUnique = false;
foreach (var color in localPalette)
{
if (color == randomColor)
{
isUnique = false;
break;
}
else
{
isUnique = true;
}
}
if (isUnique == true)
{
alphaIgnore = randomColor;
break;
}
else
{
continue;
}
}
for (int x = 0; x < source.Width; x++)
{
for (int y = 0; y < source.Height; y++)
{
var local = source.GetPixel(x, y);
if (local.A == 0)
{
source.SetPixel(x, y, alphaIgnore);
}
}
}
using (var graphics = Graphics.FromImage(target))
{
graphics.PageUnit = GraphicsUnit.Pixel;
for (int x = 0; x < source.Width; x += this.blockSize)
{
for (int y = 0; y < source.Height; y += this.blockSize)
{
var sums = new Sums();
for (int xn = 0; xn < this.blockSize; xn++)
{
for (int yn = 0; yn < this.blockSize; yn++)
{
if (x + xn >= source.Width || y + yn >= source.Height)
{
continue;
}
var color = source.GetPixel(x + xn, y + yn);
sums.A += color.A;
sums.R += color.R;
sums.G += color.G;
sums.B += color.B;
sums.C++;
}
}
var average = Color.FromArgb(
sums.A / sums.C,
sums.R / sums.C,
sums.G / sums.C,
sums.B / sums.C);
using (var brush = new SolidBrush(average))
{
graphics.FillRectangle(brush, x, y, (x + this.blockSize), (y + this.blockSize));
}
}
}
}
if (coordinatesPicked == true)
{
Color averagedAlphaIgnore = source.GetPixel(alphaX, alphaY);
for (int x = 0; x < source.Width; x++)
{
for (int y = 0; y < source.Height; y++)
{
Color local = target.GetPixel(x, y);
if (local == averagedAlphaIgnore)
{
target.SetPixel(x, y, Color.FromArgb(0, 255, 255, 255));
}
}
}
}
return(target);
}
private void Calculate()
{
Min = Sums.Min();
StDev = Sums.StDev();
Average = Sums.Average();
}
