/// <summary>
/// Индекс значения результата
/// </summary>
/// <returns></returns>
public double ИндексЗначения(IHierarchyChannelID id, int halfHourIndx, enumTimeDiscreteType discreteType)
{
if (halfHourIndx == 0)
{
return(0);
}
if (discreteType == enumTimeDiscreteType.DBHalfHours)
{
return(halfHourIndx);
}
if (discreteType == enumTimeDiscreteType.DBHours)
{
if (halfHourIndx % 2 != 0)
{
return(0);
}
return(halfHourIndx / 2);
}
if (discreteType == enumTimeDiscreteType.DB24Hour)
{
if (halfHourIndx % 24 != 0)
{
return(0);
}
return(halfHourIndx / 24);
}
return(1);
}
public FormulaWorkedPeriodHierObject(int tiId, DateTime dtStart, DateTime dtEnd, enumTimeDiscreteType discreteType, string timeZoneId, IMyListConverters MyListConverters, IDateTimeExtensions dateTimeExtensions, IGetNotWorkedPeriodService _iGetNotWorkedPeriodService)
{
TiId = tiId;
DiscreteType = discreteType;
//Здесь запрашиваем и считаем количество отработанных часов
var workedPeriods = _iGetNotWorkedPeriodService.GetNotWorkedPeriods(new List <int> {
tiId
}, dateTimeExtensions.ClientToServer(dtStart, timeZoneId), dateTimeExtensions.ClientToServer(dtEnd, timeZoneId));
HoursByHalfhourNumber = new Dictionary <DateTime, double>();
//Считаем отработанные часы
if (discreteType == enumTimeDiscreteType.DBInterval)
{
HoursByHalfhourNumber.Add(dtStart, CalculateNumberWorkedHours(dtStart, dtEnd, workedPeriods, timeZoneId, MyListConverters));
}
else
{
var dts = MyListConverters.GetDateTimeListForPeriod(dtStart, dtEnd, discreteType, timeZoneId.GeTimeZoneInfoById());
for (var i = 0; i < dts.Count; i++)
{
var dt = dts[i];
var dte = i < dts.Count - 1 ? dts[i + 1].AddMinutes(-30) : dtEnd;
HoursByHalfhourNumber.Add(dt, CalculateNumberWorkedHours(dt, dte, workedPeriods, timeZoneId, MyListConverters));
}
}
}
public FormulasFunctionDescription(string id, string description, EnumTypeFormulasFunction typeFormulasFunction, enumTimeDiscreteType discreteType)
{
Id = id;
Description = description;
TypeFormulasFunction = typeFormulasFunction;
DiscreteType = discreteType;
}
public PrecalculatedFunctionVariable(string id, IFormulaArchivesPrecalculator formulaArchivesPrecalculator, EnumTypeFormulasFunction typeFormulasFunction, enumTimeDiscreteType discreteType)
{
FormulaArchivesPrecalculator = formulaArchivesPrecalculator;
TypeFormulasFunction = typeFormulasFunction;
DiscreteType = discreteType;
Id = id.ToLower();
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="dtStartClien">Начало по времени клиента</param>
/// <param name="dtEndClient">Окончание по времени клиента</param>
/// <param name="clientTimeZoneId">Идентификатор часового пояса клиента</param>
/// <param name="unitDigit">Запрошенные ед. измерения</param>
/// <param name="discreteType"></param>
public RecalculatorResiudes(DateTime dtStartClien, DateTime dtEndClient, string clientTimeZoneId, EnumUnitDigit unitDigit, enumTimeDiscreteType discreteType)
{
_tiForRecalculateResiudes = new ConcurrentStack <TArchivesValue>();
TiForResaveResiudes = new ConcurrentStack <DBResiduesTable>();
_dtStartClient = dtStartClien;
_dtStartServer = _dtStartClient.ClientToServer(clientTimeZoneId);
_unitDigit = unitDigit;
_discreteType = discreteType;
_resiudes24Hindexes = MyListConverters.GetIntervalTimeList(dtStartClien, dtEndClient, enumTimeDiscreteType.DB24Hour, clientTimeZoneId);
}
public ArchivesHierObjectProvider(List <IHierarchyChannelID> list, bool v, DateTime dtStart, DateTime dtEnd, EnumDataSourceType?_dataSourceType, enumTimeDiscreteType discreteType, EnumUnitDigit none, bool _isReadCalculatedValues, string _timeZoneId)
{
this.list = list;
this.v = v;
this.dtStart = dtStart;
this.dtEnd = dtEnd;
this._dataSourceType = _dataSourceType;
this.discreteType = discreteType;
this.none = none;
this._isReadCalculatedValues = _isReadCalculatedValues;
this._timeZoneId = _timeZoneId;
}
public static void ConfigureGrid(XamGrid dataGrid, DataTableEx userTable, enumTimeDiscreteType discreteType, enumTypeInformation typeInformation,
string format, bool isHalfhours, DataTemplateSelector flagTemplateSelector, bool isCumulateDrums = false, bool isDateTimeGroupingGridControlXam = true,
IValueConverter converter = null)
{
if (dataGrid == null || userTable == null)
{
return;
}
var view = userTable.DefaultView;
try
{
//dataGrid.BeginInit();
//dataGrid.FieldSettings.AllowEdit = false;
view.AllowDelete = view.AllowEdit = view.AllowNew = false;
//var style = new Style(typeof(XamNumericEditor));
//style.Setters.Add(new Setter(ValueEditor.FormatProperty, format));
if (isHalfhours)
{
SetHalfhoursColumnsForXamDataGrid(dataGrid, userTable, discreteType, typeInformation, format, isCumulateDrums, isDateTimeGroupingGridControlXam);
}
//else
//{
// SetValidateColumnsForXamDataGrid(dataGrid, userTable, flagTemplateSelector, converter);
//}
//view.Table = null;
}
finally
{
//dataGrid.EndInit();
}
//dataGrid.Dispatcher.BeginInvoke((System.Action) (() =>
//{
dataGrid.ItemsSource = view;
//}), DispatcherPriority.Background);
}
public TForecastObjectFactDemand(IEnumerable <string> forecastObjectUns, DateTime dtStart, DateTime dtEnd, string timeZoneId,
EnumUnitDigit unitDigit, enumTimeDiscreteType forecastDiscreteType, bool isReadCalculatedValues)
{
if (forecastObjectUns == null)
{
Errors.Append("Выберите объекты!");
return; //Критическая ошибка
}
ForecastObjectUns = new HashSet <string>(forecastObjectUns);
DtStart = dtStart;
DtEnd = dtEnd;
TimeZoneId = timeZoneId;
UnitDigit = unitDigit;
ForecastDiscreteType = forecastDiscreteType;
Archives = new Dictionary <string, List <ForecastByInputParamArchives> >();
IsReadCalculatedValues = isReadCalculatedValues;
Errors = new StringBuilder();
if (dtEnd < dtStart)
{
Errors.Append("Начальная дата должна быть больше конечной!");
return; //Критическая ошибка
}
#region Читаем архивы
//_numberHalfHoursForForecasting = MyListConverters.GetNumbersValuesInPeriod(ForecastDiscreteType, forecastingStart, forecastingEnd, TimeZoneId);
var objectParams = ForecastObjectFactory.GetForecastObjectParams(ForecastObjectUns, dtStart, dtEnd, null, timeZoneId,
Errors, unitDigit, forecastDiscreteType, isReadCalculatedValues);
foreach (var objectParam in objectParams)
{
Archives[objectParam.ForecastObject_UN] = objectParam.ArchivesByInputParam;
}
#endregion
}
public TArchiveHierObjectPeriod(IHierarchyChannelID id, DateTime dtStart, DateTime dtEnd, List <Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB> vals, enumTimeDiscreteType discreteType,
string timeZoneId, IMyListConverters _myListConverters)
{
Id = id;
DtStart = dtStart;
DtEnd = dtEnd;
var indx = 0;
Vals = new List <ArchiveHierObjectPeriodValue>();
foreach (var dt in _myListConverters.GetDateTimeListForPeriod(dtStart, dtEnd,
discreteType, timeZoneId.GeTimeZoneInfoById()))
{
Vals.Add(new ArchiveHierObjectPeriodValue
{
Year = dt.Year,
Month = dt.Month,
Day = dt.Day,
Hour = dt.Hour,
Val = vals.ElementAtOrDefault(indx++),
});
}
DiscreteType = discreteType;
}
/// <summary>
/// Строим суточные интегралы
/// </summary>
/// <param name="archiveIntegrals">Интегралы</param>
/// <param name="getNameInterface"></param>
/// <param name="dts">Даты/время</param>
/// <returns></returns>
public static DataTableEx ExecuteDailyIntegrals(ArchTariffIntegralsTIs archiveIntegrals, enumTimeDiscreteType discreteType)
{
if (archiveIntegrals == null || archiveIntegrals.IntegralsValue30orHour == null)
{
return(null);
}
if (discreteType < enumTimeDiscreteType.DB24Hour)
{
//Допускается только 3 периода дискретизации
discreteType = enumTimeDiscreteType.DB24Hour;
}
var unitDigitCoeff = (double)archiveIntegrals.UnitDigit;
var dtStart = archiveIntegrals.DTStart;
var dtEnd = archiveIntegrals.DTEnd; //Округляем до суток
var dts = Extention.GetDateTimeListForPeriod(dtStart, dtEnd,
discreteType, archiveIntegrals.TimeZoneId.GeTimeZoneInfoById());
#if DEBUG
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
#endif
var userTable = new DataTableEx()
{
FieldForSearch = "NameTI",
};
userTable.BeginLoadData();
try
{
#region Создаем основные колонки
userTable.Columns.Add("Parent", typeof(IFreeHierarchyObject));
userTable.Columns.Add("NameTI", typeof(IFreeHierarchyObject));
userTable.Columns.Add("Coeff", typeof(double));
userTable.Columns.Add("CoeffLosses", typeof(double));
userTable.Columns.Add("Channel", typeof(object));
userTable.Columns.Add("DataSource", typeof(string));
#endregion
#region Посуточные колонки
var sufixFormat = "dd.MM.yyyy";
var prefixs = new List <string>
{
"_OnStart",
"_OnEnd",
"_Delta",
}; //Строим 3 колонки по каждой дате
foreach (var d in dts)
{
var startCaption = d.ToString(sufixFormat);
var endCaption = "";
string groupLabel;
switch (discreteType)
{
case enumTimeDiscreteType.DB24Hour:
groupLabel = "За " + startCaption;
endCaption = d.AddDays(1).ToString(sufixFormat);
break;
case enumTimeDiscreteType.DBMonth:
groupLabel = "За " + d.ToString("MMMM yyyy");
endCaption = d.AddMonths(1).ToString(sufixFormat);
break;
default:
groupLabel = "За период c " + dtStart.ToString("dd.MM.yyyy HH:mm") + " по " + dtEnd.ToString("dd.MM.yyyy HH:mm");
endCaption = dtEnd.Date.AddDays(1).ToString(sufixFormat);
break;
}
foreach (var prefix in prefixs)
{
var col = new DataColumnEx(prefix + startCaption, typeof(IConvertible));
switch (prefix)
{
case "_OnStart":
col.Caption = startCaption;
break;
case "_OnEnd":
col.Caption = endCaption;
break;
default:
col.Caption = "Расход";
col.IsFValue = true;
break;
}
col.GroupName = groupLabel;
userTable.Columns.Add(col);
}
}
#endregion
#region Наполняем содержимым
var rd = TimeSpan.FromDays(1);
foreach (var tiVal in archiveIntegrals.IntegralsValue30orHour)
{
if (tiVal.Val_List == null)
{
continue;
}
var row = userTable.NewRow() as DataRowEx;
TPSHierarchy ps;
if (EnumClientServiceDictionary.DetailPSList.TryGetValue(tiVal.PS_ID, out ps))
{
row["Parent"] = ps;
}
TInfo_TI ti;
if (EnumClientServiceDictionary.TIHierarchyList.TryGetValue(tiVal.TI_Ch_ID.TI_ID, out ti))
{
row["NameTI"] = ti;
}
row["Coeff"] = tiVal.CoeffTransformation;
row["Channel"] = new TTariffPeriodID
{
ChannelType = tiVal.TI_Ch_ID.ChannelType,
IsOV = false,
TI_ID = tiVal.TI_Ch_ID.TI_ID,
StartDateTime = dtStart,
FinishDateTime = dtEnd,
};
row["DataSource"] = EnumClientServiceDictionary
.DataSourceTypeList
.FirstOrDefault(v =>
EqualityComparer <EnumDataSourceType?> .Default.Equals(tiVal.TI_Ch_ID.DataSourceType,
v.Key))
.Value;
DateTime?startRangeDt = null, endRangeDt = null; //Обрабатываемый диапазон
var rangeDiff = 0.0; //накопленный расход за диапазон
var ranfeFlag = VALUES_FLAG_DB.None; //Состояние интегралов за диапазон
var isFirst = true;
//Перебираем интегралы
foreach (var iVal in tiVal.Val_List.OrderBy(d => d.EventDateTime))
{
if (isFirst)
{
row["CoeffLosses"] = iVal.CoeffLosses ?? 1;
isFirst = false;
}
var roundedDt = iVal.EventDateTime.Round(rd);
//Это новая запись или переход на следующую дату/время
if (!startRangeDt.HasValue || roundedDt >= endRangeDt)
{
if (iVal.IsIntegralType)
{
//Эта дата осталась от предыдущего диапазона, надо закрыть диапазона
if (startRangeDt.HasValue)
{
row["_OnEnd" + startRangeDt.Value.ToString(sufixFormat)] = iVal.F_VALUE / unitDigitCoeff;
row["_Delta" + startRangeDt.Value.ToString(sufixFormat)] = new TVALUES_DB
{
F_VALUE = rangeDiff,
F_FLAG = ranfeFlag,
};
}
if (roundedDt > dtEnd)
{
break;
}
//Теперь новый диапазон
switch (discreteType)
{
case enumTimeDiscreteType.DB24Hour:
//Первая дата/время нового диапазона
startRangeDt = new DateTime(roundedDt.Year, roundedDt.Month, roundedDt.Day);
//Последняя дата/время нового диапазона
endRangeDt = startRangeDt.Value.AddDays(1);
break;
case enumTimeDiscreteType.DBMonth:
//Первая дата/время нового диапазона
startRangeDt = new DateTime(roundedDt.Year, roundedDt.Month, 1);
//Последняя дата/время нового диапазона
endRangeDt = startRangeDt.Value.AddMonths(1);
break;
default:
//Первая дата/время нового диапазона
startRangeDt = dtStart.Date;
//Последняя дата/время нового диапазона
endRangeDt = dtEnd.Date.AddDays(1);
break;
}
row["_OnStart" + startRangeDt.Value.ToString(sufixFormat)] = iVal.F_VALUE / unitDigitCoeff;
rangeDiff = 0;
ranfeFlag = VALUES_FLAG_DB.None;
}
}
rangeDiff += iVal.F_VALUE_DIFF / unitDigitCoeff;
ranfeFlag = ranfeFlag.CompareAndReturnMostBadStatus(iVal.F_FLAG);
}
userTable.Rows.Add(row);
}
#endregion
}
finally
{
userTable.EndLoadData();
userTable.AcceptChanges();
}
#if DEBUG
sw.Stop();
Console.WriteLine("ExecuteDailyIntegralsExpand - > {0} млс", sw.ElapsedMilliseconds);
#endif
return(userTable);
}
/// <summary>
/// Результат прекалькуляции
/// </summary>
/// <returns></returns>
public TVALUES_DB GetArchive(IHierarchyChannelID id, int halfHourIndx, enumTimeDiscreteType discreteType, List <Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB> requestedArchives)
{
if (!_isRequestArchives)
{
return(null);
}
List <ArchiveHierObjectPeriodValue> allPeriodArchive = null;
if (_precalculateArchives.Count > 0)
{
var cashedArchives = _precalculateArchives.FirstOrDefault(a => a.Id.Equals(id) && a.DiscreteType == discreteType);
if (cashedArchives != null)
{
allPeriodArchive = cashedArchives.Vals;
}
}
if (allPeriodArchive == null)
{
DateTime dtStart, dtEnd; //Период в рамках которого нужны данные по указанной точке
switch (discreteType)
{
case enumTimeDiscreteType.DB24Hour: //нужны посуточные данные
dtStart = _dtClientStart.Date; //округляем до начала суток клиента
dtEnd = new DateTime(_dtClientEnd.Year, _dtClientEnd.Month, _dtClientEnd.Day, 23, 30, 0);
break;
case enumTimeDiscreteType.DBMonth: //нужны данные по месяцам
dtStart = new DateTime(_dtClientStart.Year, _dtClientStart.Month, 1); //округляем до начала месяца клиента
dtEnd = new DateTime(_dtClientEnd.Year, _dtClientEnd.Month, 1).AddMonths(1).AddMinutes(-30); //Округляем до окончания месяца
break;
default:
//В остальных случаях границы периода не расширяем
dtStart = _dtClientStart;
dtEnd = _dtClientEnd;
break;
}
//смотрим нужно ли запрашивать в архим
if (requestedArchives != null && dtStart == _dtClientStart && dtEnd == _dtClientEnd)
{
var archives = _myListConverters.ConvertHalfHoursToOtherList(discreteType, requestedArchives, _dtClientStart, _dtClientEnd, _timeZoneId);
var objectArchive = new TArchiveHierObjectPeriod(id, dtStart, dtEnd, archives, discreteType, _timeZoneId, _myListConverters);
allPeriodArchive = objectArchive.Vals;
if (_precalculateArchives != null)
{
_precalculateArchives.Add(objectArchive);
}
}
else
{
IArchivesHierObject archives = new ArchivesHierObjectProvider(new List <IHierarchyChannelID> {
id
}, true, dtStart, dtEnd, _dataSourceType,
discreteType, EnumUnitDigit.None, _isReadCalculatedValues, _timeZoneId);
if (archives.Errors.Length > 0)
{
Errors.Append(archives.Errors);
}
if (archives.result_Values != null && archives.result_Values.Count > 0)
{
var values = archives.result_Values.FirstOrDefault().Value;
var objectArchive = new TArchiveHierObjectPeriod(id, dtStart, dtEnd, values, discreteType, _timeZoneId, _myListConverters);
allPeriodArchive = objectArchive.Vals;
if (_precalculateArchives != null)
{
_precalculateArchives.Add(objectArchive);
}
}
}
}
if (allPeriodArchive == null)
{
return(null);
}
ArchiveHierObjectPeriodValue objectPeriodValue;
if (discreteType == enumTimeDiscreteType.DBInterval)
{
objectPeriodValue = allPeriodArchive.FirstOrDefault();
}
else
{
var dt = _dtServerStart.ServerToUtc().AddMinutes(30 * halfHourIndx).UtcToClient(_timeZoneId);
//Теперь выбираем нужный период (текущие сутки, текущий месяц) из всего архива
switch (discreteType)
{
case enumTimeDiscreteType.DBMonth: //нужны данные по месяцам
objectPeriodValue = allPeriodArchive.FirstOrDefault(v => v.Year == dt.Year && v.Month == dt.Month);
break;
case enumTimeDiscreteType.DB24Hour: //нужны посуточные данные
objectPeriodValue = allPeriodArchive.FirstOrDefault(v => v.Year == dt.Year && v.Month == dt.Month && v.Day == dt.Day);
break;
default: //нужны часовые
objectPeriodValue = allPeriodArchive.FirstOrDefault(v => v.Year == dt.Year && v.Month == dt.Month && v.Day == dt.Day && v.Hour == dt.Hour);
break;
}
}
if (objectPeriodValue != null)
{
return(objectPeriodValue.Val);
}
return(null);
}
/// <summary>
/// Определяем работала ли точка в расчетном периоде
/// </summary>
/// <param name="id">Идентифиуатор объекта</param>
/// <param name="halfHourIndx">Индекс получасовки</param>
/// <param name="discreteType">Период дискретизации</param>
/// <returns></returns>
public bool ЕслиВключено(IHierarchyChannelID id, int halfHourIndx, enumTimeDiscreteType discreteType)
{
return(true);
}
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);
}
static void SetHalfhoursColumnsForXamDataGrid(XamGrid dataGrid, DataTableEx userTable,
enumTimeDiscreteType discreteType, enumTypeInformation typeInformation, string format, bool isCumulateDrums, bool isDateTimeGroupingGridControlXam)
{
//var nameStyle = dataGrid.FindResource("TIChanelName") as Style;
Style labelStyle = null;
//try
//{
// labelStyle = dataGrid.FindResource("LabelObjectStyle") as Style;
// dataGrid.FieldSettings.LabelPresenterStyle = labelStyle;
//}
//catch
//{
//}
var groupLabelTemplate = dataGrid.FindResource("GroupLabelObjectTemplate") as DataTemplate;
var channelLabelTemplate = dataGrid.FindResource("ChannelLabelObjectTemplate") as DataTemplate;
var unchannelLabelTemplate = dataGrid.FindResource("LabelUnchannelTemplate") as DataTemplate;
var vTemplate = dataGrid.FindResource("FValueTemplate") as DataTemplate;
var vTemplateNoBindMeasure = Application.Current.FindResource("FValueTemplateNoBindMeasureFormTemplate") as DataTemplate;
var vFreeHierarchyObjectTemplate = Application.Current.FindResource("FreeHierarchyObjectTemlate") as DataTemplate;
var columnWidth = new ColumnWidth(105, false);
//var widthValue = new FieldLength(105);
//var widthFreeHier = new FieldLength(270);
var comparer = new IFValueComparer();
var dtConverter = new DateTimeConverter();
var dtToolTiptemplate = Application.Current.Resources[ConstantHelper.DateTimeTemplateName] as DataTemplate;
var measure = dataGrid.FindParent <IMeasure>();
dataGrid.Resources["IMeasure"] = measure;
//var fieldLayout = dataGrid.ColumnLayouts[0];
//TemplateField dtField;
try
{
//fieldLayout.Fields.BeginUpdate();
//fieldLayout.SortedFields.BeginUpdate();
var dtCol = userTable.Columns["EventDateTime"];
var dtField = new TextColumn
{
Key = dtCol.ColumnName,
IsReadOnly = true,
//DataType = dtCol.DataType,
HeaderText = dtCol.Caption,
//Width = new FieldLength(95),
Width = new ColumnWidth(90, false),
ValueConverter = dtConverter,
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
AllowToolTips = AllowToolTips.Always,
ToolTipContentTemplate = dtToolTiptemplate,
DataViewType = typeof(DateTime),
IsSortable = true,
IsSorted = SortDirection.Ascending,
GroupByComparer = new ByDayComparer(),
//Settings = { LabelPresenterStyle = dataGrid.FindResource("TimeStyle") as Style }
};
dataGrid.Columns.Add(dtField);
if (isCumulateDrums)
{
//dtField.Settings.CellValuePresenterStyle =
// XamDataGridHelper.DataTemplateToCellValuePresenterStyle(ConstantHelper.DateTimeTemplateName);
dtConverter.Parametr = ConstantHelper.DateTimeTemplateName;
//dtField.ItemTemplate = Application.Current.Resources[ConstantHelper.DateTimeTemplateName] as DataTemplate;
}
else
{
string dataTemplateToCellValuePresenterStyleName;
//-------------------------------
switch (discreteType)
{
case enumTimeDiscreteType.DB24Hour:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.DateTemplateName;
break;
case enumTimeDiscreteType.DBMonth:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.MonthName;
break;
default:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.DateTimeTemplateName;
break;
}
dtConverter.Parametr = dataTemplateToCellValuePresenterStyleName;
}
dtField.HeaderText = "Время";
//dataGrid.GroupBySettings.GroupByColumns.Add(dtField);
//if (discreteType == enumTimeDiscreteType.DB24Hour)
//{
//dtField.Settings.GroupByMode = FieldGroupByMode.Month;
//dtField.Settings.GroupByRecordPresenterStyle =
//Application.Current.FindResource("MonthYearXamDataGridStyle") as Style;
//}
//else
//{
//dtField.Settings.GroupByMode = FieldGroupByMode.Date;
//}
//SummaryCalculator statType;
//string prefix;
//if (typeInformation == enumTypeInformation.Power)
//{
// statType = new FValueAvgCalculator(format);
// prefix = "Сред:";
//}
//else
//{
// statType = new FValueSumCalculator(format);
// prefix = "Сум:";
//}
//var stringFormat = prefix + " {0:" + format + "}";
var stringFormat = " {0:" + format + "}";
var dfc = new DetailFieldInfoEqualityComparer();
//FieldGroup fieldGroupByObject = null;
//FieldGroup fieldGroupByMeasureCategory = null;
//EnumMeasureUnitCategory? previousMeasureCategory = null; //Для определения групповать или нет по категории
foreach (var colGroupByObject in userTable.Columns
.Cast <DataColumn>()
.Where(c => c.ColumnName != "EventDateTime")
.Select(c =>
{
DetailFieldInfo fieldInfo;
userTable.TryGetIndexByItemName(c.ColumnName, out fieldInfo);
return(new Tuple <DetailFieldInfo, DataColumn>(fieldInfo, c));
})
.GroupBy(c => c.Item1, dfc))
{
var fieldInfo = colGroupByObject.Key;
if (fieldInfo == null || fieldInfo.ChannelType == 0)
{
//Группировать не нужно
foreach (var colByObject in colGroupByObject)
{
FValueSummaryDefinition summaryDefinition;
var fld = AddFieldAndSummary(colByObject.Item2, comparer,
fieldInfo != null && fieldInfo.UseMeasureModule, vTemplate, vTemplateNoBindMeasure, columnWidth);
if (fieldInfo != null && fieldInfo.Id != null)
{
fld.HeaderTemplate = groupLabelTemplate;
fld.Label = colByObject.Item1.Id;
}
else
{
fld.HeaderText = colByObject.Item2.Caption;
}
//fld.HeaderText = (fieldInfo == null ? colByObject.Item2.Caption : (object)colByObject.Item1).ToString();
dataGrid.Columns.Add(fld);
//if (summaryDefinition != null)
//{
// fieldLayout.SummaryDefinitions.Add(summaryDefinition);
//}
}
}
else
{
var fieldGroupByObject = new GroupColumn
{
//Label = fieldInfo.Id,
Key = fieldInfo.ColumnName + "___",
Label = fieldInfo.Id,
//HeaderText = fieldInfo.Id.ToString(),
HeaderTemplate = groupLabelTemplate,
};
dataGrid.Columns.Add(fieldGroupByObject);
//Группируем по объектам
foreach (var colGroupByMeasureCategory in colGroupByObject.GroupBy(c => c.Item1.MeasureUnitUn.SubstringQuantityUn()))
{
var colGroupByMeasureCategoryList = colGroupByMeasureCategory.ToList();
if (!string.IsNullOrEmpty(colGroupByMeasureCategory.Key) && colGroupByMeasureCategoryList.Count > 1)
{
//Есть категории ед. измерения и их несколько
var fieldGroupByMeasureCategory = new GroupColumn
{
Label = new LabelMeasureQuantity
{
MeasureQuantityType_UN = colGroupByMeasureCategory.Key,
},
Key = fieldInfo.Id + "_" + colGroupByMeasureCategory.Key,
};
fieldGroupByObject.Columns.Add(fieldGroupByMeasureCategory);
foreach (var colByMeasure in colGroupByMeasureCategoryList)
{
FValueSummaryDefinition summaryDefinition;
var fld = AddFieldAndSummary(colByMeasure.Item2, comparer, fieldInfo.UseMeasureModule,
vTemplate,
vTemplateNoBindMeasure,
columnWidth);
//isCumulateDrums, statType, stringFormat, fieldLayout, out summaryDefinition);
//fld.Label = colByMeasure.Item1;
fld.HeaderTemplate = colByMeasure.Item1.ChannelType == 0 ? unchannelLabelTemplate : channelLabelTemplate;
fld.Label = colByMeasure.Item1;
fieldGroupByMeasureCategory.Columns.Add(fld);
//if (summaryDefinition != null)
//{
// fieldLayout.SummaryDefinitions.Add(summaryDefinition);
//}
}
}
else
{
//Нет категорий, или она одна
var fielgGroupByReplacedTiDict = new Dictionary <string, GroupColumn>();
foreach (var colByMeasure in colGroupByMeasureCategoryList)
{
if (colByMeasure.Item2.ColumnName.StartsWith("ovInfo"))
{
//Это информация об ОВ
//var hoc = new HierObjectsConverterComparer();
var fld = AddField(colByMeasure.Item2, fieldInfo.UseMeasureModule,
vFreeHierarchyObjectTemplate,
vFreeHierarchyObjectTemplate, columnWidth);
//widthFreeHier
fld.Label = "Замещаемые ТИ";
//fld.Settings.FilterOperandUIType = FilterOperandUIType.DropDownList;
//fld.Settings.FilterLabelIconDropDownType = FilterLabelIconDropDownType.MultiSelectExcelStyle;
//fld.Settings.GroupByComparer = hoc;
//fld.ValueToTextConverter = new HierObjectsConverter();
//fld.Settings.FilterComparer = new HierObjectsConverterComparer();
fieldGroupByObject.Columns.Add(fld);
}
else
{
GroupColumn fielgGroupByReplacedTi = null;
//Группируем по замещаемой ТИ
if (colByMeasure.Item2.ColumnName.StartsWith("ovValue") &&
!fielgGroupByReplacedTiDict.TryGetValue(
colByMeasure.Item1.GroupByReplacedTiName, out fielgGroupByReplacedTi))
{
fielgGroupByReplacedTi = new GroupColumn
{
Label = colByMeasure.Item1.ReplacedId,
Key = colByMeasure.Item1.ColumnName + "_",
HeaderText = colByMeasure.Item1.ReplacedId.ToString(),
};
fielgGroupByReplacedTiDict[colByMeasure.Item1.GroupByReplacedTiName] =
fielgGroupByReplacedTi;
}
//FValueSummaryDefinition summaryDefinition;
var fld = AddFieldAndSummary(colByMeasure.Item2, comparer, fieldInfo.UseMeasureModule,
vTemplate,
vTemplateNoBindMeasure,
columnWidth);
//isCumulateDrums, statType, stringFormat, fieldLayout, out summaryDefinition);
fld.Label = colByMeasure.Item1;
fld.HeaderTemplate = colByMeasure.Item1.ChannelType == 0 ? unchannelLabelTemplate : channelLabelTemplate;
if (fielgGroupByReplacedTi != null)
{
fielgGroupByReplacedTi.Columns.Add(fld);
}
else
{
fieldGroupByObject.Columns.Add(fld);
}
//if (summaryDefinition != null)
//{
// fieldLayout.SummaryDefinitions.Add(summaryDefinition);
//}
//if (colByMeasure.Item1.IsOv)
//{
// //Если это ОВ, добавляем суммарную информацию о неразнесенных значениях
// var unWritedOvs = new FValueSummaryDefinition
// {
// SourceFieldName = colByMeasure.Item2.ColumnName,
// Calculator = new FValueSumUnreplacedCalculator(format),
// StringFormat = stringFormat,
// UseMeasureModule = fieldInfo.UseMeasureModule,
// };
// fieldLayout.SummaryDefinitions.Add(unWritedOvs);
//}
}
}
if (fielgGroupByReplacedTiDict.Count > 0)
{
foreach (var c in fielgGroupByReplacedTiDict.Values)
{
fieldGroupByObject.Columns.Add(c);
}
}
}
}
}
}
//if (isDateTimeGroupingGridControlXam &&
// (discreteType == enumTimeDiscreteType.DBHalfHours || discreteType == enumTimeDiscreteType.DBHours ||
// discreteType == enumTimeDiscreteType.DB24Hour))
//{
// //dtField.Settings.AllowSummaries = false;
// dtField.Settings.AllowGroupBy = true;
// fieldLayout.SortedFields.Add(new FieldSortDescription("EventDateTime", ListSortDirection.Ascending,
// true));
//}
//else
//{
// dtField.DisplayTemplate = Application.Current.Resources[ConstantHelper.DateTimeTemplateName] as DataTemplate;
// //dtField.Settings.CellValuePresenterStyle =
// // XamDataGridHelper.DataTemplateToCellValuePresenterStyle(ConstantHelper.DateTimeTemplateName);
//}
//var consumptionScheduleField = fieldLayout.Fields.FirstOrDefault(ff => ff.Name == "ConsumptionSchedule");
//if (consumptionScheduleField != null)
//{
// consumptionScheduleField.Label = "Тип. потр.";
//}
//var consumptionSchedulePercentField = fieldLayout.Fields.FirstOrDefault(ff => ff.Name == "ConsumptionSchedulePercent");
//if (consumptionSchedulePercentField != null)
//{
// consumptionSchedulePercentField.Label = "Тип. потр. %";
//}
}
finally
{
// fieldLayout.SortedFields.EndUpdate();
//fieldLayout.Fields.EndUpdate();
}
//dataGrid.FieldLayoutSettings.FixedFieldUIType = FixedFieldUIType.Splitter;
//dataGrid.FieldSettings.SummaryDisplayArea = SummaryDisplayAreas.BottomFixed;
if (userTable.Columns.Count < 20)
{
//из-за того что тормоза ограничиваем
//dataGrid.FieldSettings.SummaryDisplayArea = dataGrid.FieldSettings.SummaryDisplayArea | SummaryDisplayAreas.InGroupByRecords;
}
//if (userTable.Columns.Count < 1000)
//{
// dataGrid.RecordsInViewChanged += ExpandFirstRecord;
//}
}
/// <summary>
/// Наполнение списка архива отсутствующими значений
/// </summary>
/// <param name="discreteType">Период дискретизации</param>
/// <param name="archivesList">Архивы, которые наполняем</param>
public void FillVoidHalfHours(List <TVALUES_DB> archivesList, enumTimeDiscreteType discreteType,
VALUES_FLAG_DB mask, ref VALUES_FLAG_DB totalPrimaryFlag)
{
var totalFlag = totalPrimaryFlag;
var totalHalfhourIndex = 0;
foreach (var numbersHalfHoursInOurPeriod in _intervalTimeList)
{
var periodFlag = VALUES_FLAG_DB.None;
var periodValue = 0.0;
for (var hhIndex = 0; hhIndex <= numbersHalfHoursInOurPeriod; hhIndex++)
{
VALUES_FLAG_DB flag;
double value;
var isNotWorkedHalfHour = _isExistsNotWorkedPeriod && _notWorkedRange.Any(r =>
(hhIndex >= r.Item1) && (!r.Item2.HasValue || hhIndex <= r.Item2));
if (isNotWorkedHalfHour)
{
flag = VALUES_FLAG_DB.IsNotWorkedPeriod;
value = 0;
}
else
{
flag = VALUES_FLAG_DB.DataNotFull | mask;
#region Акт недоучета, обработка ручного ввода КА
//Прибавляем по акту недоучета
if (_isActUndercountExists)
{
IPeriodBase <double> currentCoeff = null;
IPeriodBase <double> currentLossesCoeff = null;
if (_calculateCoeffs)
{
#region Коэфф. трансформации
IPeriodBase <bool> isDisabledPeriod;
var haveDisabledPeriod =
_coeffTransformationDisabledWorker.TryGetCurrentPeriodOrFindForTotalIndexHh(totalHalfhourIndex,
out isDisabledPeriod);
if ((!haveDisabledPeriod && !_isCoeffTransformationDisabledByDefault) ||
(haveDisabledPeriod && !isDisabledPeriod.PeriodValue.Value)
) //Если нет заблокированного периода, или период разрешен
{
//Не нашли один коэфф для данного часа или нет общего коэфф, значит ищем по каждой получасовке
_coeffTranformationWorker.TryGetCurrentPeriodOrFindForTotalIndexHh(totalHalfhourIndex,
out currentCoeff);
}
#endregion
#region Коэфф. потерь
if (_useLossesCoeff)
{
_coeffLossesWorker.TryGetCurrentPeriodOrFindForHalfhour(totalHalfhourIndex,
out currentLossesCoeff);
}
#endregion
}
EnumActMode actMode;
var av = _actUndercountValues.CalculateUndercountValues(totalHalfhourIndex, out actMode, currentCoeff, currentLossesCoeff);
if (av.HasValue)
{
value = Math.Round(av.Value, 8) / _unitDigit;
if (actMode == EnumActMode.Замещение)
{
flag &= ~(VALUES_FLAG_DB.DataNotFull | VALUES_FLAG_DB.NotCorrect |
VALUES_FLAG_DB.DataNotComplete);
}
flag |= VALUES_FLAG_DB.ActUndercountExists;
}
else
{
value = 0;
}
}
else
{
value = 0;
}
#endregion
}
periodValue += value;
periodFlag |= flag;
totalHalfhourIndex++;
}
totalFlag |= periodFlag;
archivesList.Add(new Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB(periodFlag, periodValue));
}
totalPrimaryFlag = totalFlag;
}
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 BalanceFreeHierarchyResults(List <string> balanceFreeHierarchyUNs, DateTime dTStart, DateTime dTEnd,
string timeZoneId, TExportExcelAdapterType adapterType, bool isGenerateDoc, enumTimeDiscreteType discreteType, EnumUnitDigit unitDigit,
EnumUnitDigit unitDigitIntegrals, CancellationToken?cancellationToken = null)
{
if (unitDigit == EnumUnitDigit.Null)
{
unitDigit = EnumUnitDigit.None;
}
BalanceFreeHierarchyUNs = balanceFreeHierarchyUNs.Distinct().ToList();
DTStart = dTStart.RoundToHalfHour(true);
DTEnd = dTEnd.RoundToHalfHour(true);
TimeZoneId = timeZoneId;
UnitDigit = unitDigit;
UnitDigitIntegrals = unitDigitIntegrals;
AdapterType = adapterType;
DiscreteType = discreteType;
_cancellationToken = cancellationToken;
Errors = new StringBuilder();
CalculatedValues = new ConcurrentDictionary <string, BalanceFreeHierarchyCalculatedResult>();
if (BalanceFreeHierarchyUNs == null || BalanceFreeHierarchyUNs.Count == 0)
{
Errors.Append("Неверный идентификатор(ы) баланса!");
return;
}
if ((DTEnd < DTStart))
{
Errors.Append("Дата окончания должна быть больше или равна даты начала!");
return;
}
_dtServerStart = DTStart.ClientToServer(TimeZoneId);
_dtServerEnd = DTEnd.ClientToServer(TimeZoneId);
_isGenerateDoc = isGenerateDoc;
var tiForRequestAdditionalInfo = new ConcurrentDictionary <TI_ChanelType, ConcurrentStack <BalanceFreeHierarchyItemParams> >(new TI_ChanelComparer());
using (var calculator = new BalanceFreeHierarchyCalculator(BalanceFreeHierarchyUNs, isGenerateDoc, Errors, DiscreteType, DTStart, DTEnd, TimeZoneId, tiForRequestAdditionalInfo,
UnitDigit, UnitDigitIntegrals))
{
SectionsByType = calculator.SectionsByType;
var po = new ParallelOptions();
if (cancellationToken.HasValue)
{
po.CancellationToken = cancellationToken.Value;
}
po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;
po.CancellationToken.ThrowIfCancellationRequested();
//Строим результаты по документам
Parallel.ForEach(BalanceFreeHierarchyUNs, po, (balanceFreeHierarchyUn, loopState) =>
{
try
{
if (po.CancellationToken.IsCancellationRequested)
{
loopState.Break();
}
var calculatedResult = calculator.Calculate(balanceFreeHierarchyUn);
if (calculatedResult == null)
{
return;
}
CalculatedValues.TryAdd(balanceFreeHierarchyUn, calculatedResult);
}
catch (Exception ex)
{
lock (Errors)
{
Errors.Append(ex.Message);
}
}
});
SubsectionNames = calculator.SubsectionNames;
}
if (_cancellationToken.HasValue && _cancellationToken.Value.IsCancellationRequested)
{
return;
}
#region Собираем доп. информацию
if (!tiForRequestAdditionalInfo.IsEmpty)
{
SortedList <TI_ChanelType, List <TTransformators_Information> > transormatorsInformation = null;
ConcurrentDictionary <TI_ChanelType, List <ArchCalc_Replace_ActUndercount> > replaceActUndercountList = null;
Parallel.Invoke(() =>
{
//Информация о смене трансформаторов
transormatorsInformation = SectionIntegralActsResultsList.GetTransformationInformationList(DTStart, DTEnd, tiForRequestAdditionalInfo.Keys, UnitDigit,
enumOVMode.NormalMode, true,
TimeZoneId);
},
() =>
{
ConcurrentDictionary <TI_ChanelType, List <ArchCalc_Replace_ActUndercount> > resultOvs;
//Информация об акте недоучета
replaceActUndercountList = SectionIntegralActsResultsList.GetReplaceActUndercount(_dtServerStart, _dtServerEnd, tiForRequestAdditionalInfo.Keys, Errors, out resultOvs);
}
);
foreach (var pair in tiForRequestAdditionalInfo)
{
if (transormatorsInformation != null)
{
List <TTransformators_Information> informations;
if (transormatorsInformation.TryGetValue(pair.Key, out informations))
{
foreach (var itemParam in pair.Value)
{
itemParam.Transformatos_Information = informations;
}
}
}
if (replaceActUndercountList != null && replaceActUndercountList.Count > 0)
{
List <ArchCalc_Replace_ActUndercount> replaceInformation;
if (replaceActUndercountList.TryGetValue(pair.Key, out replaceInformation) && replaceInformation != null)
{
foreach (var itemParam in pair.Value)
{
itemParam.ReplaceActUndercountList = replaceInformation;
}
}
}
}
}
#endregion
}
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 BalanceFreeHierarchyCalculator(List <string> balanceFreeHierarchyUN, bool isGenerateDoc, StringBuilder errors, enumTimeDiscreteType discreteType, DateTime dtStart, DateTime dtEnd, string timeZoneId,
ConcurrentDictionary <TI_ChanelType, ConcurrentStack <BalanceFreeHierarchyItemParams> > tiForRequestAdditionalInfo,
EnumUnitDigit unitDigit, EnumUnitDigit unitDigitIntegrals)
{
_errors = errors ?? new StringBuilder();
_discreteType = discreteType;
_dtStart = dtStart;
_dtEnd = dtEnd;
_timeZoneId = timeZoneId;
_tiForRequestAdditionalInfo = tiForRequestAdditionalInfo;
_unitDigit = unitDigit;
_unitDigitIntegrals = unitDigitIntegrals;
_intervalTimeList = MyListConverters.GetIntervalTimeList(_dtStart, _dtEnd, _discreteType, timeZoneId);
_dtServerStart = dtStart.ClientToServer(timeZoneId);
_dtServerEnd = dtEnd.ClientToServer(timeZoneId);
_isGenerateDoc = isGenerateDoc;
_numbersHalfHours = MyListConverters.GetNumbersValuesInPeriod(enumTimeDiscreteType.DBHalfHours, dtStart, dtEnd, timeZoneId);
var transIds = new ConcurrentDictionary <int, string>();
var reactorsIds = new ConcurrentStack <int>();
var tiForTransformatorsAndReactors = new ConcurrentStack <TI_ChanelType>();
var tis = new ConcurrentStack <TI_ChanelType>();
var integralTis = new ConcurrentStack <TI_ChanelType>();
var tps = new ConcurrentStack <TP_ChanelType>();
var formulas = new ConcurrentStack <TFormulaParam>();
var sections = new ConcurrentStack <TSectionChannel>();
var formulaConstantIds = new ConcurrentStack <string>();
try
{
_itemsResultByBalance = ReadBalanceParams(balanceFreeHierarchyUN, transIds, reactorsIds, tis, integralTis, tps, formulas,
sections, formulaConstantIds);
}
catch (AggregateException aex)
{
//критическая ошибка
throw aex.ToException();
}
#region Параметры трансформаторов и реакторов
try
{
ReadTransformatorsParams(transIds, tiForTransformatorsAndReactors, _itemsResultByBalance);
}
catch (AggregateException aex)
{
//не критическая ошибка
_errors.Append(aex.ToException());
}
#endregion
_archiveHalfhours = new TArchiveHalfhours(isGenerateDoc, dtStart, dtEnd,
unitDigit, timeZoneId, unitDigitIntegrals, tiForTransformatorsAndReactors,
tis, integralTis, tps, formulas, sections, formulaConstantIds, _intervalTimeList);
_numbersByDiscreteType = MyListConverters.GetNumbersValuesInPeriod(_discreteType, _dtStart, _dtEnd, timeZoneId);
SectionsByType = new ConcurrentDictionary <EnumBalanceFreeHierarchyType, List <Dict_Balance_FreeHierarchy_Section> >(GetFreeHierarchyBalanceSections(_itemsResultByBalance.Values.Select(v => (byte)v.BalanceFreeHierarchyType).Distinct())
.GroupBy(g => (EnumBalanceFreeHierarchyType)g.BalanceFreeHierarchyType_ID)
.ToDictionary(k => k.Key, v => v.ToList()));
}
private void MakeFunction(ref int eval_index, Function func, DateTime startDateTime, DateTime endDateTime, int HalfHourIndex, enumTimeDiscreteType DiscreteType)
{
if (func == null)
{
throw new Exception("Ошибка обработки функции ");
}
int func_args_start_index = eval_index - 1;
while (func_args_start_index >= 0 && OutEvalString[func_args_start_index].FunctionDevider == false)
{
func_args_start_index--;
}
if (func_args_start_index < 0)
{
throw new Exception("Ошибка обработки функции " + func.id);
}
int args_count = eval_index - func_args_start_index - 1;
if (func.FuncArgsCount != int.MaxValue && args_count != func.FuncArgsCount)
{
throw new Exception(string.Format(" У функции {0} объявлено аргументов {1}, передано в формулу {2}.",
func.id, func.FuncArgsCount, args_count));
}
else if (func.FuncArgsCount == int.MaxValue && args_count == 0)
{
throw new Exception("Функция " + func.id +
" объявлена без ограничения числа аргументов, передано в формулу 0.");
}
try
{
if (args_count > FunctionArgs.Count)
{
FunctionArgs = new FunctionArgumentList(args_count)
{
StartDateTime = startDateTime, EndDateTime = endDateTime, HalfHourIndex = HalfHourIndex
}
}
;
FunctionArgs.HalfHourIndex = HalfHourIndex;
FunctionArgs.DiscreteType = DiscreteType;
VALUES_FLAG_DB flag = VALUES_FLAG_DB.None;
for (int i = 0; i < args_count; i++)
{
OutEvalString[i + func_args_start_index + 1]
.GetValueAndCumulateFlag(ref flag, ref FunctionArgs, ref i);
}
OutEvalString[func_args_start_index].SetValue(flag,
((func.FuncDlgt == null)
? func.Value
: func.FuncDlgt(this, func,
FunctionArgs, 0, args_count).ToDouble(null)));
}
catch (Exception exc)
{
if (exc.InnerException != null)
{
throw new Exception("Ошибка обработки функции " + func.id + ":" + exc.InnerException.ToString(),
exc);
}
else
{
throw new Exception("Ошибка обработки функции " + func.id + ":" + exc.ToString(),
exc);
}
}
eval_index -= args_count;
}
/// <summary>
/// Количество часов в расчетном периоде, которое отработала точка
/// </summary>
/// <returns></returns>
public double Ччи(IHierarchyChannelID id, int halfHourIndx, enumTimeDiscreteType discreteType)
{
if (!_isRequestArchives || id == null)
{
return(0);
}
int tiId;
if (!int.TryParse(id.ID, out tiId))
{
return(0);
}
Dictionary <DateTime, double> hoursByHalfhourNumber = null;
if (_precalculateWorkedPeriod.Count > 0)
{
var cashedArchives = _precalculateWorkedPeriod.FirstOrDefault(a => a.TiId == tiId && a.DiscreteType == discreteType);
if (cashedArchives != null)
{
hoursByHalfhourNumber = cashedArchives.HoursByHalfhourNumber;
}
}
if (hoursByHalfhourNumber == null)
{
//Нет в словаре, надо добавить
DateTime dtStart, dtEnd; //Период в рамках которого нужны данные по указанной точке
switch (discreteType)
{
case enumTimeDiscreteType.DB24Hour: //нужны посуточные данные
dtStart = _dtClientStart.Date; //округляем до начала суток клиента
dtEnd = new DateTime(_dtClientEnd.Year, _dtClientEnd.Month, _dtClientEnd.Day, 23, 30, 0);
break;
case enumTimeDiscreteType.DBMonth: //нужны данные по месяцам
dtStart = new DateTime(_dtClientStart.Year, _dtClientStart.Month, 1); //округляем до начала месяца клиента
dtEnd = new DateTime(_dtClientEnd.Year, _dtClientEnd.Month, 1).AddMonths(1).AddMinutes(-30); //Округляем до окончания месяца
break;
default:
//В остальных случаях границы периода не расширяем
dtStart = _dtClientStart;
dtEnd = _dtClientEnd;
break;
}
var workedPeriodHierObject = new FormulaWorkedPeriodHierObject(tiId, dtStart, dtEnd, discreteType, _timeZoneId, _myListConverters, _dateTimeExtensions, _getNotWorkedPeriodService);
if (_precalculateWorkedPeriod != null)
{
_precalculateWorkedPeriod.Add(workedPeriodHierObject);
}
hoursByHalfhourNumber = workedPeriodHierObject.HoursByHalfhourNumber;
}
if (hoursByHalfhourNumber == null)
{
return(0);
}
//Считаем количество отработанных часов в нужном периоде дискретизвции
double hours;
if (discreteType == enumTimeDiscreteType.DBInterval)
{
hoursByHalfhourNumber.TryGetValue(_dtClientStart, out hours);
}
else
{
var dt = _dtServerStart.ServerToUtc().AddMinutes(30 * halfHourIndx).UtcToClient(_timeZoneId);
//Теперь выбираем нужный период (текущие сутки, текущий месяц) из всего архива
switch (discreteType)
{
case enumTimeDiscreteType.DBMonth: //нужны данные по месяцам
hours = hoursByHalfhourNumber.FirstOrDefault(v => v.Key.Year == dt.Year && v.Key.Month == dt.Month).Value;
break;
case enumTimeDiscreteType.DB24Hour: //нужны посуточные данные
hours = hoursByHalfhourNumber.FirstOrDefault(v => v.Key.Year == dt.Year && v.Key.Month == dt.Month && v.Key.Day == dt.Day).Value;
break;
default: //нужны часовые
hours = hoursByHalfhourNumber.FirstOrDefault(v => v.Key.Year == dt.Year && v.Key.Month == dt.Month && v.Key.Day == dt.Day && v.Key.Hour == dt.Hour).Value;
break;
}
}
return(hours);
}
static void SetHalfhoursColumnsForXamDataGrid(XamDataGrid dataGrid, DataTableEx userTable,
enumTimeDiscreteType discreteType, enumTypeInformation typeInformation, string format, bool isCumulateDrums
, bool isDateTimeGroupingGridControlXam, bool useBindedConverter)
{
//var nameStyle = dataGrid.FindResource("TIChanelName") as Style;
////Style labelStyle = null;
try
{
var labelStyle = dataGrid.FindResource("LabelObjectStyle") as Style;
dataGrid.FieldSettings.LabelPresenterStyle = labelStyle;
}
catch
{
}
//var vTemplate = dataGrid.FindResource("FValueTemplate") as DataTemplate;
var fValueNoBindMeasureStyle = dataGrid.FindResource("FValueNoBindMeasureStyle") as Style;
var vFreeHierarchyObjectTemplate = Application.Current.FindResource("FreeHierarchyObjectTemlate") as DataTemplate;
var fValueStyle = useBindedConverter ? dataGrid.FindResource("FValueStyle") as Style : fValueNoBindMeasureStyle;
var widthValue = new FieldLength(105);
var widthFreeHier = new FieldLength(270);
var comparer = new IFValueComparer();
var measure = dataGrid.FindParent <IMeasure>();
dataGrid.Resources["IMeasure"] = measure;
//var fConverter = new FValueConverter
//{
// FParameter = new FValueParameter
// {
// Measure = measure,
// }
//};
var fieldLayout = dataGrid.FieldLayouts[0];
var fields = fieldLayout.Fields;
try
{
fields.BeginUpdate();
//fieldLayout.SortedFields.BeginUpdate();
var dtCol = userTable.Columns["EventDateTime"];
var dtField = new TemplateField
{
Name = dtCol.ColumnName,
DataType = dtCol.DataType,
Label = dtCol.Caption,
Width = new FieldLength(95),
AllowFixing = AllowFieldFixing.Default,
FixedLocation = FixedFieldLocation.FixedToNearEdge,
Settings =
{
LabelPresenterStyle = dataGrid.FindResource("TimeStyle") as Style
}
};
fields.Add(dtField);
if (isCumulateDrums)
{
//dtField.Settings.CellValuePresenterStyle =
// XamDataGridHelper.DataTemplateToCellValuePresenterStyle(ConstantHelper.DateTimeTemplateName);
dtField.DisplayTemplate = Application.Current.Resources[ConstantHelper.DateTimeTemplateName] as DataTemplate;
}
else
{
string dataTemplateToCellValuePresenterStyleName;
//-------------------------------
switch (discreteType)
{
case enumTimeDiscreteType.DBHalfHours:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.HalfHourstoRangeTimeTemplateName;
break;
case enumTimeDiscreteType.DBHours:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.HourstoRangeTimeTemplateName;
break;
case enumTimeDiscreteType.DB24Hour:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.DateTemplateName;
break;
case enumTimeDiscreteType.DBMonth:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.MonthName;
break;
default:
dataTemplateToCellValuePresenterStyleName = ConstantHelper.DateTimeTemplateName;
break;
}
dtField.Tag = dataTemplateToCellValuePresenterStyleName; //Это нужно для форматирования при выгрузке в Excel
dtField.DisplayTemplate = Application.Current.Resources[dataTemplateToCellValuePresenterStyleName] as DataTemplate;
//dtField.Settings.CellValuePresenterStyle =
// XamDataGridHelper.DataTemplateToCellValuePresenterStyle(
// dataTemplateToCellValuePresenterStyleName);
}
dtField.Label = "Время";
if (discreteType == enumTimeDiscreteType.DB24Hour)
{
dtField.Settings.GroupByMode = FieldGroupByMode.Month;
dtField.Settings.GroupByRecordPresenterStyle =
Application.Current.FindResource("MonthYearXamDataGridStyle") as Style;
}
else
{
dtField.Settings.GroupByMode = FieldGroupByMode.Date;
}
SummaryCalculator statType;
string prefix;
if (typeInformation == enumTypeInformation.Power)
{
statType = new FValueAvgCalculator(format);
prefix = "Сред:";
}
else
{
statType = new FValueSumCalculator(format);
prefix = "Сум:";
}
var stringFormat = prefix + " {0:" + format + "}";
var dfc = new DetailFieldInfoEqualityComparer();
//FieldGroup fieldGroupByObject = null;
//FieldGroup fieldGroupByMeasureCategory = null;
//EnumMeasureUnitCategory? previousMeasureCategory = null; //Для определения групповать или нет по категории
foreach (var colGroupByObject in userTable.Columns
.Cast <DataColumn>()
.Where(c => c.ColumnName != "EventDateTime")
.Select(c =>
{
DetailFieldInfo fieldInfo;
userTable.TryGetIndexByItemName(c.ColumnName, out fieldInfo);
return(new Tuple <DetailFieldInfo, DataColumn>(fieldInfo, c));
})
.GroupBy(c => c.Item1, dfc))
{
if (colGroupByObject.Key == null || (colGroupByObject.Key.ChannelType == 0 && colGroupByObject.Key.ColumnType == EnumColumnType.None))
{
//Группировать не нужно
foreach (var colByObject in colGroupByObject)
{
DetailFieldInfo fieldInfo;
userTable.ItemsIndexesDict.TryGetValue(colByObject.Item2.ColumnName, out fieldInfo);
SummaryDefinition summaryDefinition;
var fld = AddFieldAndSummary(colByObject.Item2, widthValue, comparer, fieldInfo != null && fieldInfo.UseMeasureModule,
isCumulateDrums, statType, stringFormat, out summaryDefinition, fValueStyle);
fld.Label = fieldInfo == null ? colByObject.Item2.Caption : (object)colByObject.Item1;
fields.Add(fld);
if (summaryDefinition != null)
{
fieldLayout.SummaryDefinitions.Add(summaryDefinition);
}
}
}
//else if ()
//{
// //Группируем по типу
// foreach (var colByObjectByColumnType in colGroupByObject.GroupBy(c => c.Item1.ColumnType))
// {
// foreach (var colByObject in colByObjectByColumnType)
// {
// DetailFieldInfo fieldInfo;
// if (!userTable.ItemsIndexesDict.TryGetValue(colByObject.Item2.ColumnName, out fieldInfo)) continue;
// FValueSummaryDefinition summaryDefinition;
// var fld = AddFieldAndSummary(colByObject.Item2, widthValue, comparer, fieldInfo != null && fieldInfo.UseMeasureModule,
// isCumulateDrums, statType, stringFormat, out summaryDefinition, fValueStyle);
// fld.Label = fieldInfo == null ? colByObject.Item2.Caption : (object)colByObject.Item1;
// fields.Add(fld);
// if (summaryDefinition != null)
// {
// fieldLayout.SummaryDefinitions.Add(summaryDefinition);
// }
// }
// }
//}
else
{
var fieldInfo = colGroupByObject.Key;
var fieldGroupByObject = new FieldGroup
{
Label = fieldInfo.Id,
};
fieldLayout.FieldItems.Add(fieldGroupByObject);
//Группируем по ед.измерения
foreach (var colGroupByMeasureCategory in colGroupByObject.GroupBy(c => c.Item1.MeasureUnitUn.SubstringQuantityUn()))
{
var colGroupByMeasureCategoryList = colGroupByMeasureCategory.ToList();
if (!string.IsNullOrEmpty(colGroupByMeasureCategory.Key) && colGroupByMeasureCategoryList.Count > 1)
{
//Есть категории ед. измерения и их несколько
var fieldGroupByMeasureCategory = new FieldGroup
{
Label = new LabelMeasureQuantity
{
MeasureQuantityType_UN = colGroupByMeasureCategory.Key,
},
};
fieldGroupByObject.Children.Add(fieldGroupByMeasureCategory);
foreach (var colByMeasure in colGroupByMeasureCategoryList)
{
SummaryDefinition summaryDefinition;
var fld = AddFieldAndSummary(colByMeasure.Item2, widthValue, comparer, fieldInfo.UseMeasureModule,
isCumulateDrums, statType, stringFormat, out summaryDefinition, fValueStyle);
fld.Label = colByMeasure.Item1;
fieldGroupByMeasureCategory.Children.Add(fld);
if (summaryDefinition != null)
{
fieldLayout.SummaryDefinitions.Add(summaryDefinition);
}
}
}
else
{
var fielgGroupByReplacedTiDict = new Dictionary <string, FieldGroup>();
//Нет категорий, или она одна
foreach (var colByMeasure in colGroupByMeasureCategoryList)
{
if (colByMeasure.Item2.ColumnName.StartsWith("ovInfo"))
{
var hoc = new HierObjectsConverterComparer();
//var fld = AddField(colByMeasure.Item2, widthFreeHier, hoc, fieldInfo.UseMeasureModule,
// vFreeHierarchyObjectTemplate,
// vFreeHierarchyObjectTemplate, new HierObjectsConverter(), null);
var fld = new TemplateField
{
Name = colByMeasure.Item2.ColumnName,
DataType = colByMeasure.Item2.DataType,
Width = widthFreeHier,
AllowFixing = AllowFieldFixing.No,
DisplayTemplate = vFreeHierarchyObjectTemplate,
Settings =
{
AutoSizeOptions = FieldAutoSizeOptions.None,
Width = widthFreeHier,
SummaryUIType = SummaryUIType.MultiSelect,
FilterComparer = hoc,
FilterOperandUIType = FilterOperandUIType.Combo,
AllowRecordFiltering = true,
},
HorizontalContentAlignment = HorizontalAlignment.Stretch,
VerticalContentAlignment = VerticalAlignment.Stretch,
};
fld.Label = "Замещаемые ТИ";
fld.Settings.FilterOperandUIType = FilterOperandUIType.DropDownList;
fld.Settings.FilterLabelIconDropDownType = FilterLabelIconDropDownType.MultiSelectExcelStyle;
fld.Settings.GroupByComparer = hoc;
//fld.ValueToTextConverter = new HierObjectsConverter();
fld.Settings.FilterComparer = new HierObjectsConverterComparer();
fieldGroupByObject.Children.Add(fld);
}
else
{
FieldGroup fielgGroupByReplacedTi = null;
//Группируем по замещаемой ТИ
if (colByMeasure.Item2.ColumnName.StartsWith("ovValue") &&
!fielgGroupByReplacedTiDict.TryGetValue(
colByMeasure.Item1.GroupByReplacedTiName, out fielgGroupByReplacedTi))
{
fielgGroupByReplacedTi = new FieldGroup
{
Label = colByMeasure.Item1.ReplacedId,
};
fielgGroupByReplacedTiDict[colByMeasure.Item1.GroupByReplacedTiName] =
fielgGroupByReplacedTi;
}
SummaryDefinition summaryDefinition;
Field fld;
if (!string.IsNullOrEmpty(colByMeasure.Item1.MeasureUnitUn) && colByMeasure.Item1.MeasureUnitUn.IndexOf("RatioUnit") > -1)
{
//Это %, нужно усреднять
fld = AddFieldAndSummary(colByMeasure.Item2, widthValue, comparer, colByMeasure.Item1.UseMeasureModule,
isCumulateDrums, new FValueAvgCalculator(format), "Сред: {0:" + format + "}", out summaryDefinition, fValueNoBindMeasureStyle);
}
else
{
fld = AddFieldAndSummary(colByMeasure.Item2, widthValue, comparer, useBindedConverter && colByMeasure.Item1.UseMeasureModule,
isCumulateDrums, statType, stringFormat, out summaryDefinition, fValueStyle);
}
fld.Label = colByMeasure.Item1;
if (fielgGroupByReplacedTi != null)
{
fielgGroupByReplacedTi.Children.Add(fld);
}
else
{
fieldGroupByObject.Children.Add(fld);
}
if (summaryDefinition != null)
{
fieldLayout.SummaryDefinitions.Add(summaryDefinition);
}
if (colByMeasure.Item1.IsOv)
{
//Если это ОВ, добавляем суммарную информацию о неразнесенных значениях
var unWritedOvs = new FValueSummaryDefinition
{
SourceFieldName = colByMeasure.Item2.ColumnName,
Calculator = new FValueSumUnreplacedCalculator(format),
StringFormat = stringFormat,
UseMeasureModule = fieldInfo.UseMeasureModule,
};
fieldLayout.SummaryDefinitions.Add(unWritedOvs);
}
}
}
if (fielgGroupByReplacedTiDict.Count > 0)
{
fieldGroupByObject.Children.AddRange(fielgGroupByReplacedTiDict.Values);
}
}
}
}
}
if (isDateTimeGroupingGridControlXam)
{
//dtField.Settings.AllowSummaries = false;
dtField.Settings.AllowGroupBy = true;
fieldLayout.SortedFields.Add(new FieldSortDescription("EventDateTime", ListSortDirection.Ascending,
true));
}
else if (discreteType != enumTimeDiscreteType.DBMonth && discreteType != enumTimeDiscreteType.DB24Hour)
{
dtField.DisplayTemplate = Application.Current.Resources[ConstantHelper.DateTimeTemplateName] as DataTemplate;
}
//var consumptionScheduleField = fields.FirstOrDefault(ff => ff.Name == "ConsumptionSchedule");
//if (consumptionScheduleField != null)
//{
// consumptionScheduleField.Label = "Тип. потр.";
//}
//var consumptionSchedulePercentField = fields.FirstOrDefault(ff => ff.Name == "ConsumptionSchedulePercent");
//if (consumptionSchedulePercentField != null)
//{
// consumptionSchedulePercentField.Label = "Тип. потр. %";
//}
}
finally
{
// fieldLayout.SortedFields.EndUpdate();
fields.EndUpdate();
}
//XamDataGridHelper.ConfigureGrid(dataGrid, true, false, true, true, true);
dataGrid.FieldLayoutSettings.FixedFieldUIType = FixedFieldUIType.Splitter;
dataGrid.FieldSettings.SummaryDisplayArea = SummaryDisplayAreas.BottomFixed;
if (userTable.Columns.Count < 20)
{
//из-за того что тормоза ограничиваем
//dataGrid.FieldSettings.SummaryDisplayArea = dataGrid.FieldSettings.SummaryDisplayArea | SummaryDisplayAreas.InGroupByRecords;
}
if (userTable.Columns.Count < 1000)
{
dataGrid.RecordsInViewChanged += ExpandFirstRecord;
}
}
/// <summary>
/// Берем первую попавшуюся модель прогнозирования для объекта
/// </summary>
/// <param name="forecastObjectUn"></param>
/// <returns></returns>
public static List <TForecastCalculateParams> GetForecastObjectParams(HashSet <string> forecastObjectUns, DateTime dtStart, DateTime dtEnd,
int?forecastModelUserSelected, string timeZoneId, StringBuilder errors, EnumUnitDigit unitDigit, enumTimeDiscreteType forecastDiscreteType, bool isReadCalculatedValues)
{
var tis = new List <TI_ChanelType>();
var formulas = new List <TFormulaParam>();
var tps = new List <TP_ChanelType>();
var nodes = new List <long>();
var result = new Dictionary <string, TForecastCalculateParams>();
var periodsPriorityByForecastObject = new Dictionary <string, Dictionary <string, Queue <PeriodHierarchy> > >();
if (forecastObjectUns == null)
{
return(result.Values.ToList());
}
#region Читаем параметры объектов прогнозирования из базы
var forecastObjectUnsString = string.Join(",", forecastObjectUns);
try
{
using (var db = new LightDBDataContext(Settings.DbConnectionString)
{
ObjectTrackingEnabled = false, //Указываем что это у нас ReadOnly
DeferredLoadingEnabled = false,
CommandTimeout = 180,
})
{
var multiResult = db.usp2_ForecastObjectParams(forecastObjectUnsString, dtStart.ClientToServer(timeZoneId), dtEnd.ClientToServer(timeZoneId));
//Читаем доступные модели, которым будем считать
foreach (var modelsGroupByObject in multiResult.GetResult <usp2_ForecastObjectParamsResult1>().ToList().GroupBy(g => g.ForecastObject_UN))
{
result[modelsGroupByObject.Key] = new TForecastCalculateParams(modelsGroupByObject.Key, forecastModelUserSelected,
new HashSet <int>(modelsGroupByObject.Where(m => m.ForecastCalculateModel_ID.HasValue).OrderBy(m => m.Priority ?? 1000).Select(m => (int)(m.ForecastCalculateModel_ID ?? 0))));
}
#region Читаем ТИ, ТП формулы и т.д. для обсчета
foreach (var inputParamByObject in multiResult.GetResult <usp2_ForecastObjectParamsResult2>().ToList().GroupBy(g => g.ForecastObject_UN))
{
TForecastCalculateParams calculateParams;
if (!result.TryGetValue(inputParamByObject.Key, out calculateParams) || calculateParams == null)
{
continue;
}
calculateParams.DtStart = dtStart;
calculateParams.DtEnd = dtEnd;
calculateParams.DiscreteType = forecastDiscreteType;
var periodsByInputParam = new Dictionary <string, Queue <PeriodHierarchy> >();
periodsPriorityByForecastObject[inputParamByObject.Key] = periodsByInputParam;
foreach (var inputParam in inputParamByObject.GroupBy(g => g.ForecastInputParam_UN))
{
var periods = new Queue <PeriodHierarchy>();
periodsByInputParam[inputParam.Key] = periods;
var archiveByInputParam = new ForecastByInputParamArchives(inputParam.Key);
calculateParams.ArchivesByInputParam.Add(archiveByInputParam);
var isFirst = true;
foreach (var physicalParam in inputParam)
{
bool isFullPeriod;
var period = BuildHalfHoursPeriods(physicalParam, dtStart, dtEnd, timeZoneId, out isFullPeriod);
if (isFirst)
{
archiveByInputParam.MeasureQuantityType_UN = physicalParam.MeasureQuantityType_UN;
isFirst = false;
}
//Формула
if (!string.IsNullOrEmpty(physicalParam.Formula_UN))
{
var formulaParam = new TFormulaParam
{
FormulaID = physicalParam.Formula_UN,
FormulasTable = enumFormulasTable.Info_Formula_Description,
IsFormulaHasCorrectDescription = true,
};
formulas.Add(formulaParam);
//archiveByInputParam.Formulas.Add(formulaParam);
periods.Enqueue(new PeriodHierarchy
{
Id = new ID_Hierarchy_Channel(enumTypeHierarchy.Formula, physicalParam.Formula_UN, 0),
IsFullPeriod = isFullPeriod,
IndxStart = period.Item1,
IndxFinish = period.Item2,
});
if (isFullPeriod)
{
continue; //Объект действует на весь период, остальные объекты пропускаем
}
}
//OPC пока не используется, т.к. не понятно как приводить к получасовкам
if (physicalParam.UANode_ID.HasValue)
{
//archiveByInputParam.Nodes.Add(physicalParam.UANode_ID.Value);
nodes.Add(physicalParam.UANode_ID.Value);
periods.Enqueue(new PeriodHierarchy
{
Id = new ID_Hierarchy_Channel(enumTypeHierarchy.UANode, physicalParam.UANode_ID.Value.ToString(), 0),
IsFullPeriod = isFullPeriod,
IndxStart = period.Item1,
IndxFinish = period.Item2,
});
if (isFullPeriod)
{
continue; //Объект действует на весь период, остальные объекты пропускаем
}
}
//Для остальных нужен канал, если не указан пропускаем
//if (!inputParam.ChannelType.HasValue) continue;
//ТИ
if (physicalParam.TI_ID.HasValue)
{
if (!physicalParam.ChannelType.HasValue)
{
errors.Append("Для ТИ {").Append(physicalParam.TI_ID).Append("} нужно указать канал");
continue;
}
var tiId = new TI_ChanelType
{
ChannelType = physicalParam.ChannelType.Value,
TI_ID = physicalParam.TI_ID.Value,
MsTimeZone = timeZoneId, //Это возможно не нужно
};
//archiveByInputParam.TiIds.Add(tiId);
tis.Add(tiId);
periods.Enqueue(new PeriodHierarchy
{
Id = new ID_Hierarchy_Channel(enumTypeHierarchy.Info_TI, physicalParam.TI_ID.Value.ToString(), physicalParam.ChannelType.Value),
IsFullPeriod = isFullPeriod,
IndxStart = period.Item1,
IndxFinish = period.Item2,
});
if (isFullPeriod)
{
continue; //Объект действует на весь период, остальные объекты пропускаем
}
}
//ТП
if (physicalParam.TP_ID.HasValue)
{
if (!physicalParam.ChannelType.HasValue)
{
errors.Append("Для ТП {").Append(physicalParam.TP_ID).Append("} нужно указать канал");
continue;
}
var tpId = new TP_ChanelType
{
ChannelType = physicalParam.ChannelType.Value,
TP_ID = physicalParam.TP_ID.Value,
};
//archiveByInputParam.TpIds.Add(tpId);
tps.Add(tpId);
periods.Enqueue(new PeriodHierarchy
{
Id = new ID_Hierarchy_Channel(enumTypeHierarchy.Info_TP, physicalParam.TP_ID.Value.ToString(), physicalParam.ChannelType.Value),
IsFullPeriod = isFullPeriod,
IndxStart = period.Item1,
IndxFinish = period.Item2,
});
}
}
}
}
#endregion
}
}
catch (Exception ex)
{
errors.Append(ex.Message);
}
#endregion
#region Читаем архивы
//Пока запрашиваем только получасовки
var resultCommonTi = new ArchivesValues_List2(tis, dtStart, dtEnd,
true, false, enumTimeDiscreteType.DBHalfHours, enumTypeInformation.Energy, false,
unitDigit, enumOVMode.NormalMode, timeZoneId, isReadCalculatedValues: isReadCalculatedValues);
if (resultCommonTi.Errors != null)
{
errors.Append(resultCommonTi.Errors);
}
//Запрос значений всех ТП
var resultCommonTp = new ArchivesTPValues(tps, dtStart, dtEnd, enumBusRelation.PPI_OurSide, enumTimeDiscreteType.DBHalfHours, null, enumTypeInformation.Energy, unitDigit,
timeZoneId, false, isSupressTpNotFound: true, isReadCalculatedValues: isReadCalculatedValues);
if (resultCommonTp.Errors != null)
{
errors.Append(resultCommonTp.Errors);
}
//Все формулы
var resultCommonFormula = new FormulasResult(formulas, dtStart, dtEnd, enumTimeDiscreteType.DBHalfHours, null, 0, enumTypeInformation.Energy, unitDigit, timeZoneId, //Для описанных здесь формул ед. изм. не учитываем
true, false, false, false, isReadCalculatedValues: isReadCalculatedValues, ovMode: enumOVMode.NormalMode); //Для формулы сумму с ОВ считаем всегда!!!
if (resultCommonFormula.Errors != null)
{
errors.Append(resultCommonFormula.Errors);
}
//Чтение архивов OPC
UADataReader resultCommonUAData = null;
try
{
resultCommonUAData = new UADataReader(nodes, dtStart, dtEnd, false, false, false, timeZoneId);
}
catch
{ }
#endregion
#region Подготовка архивов
var numberHalfHoursForForecasting = MyListConverters.GetNumbersValuesInPeriod(enumTimeDiscreteType.DBHalfHours, dtStart, dtEnd, timeZoneId);
result.Values.AsParallel().ForAll(calculateParam => //AsParallel().ForAll()
{
//new TVALUES_DB[numberHalfHoursForForecasting].Select(v => new TVALUES_DB(VALUES_FLAG_DB.IsNull, 0)).ToList();
Dictionary <string, Queue <PeriodHierarchy> > periodsByInputParam;
if (!periodsPriorityByForecastObject.TryGetValue(calculateParam.ForecastObject_UN, out periodsByInputParam) || periodsByInputParam.Count == 0)
{
return; //Нет параметров для обсчета
}
foreach (var paramArchives in calculateParam.ArchivesByInputParam)
{
Queue <PeriodHierarchy> periods;
if (!periodsByInputParam.TryGetValue(paramArchives.ForecastInputParamUn, out periods) || periods.Count == 0)
{
continue; //Нет параметров для обсчета
}
//var period = periods.Dequeue(); //Первый объект в интервале
PeriodHierarchy period = null;
var halfHours = new List <TVALUES_DB>();
for (var hh = 0; hh < numberHalfHoursForForecasting; hh++)
{
if (!PeriodInHalfHour(ref period, periods, hh, resultCommonTi, resultCommonFormula,
resultCommonTp, resultCommonUAData) || period.Archives == null)
{
halfHours.Add(new Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB(VALUES_FLAG_DB.IsNull, 0)); //Получасовка не входит в наш диапазон, или нет архива
continue;
}
var aVal = period.Archives.ElementAtOrDefault(hh);
if (aVal == null)
{
aVal = new Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB(VALUES_FLAG_DB.IsNull, 0); //Непонятная ситуация, помечаем как отсутствующие
}
var cVal = halfHours.ElementAtOrDefault(hh);
if (cVal == null)
{
cVal = new Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB(aVal.F_FLAG, aVal.F_VALUE);
halfHours.Add(cVal);
}
else
{
cVal.F_VALUE = aVal.F_VALUE;
cVal.F_FLAG = aVal.F_FLAG;
}
}
paramArchives.Archives.AddRange(MyListConverters.ConvertHalfHoursToOtherList(forecastDiscreteType, halfHours,
dtStart, dtEnd, timeZoneId).Select(v => new Servers.Calculation.DBAccess.Interface.Data.TVALUES_DB(v.F_FLAG, v.F_VALUE)));
}
});
#endregion
return(result.Values.ToList());
}
