/// <summary>
/// Создать объект для расчета выходных значений
/// </summary>
protected override TaskCalculate createTaskCalculate(TaskCalculate.TYPE types
, IEnumerable <HandlerDbTaskCalculate.NALG_PARAMETER> listNAlg
, IEnumerable <HandlerDbTaskCalculate.PUT_PARAMETER> listPutPar
, Dictionary <KEY_VALUES, List <VALUE> > dictValues)
{
throw new NotImplementedException();
}
/// <summary>
/// Конструктор - основной (с параметром)
/// </summary>
public TaskAutobookMonthValuesCalculate(TaskCalculate.TYPE types
, IEnumerable <HandlerDbTaskCalculate.NALG_PARAMETER> listNAlg
, IEnumerable <HandlerDbTaskCalculate.PUT_PARAMETER> listPutPar
, Dictionary <KEY_VALUES, List <VALUE> > dictValues)
: base(types, listNAlg, listPutPar, dictValues)
{
}
///// <summary>
/////
///// </summary>
///// <returns></returns>
//public string GetQueryComp(TaskCalculate.TYPE type)
//{
// string strRes = string.Empty;
// strRes = @"SELECT a.[ID] as ID_ALG, p.[ID], p.[ID_COMP], cl.[DESCRIPTION], a.[N_ALG] "
// + @"FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a "
// + @"LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p "
// + @"ON a.ID = p.ID_ALG "
// + @"LEFT JOIN " + "[" + s_dictDbTables[ID_DBTABLE.COMP_LIST].m_name + @"] cl "
// + @"ON cl.ID = p.ID_COMP "
// + @"WHERE a.ID_TASK = " + (int)IdTask;
// return strRes;
//}
/// <summary>
/// Получение вых.знач.
/// </summary>
/// <param name="dtRange">диапазон временной</param>
/// <param name="err">Индентификатор ошибки</param>
/// <returns>таблица данных</returns>
public DataTable GetDataOutval(TaskCalculate.TYPE type, DateTimeRange[] dtRange, out int err)
{
string strQuery = string.Empty;
bool bLastItem = false;
for (int i = 0; i < dtRange.Length; i++)
{
bLastItem = !(i < (dtRange.Length - 1));
strQuery += @"SELECT o.ID, o.ID_PUT, o.ID_USER, o.ID_SOURCE, o.DATE_TIME, o.ID_TIME"
+ @", o.ID_TIMEZONE, o.QUALITY, o.VALUE, o.WR_DATETIME"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p"
+ @" ON a.ID = p.ID_ALG"
+ @" LEFT JOIN [dbo].[outval_" + dtRange[i].End.ToString(@"yyyyMM") + @"] o"
+ @" ON o.ID_PUT = p.ID"
+ @" WHERE [ID_TASK] = " + (int)IdTask
+ @" AND [DATE_TIME] > '" + dtRange[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] <= '" + dtRange[i].End.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [ID_TIMEZONE] = " + (int)_Session.CurrentIdTimezone
+ @" AND [ID_TIME] = " + (int)ID_PERIOD.DAY
+ @" AND [QUALITY] > 0";
if (bLastItem == false)
{
strQuery += @" UNION ALL ";
}
}
return(Select(strQuery, out err));
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private string getRangeAlg(TaskCalculate.TYPE type)
{
string strRes = string.Empty;
ID_START_RECORD idRecStart = ID_START_RECORD.ALG
, idRecEnd = ID_START_RECORD.PUT;
switch (type)
{
case TaskCalculate.TYPE.IN_VALUES:
break;
case TaskCalculate.TYPE.OUT_TEP_NORM_VALUES:
case TaskCalculate.TYPE.OUT_VALUES:
idRecStart = type == TaskCalculate.TYPE.OUT_TEP_NORM_VALUES ? ID_START_RECORD.ALG_NORMATIVE :
type == TaskCalculate.TYPE.OUT_VALUES ? ID_START_RECORD.ALG :
ID_START_RECORD.ALG;
idRecEnd = type == TaskCalculate.TYPE.OUT_TEP_NORM_VALUES ? ID_START_RECORD.PUT :
type == TaskCalculate.TYPE.OUT_VALUES ? ID_START_RECORD.ALG_NORMATIVE :
ID_START_RECORD.PUT;
strRes = @" BETWEEN " + (int)(idRecStart - 1) + @" AND " + (int)(idRecEnd - 1);
break;
default:
break;
}
return(strRes);
}
/// <summary>
/// Получение плановых значений
/// </summary>
/// <param name="type"></param>
/// <param name="arQueryRanges">отрезок времени</param>
/// <param name="idPeriod">период времени</param>
/// <param name="err"></param>
/// <returns>таблица значений</returns>
public DataTable getPlanOnMonth(TaskCalculate.TYPE type
, DateTimeRange[] arQueryRanges
, ID_PERIOD idPeriod, out int err)
{
string strQuery = string.Empty;
for (int i = 0; i < arQueryRanges.Length; i++)
{
strQuery = "SELECT p.ID as ID_PUT"
+ @", " + _Session.m_Id + @" as [ID_SESSION]"
+ @", v.QUALITY as QUALITY, v.VALUE as VALUE"
+ @",v.DATE_TIME as WR_DATETIME, ROW_NUMBER() OVER(ORDER BY p.ID) as [EXTENDED_DEFINITION] "
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p"
+ @" ON a.ID = p.ID_ALG"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @"_"
+ arQueryRanges[i].Begin.ToString(@"yyyyMM") + @"] v "
+ @" ON v.ID_PUT = p.ID"
+ @" WHERE ID_TASK = " + (int)IdTask
+ @" AND [DATE_TIME] >= '" + arQueryRanges[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] < '" + arQueryRanges[i].End.AddMonths(1).ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND v.ID_TIME = 24";
}
return(Select(strQuery, out err));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public string GetQueryComp(TaskCalculate.TYPE type)
{
string strRes = string.Empty;
//strRes = @"SELECT a.[ID] as ID_ALG, p.[ID], p.[ID_COMP], cl.[DESCRIPTION], a.[N_ALG] , m.NAME_RU as NAME_SHR_MEASURE, m.[AVG] "
//+ @"FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a "
//+ @"LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p "
//+ @"ON a.ID = p.ID_ALG "
//+ @"LEFT JOIN " + "[" + s_NameDbTables[(int)INDEX_DBTABLE_NAME.COMP_LIST] + @"] cl "
//+ @"ON cl.ID = p.ID_COMP "
//+ @"JOIN [dbo].[measure] as m "
//+ @"ON a.ID_MEASURE = m.ID "
//+ @"WHERE a.ID_TASK = " + (int)IdTask;
//return strRes;
//string strRes = string.Empty;
strRes = @"SELECT l.[ID] , l.[ID_COMP], l.[DESCRIPTION] "
+ @"FROM [" + s_NameDbTables[(int)INDEX_DBTABLE_NAME.COMP_LIST] + @"] l "
+ @"LEFT JOIN [TEP_NTEC_5].[dbo].[comp] c "
+ @"ON c.ID = l.ID_COMP "
+ @"WHERE c.ID > 500 AND c.ID < 20000";
return(strRes);
}
/// <summary>
/// Получение вых.знач.
/// </summary>
/// <param name="dtRange">диапазон временной</param>
/// <param name="err">Индентификатор ошибки</param>
/// <returns>таблица данных</returns>
public DataTable GetDataOutvalArch(TaskCalculate.TYPE type, DateTimeRange[] dtRange, out int err)
{
string strQuery = string.Empty;
bool bLastItem = false;
for (int i = 0; i < dtRange.Length; i++)
{
bLastItem = !(i < (dtRange.Length - 1));
strQuery += @"SELECT [ID_PUT], [QUALITY], [VALUE], [DATE_TIME] as [WR_DATETIME]"
+ @" , CONVERT(varchar, [DATE_TIME], 127) as [EXTENDED_DEFINITION]"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p"
+ @" ON a.ID = p.ID_ALG"
+ @" LEFT JOIN [dbo].[outval_" + dtRange[i].End.ToString(@"yyyyMM") + @"] o"
+ @" ON o.ID_PUT = p.ID"
+ @" WHERE [ID_TASK] = " + (int)IdTask
+ @" AND [DATE_TIME] > '" + dtRange[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] <= '" + dtRange[i].End.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [ID_TIMEZONE] = " + (int)_Session.m_currIdTimezone
+ @" AND [ID_TIME] = " + (int)ID_PERIOD.DAY
+ @" AND [QUALITY] > 0";
if (bLastItem == false)
{
strQuery += @" UNION ALL ";
}
}
return(Select(strQuery, out err));
}
/// <summary>
/// Возвратить строку запроса для получения
/// </summary>
/// <param name="idSession">Идентификатор сессии</param>
/// <param name="type">Тип значений (входные, выходные-нормативы - только для ТЭП, выходные)</param>
/// <returns>Строка - содержание запроса</returns>
private string getQueryValuesVar(TaskCalculate.TYPE type)
{
string strRes = string.Empty
, strJoinValues = string.Empty;
if (!(type == TaskCalculate.TYPE.UNKNOWN))
{
strJoinValues = getRangeAlg(type);
if (strJoinValues.Equals(string.Empty) == false)
{
strJoinValues = @" JOIN [" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + @"] p ON p.ID = v.ID_PUT AND p.ID_ALG" + strJoinValues;
}
else
{
;
}
strRes = @"SELECT v.* FROM " + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @" as v"
+ strJoinValues
+ @" WHERE [ID_SESSION]=" + _Session.m_Id;
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::getQueryValuesVar () - неизвестный тип расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
return(strRes);
}
/// <summary>
/// Создать объект для расчета выходных значений
/// </summary>
protected override TaskCalculate createTaskCalculate(TaskCalculate.TYPE types
, IEnumerable <HandlerDbTaskCalculate.NALG_PARAMETER> listNAlg
, IEnumerable <HandlerDbTaskCalculate.PUT_PARAMETER> listPutPar
, Dictionary <KEY_VALUES, List <VALUE> > dictValues)
{
return(new TaskVedomostBlCalculate(types, listNAlg, listPutPar, dictValues));
}
/// <summary>
/// Получение корр. входных значений
/// из INVAL
/// </summary>
/// <param name="type">тип задачи</param>
/// <param name="arQueryRanges"></param>
/// <param name="idPeriod">тек. период</param>
/// <param name="err">Индентификатор ошибки</param>
/// <returns>таблица значений</returns>
public DataTable GetInVal(TaskCalculate.TYPE type
, DateTimeRange[] arQueryRanges
, ID_PERIOD idPeriod
, out int err)
{
string strQuery = string.Empty;
bool bLastItem = false;
for (int i = 0; i < arQueryRanges.Length; i++)
{
bLastItem = !(i < (arQueryRanges.Length - 1));
strQuery += @"SELECT v.ID, v.ID_PUT, v.ID_USER, v.ID_SOURCE, v.DATE_TIME, v.ID_TIME"
+ ", v.ID_TIMEZONE, v.QUALITY, v.VALUE, v.WR_DATETIME"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p"
+ @" ON a.ID = p.ID_ALG"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @"_"
+ arQueryRanges[i].End.ToString(@"yyyyMM") + @"] v"
+ @" ON v.ID_PUT = p.ID"
+ @" WHERE ID_TASK = " + (int)IdTask
+ @" AND [DATE_TIME] > '" + arQueryRanges[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] <= '" + arQueryRanges[i].End.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND v.ID_TIME = " + (int)idPeriod
+ @" AND ID_TIMEZONE = " + (int)_Session.m_currIdTimezone;
if (bLastItem == false)
{
strQuery += @" UNION ALL ";
}
}
strQuery += @" ORDER BY [DATE_TIME] ";
return(Select(strQuery, out err));
}
/// <summary>
/// Возвратить наименование таблицы
/// </summary>
/// <param name="type">Тип панели/расчета</param>
/// <param name="req">Индекс таблицы, требуемой при расчете</param>
/// <returns>Наименование таблицы</returns>
private static string getNameDbTable(TaskCalculate.TYPE type, TABLE_CALCULATE_REQUIRED req)
{
INDEX_DBTABLE_NAME indx = INDEX_DBTABLE_NAME.UNKNOWN;
indx = TaskCalculate.GetIndexNameDbTable(type, req);
return(s_NameDbTables[(int)indx]);
}
/// <summary>
/// Формирование запроса на получение компонентов
/// </summary>
/// <returns>строка запроса</returns>
public string GetQueryComp(TaskCalculate.TYPE type)
{
string strRes = string.Empty;
strRes = @"SELECT l.[ID] , l.[ID_COMP], l.[DESCRIPTION] "
+ @"FROM [" + s_NameDbTables[(int)INDEX_DBTABLE_NAME.COMP_LIST] + @"] l "
+ @"LEFT JOIN [comp] c "
+ @"ON c.ID = l.ID_COMP "
+ @"WHERE c.ID > 500 AND c.ID < 2000";
return(strRes);
}
protected override DataTable getArchiveTableValues(TaskCalculate.TYPE type
, ID_PERIOD idPeriod
, int cntBasePeriod
, ASUTP.Core.DateTimeRange [] arQueryRanges
, out int err)
{
err = 0;
DataTable tableRes = base.getArchiveTableValues(type, idPeriod, cntBasePeriod, arQueryRanges, out err);
return(tableRes);
}
/// <summary>
/// Возвратить объект-таблицу со значениями из таблицы с временными для расчета
/// </summary>
/// <param name="type">Тип значений (входные, выходные)</param>
/// <param name="err">Признак выполнения функции</param>
/// <returns>Объект-таблица</returns>
public DataTable GetValuesVar(TaskCalculate.TYPE type
, out int err)
{
DataTable tableRes = new DataTable();
err = -1;
tableRes = DbTSQLInterface.Select(ref _dbConnection
, getQueryValuesVar(type)
, null, null
, out err);
return(tableRes);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public string GetQueryComp(TaskCalculate.TYPE type)
{
string strRes = string.Empty;
strRes = @"SELECT a.[ID] as ID_ALG, p.[ID], p.[ID_COMP], cl.[DESCRIPTION], a.[N_ALG] "
+ @"FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a "
+ @"LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p "
+ @"ON a.ID = p.ID_ALG "
+ @"LEFT JOIN " + "[" + s_NameDbTables[(int)INDEX_DBTABLE_NAME.COMP_LIST] + @"] cl "
+ @"ON cl.ID = p.ID_COMP "
+ @"WHERE a.ID_TASK = " + (int)IdTask;
return(strRes);
}
/// <summary>
/// Расчитать выходные-нормативные значения для задачи "Расчет ТЭП"
/// , сохранить значения во временной таблице для возможности предварительного просмотра результата
/// </summary>
public void Calculate(TaskCalculate.TYPE type)
{
int err = -1
, iRegDbConn = -1;
// регистрация соединения с БД
RegisterDbConnection(out iRegDbConn);
if (!(iRegDbConn < 0))
{
switch (IdTask)
{
case ID_TASK.TEP:
case ID_TASK.AUTOBOOK:
case ID_TASK.BAL_TEPLO: //Для работы с балансом тепла 6,06,2016 Апельганс
calculate(type, out err);
if (!(err == 0))
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - ошибка при выполнеии расчета задачи ID=" + IdTask.ToString() + @" ...", Logging.INDEX_MESSAGE.NOT_SET);
}
else
{
;
}
break;
default:
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - неизвестный тип задачи расчета...", Logging.INDEX_MESSAGE.NOT_SET);
break;
}
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - при регистрации соединения...", Logging.INDEX_MESSAGE.NOT_SET);
}
// отмена регистрации БД - только, если регистрация произведена в текущем контексте
if (!(iRegDbConn > 0))
{
UnRegisterDbConnection();
}
else
{
;
}
}
/// <summary>
/// Строка - условие для TSQL-запроса для указания диапазона идентификаторов
/// выходных параметров алгоритма расчета
/// </summary>
private string getWhereRangeAlg(TaskCalculate.TYPE type, string strNameFieldId = @"ID")
{
string strRes = string.Empty;
switch (type)
{
case TaskCalculate.TYPE.IN_VALUES:
break;
case TaskCalculate.TYPE.OUT_TEP_NORM_VALUES:
case TaskCalculate.TYPE.OUT_VALUES:
strRes = @"[" + strNameFieldId + @"]" + getRangeAlg(type);
break;
default:
break;
}
return(strRes);
}
/// <summary>
/// Возвратить объект-таблицу со значениями из таблицы с сохраняемыми значениями из источников информации
/// </summary>
/// <param name="cntBasePeriod">Количество периодов расчета в интервале запрашиваемых данных</param>
/// <param name="arQueryRanges">Массив диапазонов даты/времени - интервал(ы) заправшиваемых данных</param>
/// <param name="err">Признак выполнения функции</param>
/// <returns>Таблица со значенями</returns>
public DataTable GetValuesVar(TaskCalculate.TYPE type
, ID_PERIOD idPeriod
, int cntBasePeriod
, DateTimeRange[] arQueryRanges
, out int err)
{
DataTable tableRes = new DataTable();
err = -1;
tableRes = DbTSQLInterface.Select(ref _dbConnection
, getQueryValuesVar(type
, idPeriod
, cntBasePeriod
, arQueryRanges)
, null, null
, out err);
return(tableRes);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public virtual string GetQueryParameters(TaskCalculate.TYPE type /* = TaskCalculate.TYPE.UNKNOWN*/)
{
string strRes = string.Empty
, whereParameters = string.Empty;
//if (type == TaskCalculate.TYPE.UNKNOWN)
// type = m_taskCalculate.Type;
//else
// ;
if (!(type == TaskCalculate.TYPE.UNKNOWN))
{
// аналог в 'getQueryValuesVar'
whereParameters = getWhereRangeAlg(type);
if (whereParameters.Equals(string.Empty) == false)
{
whereParameters = @" AND a." + whereParameters;
}
else
{
;
}
strRes = @"SELECT p.ID, p.ID_ALG, p.ID_COMP, p.ID_RATIO, p.MINVALUE, p.MAXVALUE"
+ @", a.NAME_SHR, a.N_ALG, a.DESCRIPTION, a.ID_MEASURE, a.SYMBOL"
+ @", m.NAME_RU as NAME_SHR_MEASURE, m.[AVG]"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + @"] as p"
+ @" JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + @"] as a ON a.ID = p.ID_ALG AND a.ID_TASK = " + (int)IdTask
+ whereParameters
+ @" JOIN [dbo].[" + s_NameDbTables[(int)INDEX_DBTABLE_NAME.MEASURE] + @"] as m ON a.ID_MEASURE = m.ID ORDER BY ID";
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::GetQueryParameters () - неизвестный тип расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
return(strRes);
}
/// <summary>
/// Получение корр. PUT's
/// </summary>
/// <param name="type"></param>
/// <param name="arQueryRanges"></param>
/// <param name="idPeriod">период</param>
/// <param name="err"></param>
/// <returns></returns>
public DataTable getInPut(TaskCalculate.TYPE type
, DateTimeRange[] arQueryRanges
, ID_PERIOD idPeriod
, out int err)
{
string strQuery = string.Empty;
for (int i = 0; i < arQueryRanges.Length; i++)
{
strQuery += @"SELECT DISTINCT v.ID,v.ID_PUT, v.ID_USER, v.ID_SOURCE,v.DATE_TIME, v.ID_TIME"
+ ", v.ID_TIMEZONE,v.QUALITY,v.VALUE,v.WR_DATETIME"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + "] a"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + "] p"
+ @" ON a.ID = p.ID_ALG"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @"_"
+ arQueryRanges[i].Begin.ToString(@"yyyyMM") + @"] v "
+ @" ON v.ID_PUT = p.ID"
+ @" WHERE ID_TASK = " + (int)IdTask
+ @" AND v.ID_TIME = " + (int)idPeriod + " AND v.ID_SOURCE = 0"
+ @" ORDER BY ID";
}
return(Select(strQuery, out err));
}
public override DataTable GetImportTableValues(TaskCalculate.TYPE type, long idSession, DataTable tableInParameter, DataTable tableRatio, out int err)
{
throw new NotImplementedException();
}
/// <summary>
/// Запрос к БД по получению редактируемых значений (автоматически собираемые значения)
/// , структура таблицы совместима с [inval], [outval]
/// </summary>
/// <param name="type">тип задачи</param>
/// <param name="idPeriod">период</param>
/// <param name="cntBasePeriod">период(день,месяц,год)</param>
/// <param name="arQueryRanges">диапазон времени запроса</param>
/// <returns>строка запроса</returns>
public override string GetQueryValuesVar(TaskCalculate.TYPE type, ID_PERIOD idPeriod
, int cntBasePeriod, DateTimeRange[] arQueryRanges)
{
string strRes = string.Empty
, whereParameters = string.Empty;
if (!(type == TaskCalculate.TYPE.UNKNOWN))
{
// аналог в 'GetQueryParameters'
//whereParameters = getWhereRangeAlg(type);
//if (whereParameters.Equals(string.Empty) == false)
// whereParameters = @" AND a." + whereParameters;
//else
// ;
int i = -1;
bool bLastItem = false
, bEquDatetime = false;
for (i = 0; i < arQueryRanges.Length; i++)
{
bLastItem = !(i < (arQueryRanges.Length - 1));
strRes += @"SELECT v.ID_PUT, v.QUALITY, v.[VALUE]"
+ @", " + _Session.m_Id + @" as [ID_SESSION]"
+ @", [DATE_TIME]"
+ @", CONVERT(varchar, [DATE_TIME], 127) as [EXTENDED_DEFINITION] "
+ @"FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + @"] a "
+ @"LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + @"] p "
+ @"ON a.ID = p.ID_ALG AND a.ID_TASK = " + (int)IdTask + " "
+ @"LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @"_"
+ arQueryRanges[i].End.ToString(@"yyyyMM") + @"] v "
+ @"ON p.ID = v.ID_PUT "
+ @"WHERE v.[ID_TIME] = " + (int)idPeriod //+ " AND [ID_SOURCE] > 0 "
+ @" AND ID_TIMEZONE = " + (int)_Session.m_currIdTimezone
;
// при попадании даты/времени на границу перехода между отчетными периодами (месяц)
// 'Begin' == 'End'
if (bLastItem == true)
{
bEquDatetime = arQueryRanges[i].Begin.Equals(arQueryRanges[i].End);
}
if (bEquDatetime == false)
{
strRes += @" AND [DATE_TIME] > '" + arQueryRanges[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] <= '" + arQueryRanges[i].End.ToString(@"yyyyMMdd HH:mm:ss") + @"'";
}
if (bLastItem == false)
{
strRes += @" UNION ALL ";
}
}
strRes = "" + @"SELECT v.ID_PUT"
+ @", " + _Session.m_Id + @" as [ID_SESSION]"
+ @", [QUALITY]"
+ @", [VALUE]"
+ @", [DATE_TIME] as [WR_DATETIME]"
+ @", [EXTENDED_DEFINITION] "
+ @"FROM (" + strRes + @") as v "
+ @"ORDER BY v.ID_PUT,v.DATE_TIME";
}
else
{
Logging.Logg().Error(@"TepCommon.HandlerDbTaskCalculate::getQueryValuesVar () - неизветстный тип расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
return(strRes);
}
protected override TaskCalculate.ListDATATABLE prepareCalculateValues(TaskCalculate.TYPE type, out int err)
{
throw new NotImplementedException();
}
protected abstract void calculate(TaskCalculate.TYPE type, out int err);
/// <summary>
/// Подготовить таблицы для проведения расчета
/// </summary>
/// <param name="err">Признак ошибки при выполнении функции</param>
/// <returns>Массив таблиц со значенями для расчета</returns>
private TaskTepCalculate.ListDATATABLE prepareTepCalculateValues(TaskCalculate.TYPE type, out int err)
{
TaskTepCalculate.ListDATATABLE listRes = new TaskTepCalculate.ListDATATABLE();
err = -1;
//long idSession = -1;
DataTable tableVal = null;
if (isRegisterDbConnection == true)
{
// проверить наличие сессии
if (_Session.m_Id > 0)
{
// получить таблицу со значеняими нормативных графиков
tableVal = GetDataTable(INDEX_DBTABLE_NAME.FTABLE, out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.FTABLE, m_table = tableVal.Copy()
});
// получить описание входных парметров в алгоритме расчета
tableVal = Select(GetQueryParameters(TaskCalculate.TYPE.IN_VALUES), out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.IN_PARAMETER, m_table = tableVal.Copy()
});
// получить входные значения для сессии
tableVal = GetValuesVar(TaskCalculate.TYPE.IN_VALUES, out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.IN_VALUES, m_table = tableVal.Copy()
});
if (IdTask == ID_TASK.TEP)
{
// получить описание выходных-нормативных парметров в алгоритме расчета
tableVal = Select(GetQueryParameters(TaskCalculate.TYPE.OUT_TEP_NORM_VALUES), out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.OUT_NORM_PARAMETER, m_table = tableVal.Copy()
});
// получить выходные-нормативные значения для сессии
tableVal = GetValuesVar(TaskCalculate.TYPE.OUT_TEP_NORM_VALUES, out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.OUT_NORM_VALUES, m_table = tableVal.Copy()
});
}
else
{
;
}
if (type == TaskCalculate.TYPE.OUT_VALUES)
{// дополнительно получить описание выходных-нормативных параметров в алгоритме расчета
tableVal = Select(GetQueryParameters(TaskCalculate.TYPE.OUT_VALUES), out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.OUT_PARAMETER, m_table = tableVal.Copy()
});
// получить выходные значения для сессии
tableVal = GetValuesVar(TaskCalculate.TYPE.OUT_VALUES, out err);
listRes.Add(new TaskTepCalculate.DATATABLE()
{
m_indx = TaskTepCalculate.INDEX_DATATABLE.OUT_VALUES, m_table = tableVal.Copy()
});
}
else
{
;
}
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::prepareTepCalculateValues () - при получении идентифкатора сессии расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
}
else
{
; // ошибка при регистрации соединения с БД
}
return(listRes);
}
protected override void calculate(TaskCalculate.TYPE type, out int err)
{
err = 0;
}
/// <summary>
/// Расчитать выходные-нормативные значения для задачи "Расчет ТЭП"
/// , сохранить значения во временной таблице для возможности предварительного просмотра результата
/// </summary>
public void Calculate(TaskCalculate.TYPE type)
{
int err = -1
, iRegDbConn = -1;
DataTable tableOrigin = null
, tableCalcRes = null;
TaskTepCalculate.ListDATATABLE listDataTables = null;
// регистрация соединения с БД
RegisterDbConnection(out iRegDbConn);
if (!(iRegDbConn < 0))
{
switch (IdTask)
{
case ID_TASK.TEP:
// подготовить таблицы для расчета
listDataTables = prepareTepCalculateValues(type, out err);
if (err == 0)
{
// произвести вычисления
switch (type)
{
case TaskCalculate.TYPE.OUT_TEP_NORM_VALUES:
tableOrigin = listDataTables.FindDataTable(TaskCalculate.INDEX_DATATABLE.OUT_NORM_VALUES);
tableCalcRes = (m_taskCalculate as TaskTepCalculate).CalculateNormative(listDataTables);
break;
case TaskCalculate.TYPE.OUT_VALUES:
tableCalcRes = (m_taskCalculate as TaskTepCalculate).CalculateMaket(listDataTables);
break;
default:
break;
}
// сохранить результаты вычисления
saveResult(tableOrigin, tableCalcRes, out err);
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - при подготовке данных для расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
break;
default:
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - неизвестный тип задачи расчета...", Logging.INDEX_MESSAGE.NOT_SET);
break;
case ID_TASK.AUTOBOOK:
break;
}
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::Calculate () - при регистрации соединения...", Logging.INDEX_MESSAGE.NOT_SET);
}
// отмена регистрации БД - только, если регистрация произведена в текущем контексте
if (!(iRegDbConn > 0))
{
UnRegisterDbConnection();
}
else
{
;
}
}
/// <summary>
/// Вставить значения в таблицу для временных выходных значений сессии расчета
/// </summary>
/// <param name="idSession">Идентификатор сессии расчета</param>
/// <param name="typeCalc">Тип расчета</param>
/// <param name="err">Идентификатор ошибки при выполнении функции</param>
private void insertOutValues(long idSession, TaskCalculate.TYPE typeCalc, out int err)
{
err = -1;
DataTable tableParameters = null;
string strBaseQuery = string.Empty
, strQuery = string.Empty;
int iRowCounterToInsert = -1;
strQuery = GetQueryParameters(typeCalc);
tableParameters = Select(strQuery, out err);
strBaseQuery =
strQuery =
@"INSERT INTO " + s_NameDbTables[(int)INDEX_DBTABLE_NAME.OUTVALUES] + @" VALUES ";
iRowCounterToInsert = 0;
foreach (DataRow rPar in tableParameters.Rows)
{
if (iRowCounterToInsert > MAX_ROWCOUNT_TO_INSERT)
{
// исключить лишнюю запятую
strQuery = strQuery.Substring(0, strQuery.Length - 1);
// вставить строки в таблицу
DbTSQLInterface.ExecNonQuery(ref _dbConnection, strQuery, null, null, out err);
if (!(err == 0))
{
// при ошибке - не продолжать
break;
}
else
{
;
}
strQuery = strBaseQuery;
iRowCounterToInsert = 0;
}
else
{
;
}
strQuery += @"(";
strQuery += idSession + @"," //ID_SEESION
+ rPar[@"ID"] + @"," //ID_PUT
+ 0.ToString() + @"," //QUALITY
+ 0.ToString() + @"," //VALUE
+ @"GETDATE()"
;
strQuery += @"),";
iRowCounterToInsert++;
}
if (err == 0)
{
// исключить лишнюю запятую
strQuery = strQuery.Substring(0, strQuery.Length - 1);
// вставить строки в таблицу
DbTSQLInterface.ExecNonQuery(ref _dbConnection, strQuery, null, null, out err);
}
else
{
; // при ошибке - не продолжать
}
}
/// <summary>
/// Возвратить объект-таблицу со значениями из таблицы с сохраняемыми значениями из источников информации
/// + для текущей задачи "растиражировать" плановые значения за месяц
/// </summary>
/// <param name="idPeriod">Идентификатор расчета (HOUR, DAY, MONTH, YEAR)</param>
/// <param name="cntBasePeriod">Количество периодов расчета в интервале запрашиваемых данных</param>
/// <param name="arQueryRanges">Массив диапазонов даты/времени - интервал(ы) запрашиваемых данных</param>
/// <param name="err">Признак выполнения функции</param>
/// <returns>Таблица со значениями</returns>
protected override DataTable getVariableTableValues(TaskCalculate.TYPE type
, ID_PERIOD idPeriod
, int cntBasePeriod
, ASUTP.Core.DateTimeRange [] arQueryRanges
, out int err)
{
DataTable tableRes = new DataTable()
, tableMonthPlan;
int iDay = -1
, periodTotalDays = -1
, iColumnDataDate = -1;
DateTime datetimeValue = DateTime.MinValue;
object[] rowValues;
double dayPlan = -1F;
ASUTP.Core.DateTimeRange [] arMonthPlanQueryRanges;
err = -1;
tableRes = base.getVariableTableValues(type, idPeriod, cntBasePeriod, arQueryRanges, out err);
// дополнительно прочитаем плановые значения (план выработки - входной параметр)
if ((type & TaskCalculate.TYPE.IN_VALUES) == TaskCalculate.TYPE.IN_VALUES)
{
// для плана выработки индивидуальный диапазон даты/времени
arMonthPlanQueryRanges = HandlerDbTaskCalculate.GetDateTimeRangeVariableValues(ID_PERIOD.MONTH, _Session.m_DatetimeRange, _Session.m_curOffsetUTC, MODE_DATA_DATETIME.Ended);
// для плана выработки индивидуальный запрос значений
tableMonthPlan = Select(HandlerDbTaskCalculate.GetQueryVariableValues(IdTask
, _Session.m_Id
, type
, ID_PERIOD.MONTH
, 1
, arMonthPlanQueryRanges
, getWhereRangeAlg(type)
, MODE_AGREGATE_GETVALUES.OFF
, MODE_DATA_DATETIME.Ended)
, out err);
if (tableMonthPlan.Rows.Count == 1)
{
periodTotalDays = (int)(_Session.m_DatetimeRange.End - _Session.m_DatetimeRange.Begin).TotalDays;
dayPlan = (double)tableMonthPlan.Rows[0][@"VALUE"] / periodTotalDays;
rowValues = new object[tableMonthPlan.Columns.Count];
foreach (DataColumn column in tableMonthPlan.Columns)
{
if (column.ColumnName.Equals(@"VALUE") == true)
{
rowValues[column.Ordinal] = dayPlan;
}
else
{
if (column.ColumnName.Equals(@"EXTENDED_DEFINITION") == true)
{
iColumnDataDate = column.Ordinal;
if (DateTime.TryParse((string)tableMonthPlan.Rows[0][column.Ordinal], out datetimeValue) == true)
{
////??? в запросе добавляется период(месяц)
//datetimeValue = datetimeValue.AddMonths(-1)
;
}
else
{
Logging.Logg().Error(string.Format(@"HandlerDbTaskAutobookMonthValuesCalculate::getVariableTableValues () - не распознано значение в {0}...", column.ColumnName), Logging.INDEX_MESSAGE.NOT_SET);
}
}
else
{
;
}
rowValues[column.Ordinal] = tableMonthPlan.Rows[0][column.Ordinal];
}
}
if (datetimeValue.Equals(DateTime.MinValue) == false)
{
for (iDay = 0; iDay < periodTotalDays; iDay++)
{
rowValues[iColumnDataDate] = string.Format(@"{0:s}", datetimeValue.AddDays(-1 * iDay));
tableRes.Rows.Add(rowValues);
}
tableRes.AcceptChanges();
}
else
{
Logging.Logg().Error(string.Format(@"HandlerDbTaskAutobookMonthValuesCalculate::getVariableTableValues () - не удалось преобразовать метку даты/времени {0} планового значения"
, tableMonthPlan.Rows[0][iColumnDataDate])
, Logging.INDEX_MESSAGE.NOT_SET);
}
}
else
{
Logging.Logg().Error(string.Format(@"HandlerDbTaskAutobookMonthValuesCalculate::getVariableTableValues () - нет плановых значений за {0:s} - {1:s}"
, _Session.m_DatetimeRange.Begin, _Session.m_DatetimeRange.End)
, Logging.INDEX_MESSAGE.NOT_SET);
}
}
else
{
// план только во входных значениях, в выходных его нет
;
}
return(tableRes);
}
/// <summary>
/// Запрос к БД по получению редактируемых значений (автоматически собираемые значения)
/// , структура таблицы совместима с [inval], [outval]
/// </summary>
public virtual string getQueryValuesVar(TaskCalculate.TYPE type
, ID_PERIOD idPeriod
, int cntBasePeriod
, DateTimeRange[] arQueryRanges)
{
string strRes = string.Empty
, whereParameters = string.Empty;
if (!(type == TaskCalculate.TYPE.UNKNOWN))
{
// аналог в 'GetQueryParameters'
whereParameters = getWhereRangeAlg(type);
if (whereParameters.Equals(string.Empty) == false)
{
whereParameters = @" AND a." + whereParameters;
}
else
{
;
}
int i = -1;
bool bLastItem = false
, bEquDatetime = false;
for (i = 0; i < arQueryRanges.Length; i++)
{
bLastItem = !(i < (arQueryRanges.Length - 1));
strRes += @"SELECT v.ID_PUT, v.QUALITY, v.[VALUE]"
+ @", " + _Session.m_Id + @" as [ID_SESSION]"
+ @", m.[AVG]"
//+ @", GETDATE () as [WR_DATETIME]"
+ @" FROM [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.VALUE) + @"_" + arQueryRanges[i].Begin.ToString(@"yyyyMM") + @"] v"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.PUT) + @"] p ON p.ID = v.ID_PUT"
+ @" LEFT JOIN [dbo].[" + getNameDbTable(type, TABLE_CALCULATE_REQUIRED.ALG) + @"] a ON a.ID = p.ID_ALG AND a.ID_TASK = " + (int)_iIdTask + whereParameters
+ @" LEFT JOIN [dbo].[measure] m ON a.ID_MEASURE = m.ID"
+ @" WHERE v.[ID_TIME] = " + (int)idPeriod //???ID_PERIOD.HOUR //??? _currIdPeriod
;
// при попадании даты/времени на границу перехода между отчетными периодами (месяц)
// 'Begin' == 'End'
if (bLastItem == true)
{
bEquDatetime = arQueryRanges[i].Begin.Equals(arQueryRanges[i].End);
}
else
{
;
}
if (bEquDatetime == false)
{
strRes += @" AND [DATE_TIME] > '" + arQueryRanges[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'"
+ @" AND [DATE_TIME] <= '" + arQueryRanges[i].End.ToString(@"yyyyMMdd HH:mm:ss") + @"'";
}
else
{
strRes += @" AND [DATE_TIME] = '" + arQueryRanges[i].Begin.ToString(@"yyyyMMdd HH:mm:ss") + @"'";
}
if (bLastItem == false)
{
strRes += @" UNION ALL ";
}
else
{
;
}
}
strRes = @"SELECT v.ID_PUT" // as [ID]"
+ @", " + _Session.m_Id + @" as [ID_SESSION]"
+ @", CASE"
+ @" WHEN COUNT (*) = " + cntBasePeriod + @" THEN MIN(v.[QUALITY])"
+ @" WHEN COUNT (*) = 0 THEN " + (int)ID_QUALITY_VALUE.NOT_REC
+ @" ELSE " + (int)ID_QUALITY_VALUE.PARTIAL
+ @" END as [QUALITY]"
+ @", CASE"
+ @" WHEN v.[AVG] = 0 THEN SUM (v.[VALUE])"
+ @" WHEN v.[AVG] = 1 THEN AVG (v.[VALUE])"
+ @" ELSE MIN (v.[VALUE])"
+ @" END as [VALUE]"
+ @", GETDATE () as [WR_DATETIME]"
+ @" FROM (" + strRes + @") as v"
+ @" GROUP BY v.ID_PUT"
+ @", v.[AVG]"
;
}
else
{
Logging.Logg().Error(@"HandlerDbTaskCalculate::getQueryValuesVar () - неизветстный тип расчета...", Logging.INDEX_MESSAGE.NOT_SET);
}
return(strRes);
}