public void Dispose()
{
_errors = null;
_balanceCalculated = null;
_integralActPsList = null;
_signaturesByBalance = null;
_sectionsByType = null;
_commentProps = null;
}
public static DataTableEx ExecuteFormulasValueExpand(FormulasResult formulasResult, ArchivesValues_List2 archivesList,
IVisualDataRequestObjectsNames getNameInterface, int doublePrecision, DateTime dtStart, DateTime dtEnd, enumTimeDiscreteType discreteType, string timeZoneId,
ArchivesTPValueAllChannels archivesTpList = null, SectionIntegralActsTotalResults?archivesSection = null,
bool isSumTiForChart = false, FormulaConstantArchives constantArchives = null, ArchTariffIntegralsTIs cumulativeIntegrals = null,
ForecastConsumptionResult fResult = null, List <TRowObjectForGrid> listTiViewModel = null, bool isDetailOv = true,
BalanceFreeHierarchyResults balanceFreeHierarchy = null)
{
if (archivesList == null && formulasResult == null && archivesTpList == null && archivesSection == null &&
constantArchives == null && cumulativeIntegrals == null && fResult == null && balanceFreeHierarchy == null)
{
return(null);
}
#if DEBUG
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
#endif
var dts = getNameInterface.GetDateTimeListForPeriod(dtStart, dtEnd, discreteType, timeZoneId.GeTimeZoneInfoById());
var numbersValues = dts.Count;
//Расчетный ли это профиль
var deltaDiscrete = (int)discreteType + 1;
//-------------Таблица для представления данных----------------------------
var userTable = new DataTableEx();
userTable.BeginLoadData();
try
{
userTable.Columns.Add("EventDateTime", typeof(DateTime));
#region Создаем колонки в пользовательском представлениее
var vType = typeof(IFValue);
var k = 0;
#region ------------Перебираем точки---------------------------------------------
var tiColumnValues = userTable.AddColumnsTi(ref k, archivesList, isSumTiForChart, isDetailOv);
#endregion
#region ------------ТП---------------------------------------------
var tpColumnValues = userTable.AddColumnsTp(ref k, archivesTpList, listTiViewModel);
// var tpArchives = new List<Tuple<TPoint, Dictionary<byte, List<TPointValue>>>>();
//if (archivesTpList != null)
//{
//}
#endregion
#region ------------Перебираем формулы---------------------------------------------
var formulaArchives = new List <Tuple <IFormulaInfo, TFormulasResult, List <TFormulaConsist> > >();
if (formulasResult != null && formulasResult.Result_Values != null)
{
foreach (var formulas in formulasResult.Result_Values
.Select(f => new Tuple <IFormulaInfo, TFormulasResult, List <TFormulaConsist> >(f.GetFormulaInfo(getNameInterface),
f.Result_Values.FirstOrDefault(), f.FormulaConsist))
.Where(f => f.Item1 != null)
.OrderBy(f => f.Item1.FormulaName))
{
var fVal = formulas.Item2;
if (fVal != null && fVal.Val_List != null && fVal.Val_List.Count > 0)
{
var col = new DataColumn("F_VALUE" + k, vType)
{
ReadOnly = true,
};
userTable.Columns.Add(col);
k++;
}
//------------ТИ которые входят в формулу-------------------------------------------------------
if (formulasResult.IsValuesAllTIEnabled && formulas.Item3 != null)
{
foreach (var archivesValue in formulas.Item3)
{
if (archivesValue.Val_List == null)
{
continue;
}
//var hierObj =
// getNameInterface.GetHierarchyDbTreeObject(archivesValue.TI_Ch_ID.TI_ID.ToString(),
// archivesValue.TypeTIinFormula);
var col = new DataColumn("F_VALUE" + k, vType)
{
ReadOnly = true,
};
userTable.Columns.Add(col);
k++;
}
}
formulaArchives.Add(formulas);
}
}
#endregion
#region ------------Перебираем константы---------------------------------------------
if (constantArchives != null && constantArchives.FormulaConstantDict != null)
{
foreach (var formulaConstant in constantArchives.FormulaConstantDict.Values)
{
if (formulaConstant.ArchiveValues != null && formulaConstant.ArchiveValues.Count > 0)
{
var col = new DataColumn("F_VALUE" + k, vType)
{
//Caption = "Конст. -" + formulaConstant.ConstantaParams.FormulaConstantName,
ReadOnly = true,
};
userTable.Columns.Add(col);
//namesFormulas.Add(new GridTitle
//{
// //TitleString = "Конст. -" + formulaConstant.ConstantaParams.FormulaConstantName,
// TitleString = "Конст. -" + formulaConstant.ConstantaParams.FormulaConstantName
//});
k++;
}
}
}
#endregion
#region ------------Перебираем сечения---------------------------------------------
if (archivesSection != null && archivesSection.Value.Total_Result != null &&
archivesSection.Value.Total_Result.Count > 0)
{
foreach (var sectionPair in archivesSection.Value.Total_Result)
{
var section = sectionPair.Value;
if (section.TotalVals != null && section.TotalVals.Count > 0)
{
var sectionName = getNameInterface.GetSectionName(sectionPair.Key);
var col = new DataColumn("F_VALUE" + k, vType)
{
//Caption = "Сеч. -" + sectionName,
ReadOnly = true,
};
userTable.Columns.Add(col);
//namesFormulas.Add(new GridTitle
//{
// //TitleString = "Сеч. -" + sectionName,
// TitleString = "Сеч. -" + sectionName
//});
k++;
}
}
}
#endregion
#region ------------Перебираем накопительные интегралы------------------------------
if (cumulativeIntegrals != null && cumulativeIntegrals.IntegralsValue30orHour != null)
{
var nType = typeof(IConvertible);
foreach (var integral in cumulativeIntegrals.IntegralsValue30orHour)
{
if (integral.Cumulate_Val_List == null || integral.Cumulate_Val_List.Count == 0)
{
continue;
}
//var tiName = getNameInterface.GetTIName(integral.TI_Ch_ID.TI_ID, integral.TI_Ch_ID.IsCA);
//var psName = getNameInterface.GetPSName(integral.PS_ID, integral.TI_Ch_ID.IsCA);
var col = new DataColumn("F_VALUE" + k, nType)
{
//Caption = tiName +
// getNameInterface.GetChanelTypeNameByID(integral.TI_Ch_ID.TI_ID,
// integral.TI_Ch_ID.ChannelType, false,
// cumulativeIntegrals.DTStart, cumulativeIntegrals.DTEnd) + " \n" +
// psName,
ReadOnly = true,
};
userTable.Columns.Add(col);
k++;
}
}
#endregion
#region ------------Прогнозирование------------------------------
if (fResult != null && fResult.Result_Values != null)
{
var hierarchyObject =
getNameInterface.GetHierarchyDbTreeObject(fResult.ID.ID, fResult.ID.TypeHierarchy);
if (hierarchyObject != null)
{
foreach (var archive in fResult.Result_Values)
{
if (archive.Value == null)
{
continue;
}
var col = new DataColumn("F_VALUE" + k, vType)
{
Caption = hierarchyObject.Name + " " + getNameInterface.GetChanelTypeNameByID(archive.Key.Channel, false),
ReadOnly = true,
};
userTable.Columns.Add(col);
k++;
}
}
}
#endregion
#region ------------Перебираем балансы---------------------------------------------
var balanceColumnValues = userTable.AddColumnsBalances(ref k, balanceFreeHierarchy);
#endregion
#endregion
#if DEBUG
sw.Stop();
Console.WriteLine("Создаем колонки в пользовательском представлениее - > {0} млс", sw.ElapsedMilliseconds);
sw.Restart();
#endif
#region Наполняем поставщик
if (archivesList != null)
{
userTable.Description = new DataTableDescription
{
DtStart = archivesList.DTStart,
DiscreteType = archivesList.DiscreteType,
TimeZoneId = archivesList.TimeZoneId,
};
}
else
{
userTable.Description = null;
}
for (var i = 0; i < numbersValues; i++)
{
k = 0;
//--------колонки в промежуточную таблицу-----------
var row = userTable.NewRow() as DataRowEx;
var dt = dts[i];
row["EventDateTime"] = dt;
//row["Time"] = dt.TimeOfDay;
//-------пишем в промежуточную таблицу значения--------
//TVALUES_DB mainChannelVal = null;
#region ТИ
userTable.PopulateRowsTi(ref k, tiColumnValues, numbersValues, isSumTiForChart, row, i);
#endregion
#region ТП
userTable.PopulateRowsTp(ref k, tpColumnValues, row, i);
#endregion
#region Формулы
if (formulasResult != null && formulasResult.Result_Values != null)
{
foreach (var formulas in formulaArchives)
{
enumTypeHierarchy typeHierarchy;
switch (formulas.Item1.FormulasTable)
{
case enumFormulasTable.Info_Formula_Description:
typeHierarchy = enumTypeHierarchy.Formula;
break;
case enumFormulasTable.Info_TP2_OurSide_Formula_Description:
typeHierarchy = enumTypeHierarchy.Formula_TP_OurSide;
break;
case enumFormulasTable.Info_TP2_Contr_Formula_Description:
typeHierarchy = enumTypeHierarchy.Formula_TP_CA;
break;
default:
typeHierarchy = enumTypeHierarchy.Unknown;
break;
}
var id = new ID_Hierarchy
{
ID = formulas.Item1.Formula_UN,
TypeHierarchy = typeHierarchy
};
var fVal = formulas.Item2;
if (fVal != null && fVal.Val_List != null && fVal.Val_List.Count > 0)
{
var v = fVal.Val_List.ElementAtOrDefault(i);
if (v != null)
{
var useMeasureModule =
string.IsNullOrEmpty(fVal.MeasureUnit_UN)
&&
(string.Equals(fVal.MeasureQuantityType_UN, "EnergyUnit") ||
string.Equals(fVal.MeasureQuantityType_UN, "PowerUnit"));
//row["F_VALUE" + k] = v;
row.SetValue("F_VALUE" + k, i, 0, id, null, fVal.MeasureUnit_UN, v, useMeasureModule);
}
k++;
}
if (formulasResult.IsValuesAllTIEnabled && formulas.Item3 != null)
{
foreach (var archivesValue in formulas.Item3)
{
if (archivesValue.Val_List == null)
{
continue;
}
var v = archivesValue.Val_List.ElementAtOrDefault(i);
if (v != null)
{
if (archivesValue.Id == null)
{
row["F_VALUE" + k] = new TVALUES_DB
{
F_VALUE = v.F_VALUE,
F_FLAG = v.F_FLAG,
};
}
else
{
row.SetValue("F_VALUE" + k, i, archivesValue.ChannelType, archivesValue.Id, null, null, v);
}
}
k++;
}
}
}
}
#endregion
#region Константы
if (constantArchives != null && constantArchives.FormulaConstantDict != null)
{
foreach (var formulaConstant in constantArchives.FormulaConstantDict.Values)
{
if (formulaConstant.ArchiveValues != null)
{
var v = formulaConstant.ArchiveValues.ElementAtOrDefault(i);
if (v != null)
{
row.SetValue("F_VALUE" + k, i, 0, new ID_Hierarchy
{
ID = formulaConstant.ConstantaParams.FormulaConstant_UN,
TypeHierarchy = enumTypeHierarchy.FormulaConstant
}, null, null, v);
}
k++;
}
}
}
#endregion
#region Сечения
if (archivesSection != null && archivesSection.Value.Total_Result != null &&
archivesSection.Value.Total_Result.Count > 0)
{
foreach (var sectionPair in archivesSection.Value.Total_Result)
{
var section = sectionPair.Value;
List <TVALUES_DB> values;
if (section.TotalVals != null && section.TotalVals.Count > 0 &&
section.TotalVals.TryGetValue(enumInputType.Saldo, out values))
{
var v = values.ElementAtOrDefault(i);
if (v != null)
{
//row["F_VALUE" + k] = v;
row.SetValue("F_VALUE" + k, i, 0, new ID_Hierarchy
{
ID = sectionPair.Key.ToString(),
TypeHierarchy = enumTypeHierarchy.Section
}, null, null, v);
}
k++;
}
}
}
#endregion
#region ------------Перебираем накопительные интегралы------------------------------
if (cumulativeIntegrals != null && cumulativeIntegrals.IntegralsValue30orHour != null)
{
var unitDigitCoeff = (double)cumulativeIntegrals.UnitDigit;
foreach (var integral in cumulativeIntegrals.IntegralsValue30orHour)
{
if (integral.Cumulate_Val_List == null || integral.Cumulate_Val_List.Count == 0)
{
continue;
}
var val = integral.Cumulate_Val_List.ElementAtOrDefault(i);
if (val != null)
{
var v = new TVal
{
F_FLAG = val.F_FLAG,
F_VALUE = val.Value / unitDigitCoeff,
};
//var v = val.Value / unitDigitCoeff;
//------------ТИ ФСК-----------------------------
row.SetValue("F_VALUE" + k, i, integral.TI_Ch_ID.ChannelType, new ID_Hierarchy
{
ID = integral.TI_Ch_ID.TI_ID.ToString(),
TypeHierarchy = enumTypeHierarchy.Info_TI
}, integral.TI_Ch_ID.DataSourceType, null, v);
//row["F_VALUE" + k] = v;
//if (integral.TI_Ch_ID.ChannelType < 3 && v > 0)
//{
// mainChannelVal = v;
//}
}
k++;
}
}
#endregion
#region ------------Прогнозирование------------------------------
if (fResult != null && fResult.Result_Values != null)
{
var hierarchyObject =
getNameInterface.GetHierarchyDbTreeObject(fResult.ID.ID, fResult.ID.TypeHierarchy);
if (hierarchyObject != null)
{
var unitDigitCoeff = (double)fResult.UnitDigit;
foreach (var archive in fResult.Result_Values)
{
if (archive.Value == null)
{
continue;
}
var val = archive.Value.ElementAtOrDefault(i);
if (val != null)
{
var v = new TVALUES_DB
{
F_FLAG = val.F_FLAG,
F_VALUE = val.F_VALUE / unitDigitCoeff,
};
//------------ТИ ФСК-----------------------------
//row["F_VALUE" + k] = v;
row.SetValue("F_VALUE" + k, i, archive.Key.Channel, new ID_Hierarchy
{
ID = archive.Key.ID,
TypeHierarchy = archive.Key.TypeHierarchy,
}, null, null, v);
}
k++;
}
}
}
#endregion
#region Балансы
userTable.PopulateRowsBalances(ref k, balanceColumnValues, row, i);
#endregion
// if (consumptionSchedule != null && mainChannelVal != null && mainChannelVal.F_VALUE != null &&
// mainChannelVal.F_FLAG.HasFlag(VALUES_FLAG_DB.ConsumptionScheduleOverflow))
//{
// //Ищем значение типового графика для данной получасовки
// var cs_val =
// consumptionSchedule.ConsumptionScheduleValues.FirstOrDefault(
// cs => cs.TotalDay == (dt.Date - dtStart.Date).TotalDays && cs.TotalNumberPerDay ==
// dt.TimeOfDay.TotalMinutes / (30 * deltaDiscrete));
// if (cs_val != null && cs_val.F_VALUE.HasValue)
// {
// double delta = 0;
// if (mainChannelVal.F_VALUE > cs_val.MAX_VALUE)
// {
// delta = mainChannelVal.F_VALUE - cs_val.F_VALUE.Value;
// }
// else
// {
// delta = mainChannelVal.F_VALUE - cs_val.F_VALUE.Value;
// }
// row["ConsumptionSchedule"] = delta;
// row["ConsumptionSchedulePercent"] = delta / mainChannelVal.F_VALUE * 100;
// }
//}
userTable.Rows.Add(row);
}
#endregion
}
finally
{
userTable.EndLoadData();
userTable.AcceptChanges();
}
#if DEBUG
sw.Stop();
Console.WriteLine("ExecuteFormulasValueExpand - > {0} млс", sw.ElapsedMilliseconds);
#endif
return(userTable);
}
public Dictionary <string, DetailFieldInfo> AddColumnsBalances(ref int k, BalanceFreeHierarchyResults balanceFreeHierarchy)
{
var result = new Dictionary <string, DetailFieldInfo>();
if (balanceFreeHierarchy == null || balanceFreeHierarchy.CalculatedValues == null)
{
return(result);
}
var objectType = typeof(ObjectIdCollection);
var vType = typeof(IFValue);
var comparer = new IFreeHierarchyObjectComparerTyped();
var freeHierarchyComparer = new IFreeHierarchyObjectEqualityComparer();
foreach (var balance in balanceFreeHierarchy.CalculatedValues.Values)
{
if (balance.CalculatedByDiscretePeriods == null || balance.CalculatedByDiscretePeriods.Count == 0)
{
continue;
}
var id = new ID_Hierarchy
{
ID = balance.BalanceFreeHierarchyUn,
TypeHierarchy = enumTypeHierarchy.UniversalBalance
};
#region Перебираем подгруппы
//Фактический небаланс,кВт (по модулю) FactUnbalanceValue
var columnName = "FactUnbalanceValue" + k;
Columns.Add(new DataColumn(columnName, vType)
{
ReadOnly = true,
});
k++;
result[columnName] = new DetailFieldInfo
{
ColumnName = columnName,
Id = id,
UseMeasureModule = true,
//MeasureUnitUn = tiValue.MeasureUnit_UN,
BalanceValues = balance.CalculatedByDiscretePeriods,
};
//Фактический небаланс,%
columnName = "FactUnbalancePercent" + k;
Columns.Add(new DataColumn(columnName, vType)
{
ReadOnly = true,
});
k++;
result[columnName] = new DetailFieldInfo
{
ColumnName = columnName,
Id = id,
UseMeasureModule = false,
MeasureUnitUn = "RatioUnit.Percent",
BalanceValues = balance.CalculatedByDiscretePeriods,
};
#endregion
}
return(result);
}
public ExcelReportFreeHierarchyAdapter(BalanceFreeHierarchyResults balanceCalculated,
Dictionary <string, List <IFreeHierarchyBalanceSignature> > signaturesByBalance,
TExportExcelAdapterType adapterType, StringBuilder errors,
bool isFormingSeparateList,
bool isUseThousandKVt, bool printLandscape, string branchName, byte doublePrecisionProfile,
byte doublePrecisionIntegral, bool need0, bool isAnalisIntegral, string timeZoneId, bool setPercisionAsDisplayed)
{
_branchName = branchName;
_printLandscape = printLandscape;
_balanceCalculated = balanceCalculated;
_signaturesByBalance = signaturesByBalance;
AdapterType = adapterType;
_discreteType = balanceCalculated.DiscreteType;
_errors = errors;
_dtStart = balanceCalculated.DTStart;
_dtEnd = balanceCalculated.DTEnd;
_dts = MyListConverters.GetDateTimeListForPeriod(balanceCalculated.DTStart, balanceCalculated.DTEnd, balanceCalculated.DiscreteType, balanceCalculated.TimeZoneId.GeTimeZoneInfoById());
_isFormingSeparateList = isFormingSeparateList && (AdapterType == TExportExcelAdapterType.toXLS || AdapterType == TExportExcelAdapterType.toXLSx);
_unitDigitIntegrals = balanceCalculated.UnitDigitIntegrals;
_unitDigit = balanceCalculated.UnitDigit;
_doublePrecisionIntegral = doublePrecisionIntegral;
_doublePrecisionProfile = doublePrecisionProfile;
_need0 = need0;
IsAnalisIntegral = isAnalisIntegral;
_setPercisionAsDisplayed = setPercisionAsDisplayed;
_intervalTimeList = MyListConverters.GetIntervalTimeList(_dtStart, _dtEnd, _discreteType, timeZoneId);
switch (_unitDigit)
{
case EnumUnitDigit.Null:
case EnumUnitDigit.None:
_unitDigitName = "";
break;
case EnumUnitDigit.Kilo:
_unitDigitName = "к";
break;
case EnumUnitDigit.Mega:
_unitDigitName = isUseThousandKVt ? "тыс.к" : "М";
break;
}
switch (_unitDigitIntegrals)
{
case EnumUnitDigit.Null:
case EnumUnitDigit.None:
_unitDigitIntegralName = "";
break;
case EnumUnitDigit.Kilo:
_unitDigitIntegralName = "к";
break;
case EnumUnitDigit.Mega:
_unitDigitIntegralName = isUseThousandKVt ? "тыс.к" : "М";
break;
}
_unitDigitHeatName = "Гкал"; //решили что отпуск тепла будет хранится/отображаться как есть (например в ЛЭРС) в Гкал
_unitDigitName += "Вт*ч";
_unitDigitIntegralName += "Вт*ч";
}
public static BalanceFreeHierarchyResults BL_GetFreeHierarchyBalanceResult(List <string> balanceFreeHierarchyUNs, DateTime dTStart, DateTime dTEnd, string timeZoneId,
TExportExcelAdapterType adapterType, bool isGenerateDoc, enumTimeDiscreteType discreteType,
EnumUnitDigit unitDigit, bool isFormingSeparateList, EnumUnitDigit unitDigitIntegrals, bool isUseThousandKVt, bool printLandscape, byte doublePrecisionProfile, byte doublePrecisionIntegral,
bool need0, bool isAnalisIntegral, bool setPercisionAsDisplayed, CancellationToken?cancellationToken = null)
{
var balance = new BalanceFreeHierarchyResults(balanceFreeHierarchyUNs, dTStart, dTEnd, timeZoneId, adapterType, isGenerateDoc,
discreteType, unitDigit, unitDigitIntegrals, cancellationToken);
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return(balance);
}
if (isGenerateDoc)
{
string branchName;
//Читаем подписантов
var signaturesByBalance = GetBalanceSignatures(balanceFreeHierarchyUNs, out branchName);
var po = new ParallelOptions();
if (cancellationToken.HasValue)
{
po.CancellationToken = cancellationToken.Value;
}
po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;
po.CancellationToken.ThrowIfCancellationRequested();
using (var adapter = new ExcelReportFreeHierarchyAdapter(balance, signaturesByBalance, adapterType, balance.Errors,
isFormingSeparateList, isUseThousandKVt, printLandscape, branchName,
doublePrecisionProfile, doublePrecisionIntegral, need0, isAnalisIntegral, timeZoneId, setPercisionAsDisplayed))
{
Parallel.ForEach(balanceFreeHierarchyUNs, po, (balanceUn, loopState) =>
{
BalanceFreeHierarchyCalculatedResult calculatedValue;
if (!balance.CalculatedValues.TryGetValue(balanceUn, out calculatedValue))
{
return;
}
//Формирование документов по каждому балансу
try
{
if (po.CancellationToken.IsCancellationRequested)
{
loopState.Break();
}
calculatedValue.CompressedDoc = CompressUtility.CompressGZip(adapter.BuildBalanceFreeHier(calculatedValue));
}
catch (Exception ex)
{
lock (balance.Errors)
{
balance.Errors.Append("Ошибка генерации документа - " + ex.Message);
}
}
});
}
}
return(balance);
}
