protected virtual void threadGetRDGValuesWithDate(object date)
{
INDEX_WAITHANDLE_REASON indxEv = INDEX_WAITHANDLE_REASON.SUCCESS;
ResetSyncState();
//lock (m_lockSuccessGetData)
//{
foreach (FormChangeMode.KeyDevice key in m_listKeyTECComponentDetail)
{
indxEv = WaitAny(Constants.MAX_WATING, true);
if (indxEv == INDEX_WAITHANDLE_REASON.SUCCESS)
{
base.GetRDGValues(key, (DateTime)date);
}
else
{
ASUTP.Logging.Logg().Error($"AdminTS_TG::threadGetRDGValuesWithDate () - <{indxEv}>...", ASUTP.Logging.INDEX_MESSAGE.NOT_SET);
break;
}
}
//}
//m_bSavePPBRValues = true;
}
/// <summary>
/// Метод создания потока получения значений с датой
/// </summary>
/// <param name="obj">Объект, передаваемый в качестве параметра при запуске потока</param>
protected override void threadGetRDGValuesWithDate(object date)
{
INDEX_WAITHANDLE_REASON indxEv = INDEX_WAITHANDLE_REASON.SUCCESS;
ResetSyncState();
//lock (m_lockSuccessGetData)
//{
foreach (FormChangeMode.KeyDevice key in m_listKeyTECComponentDetail)
{
indxEv = WaitAny(Constants.MAX_WATING, true);
if (indxEv == INDEX_WAITHANDLE_REASON.SUCCESS)
{
//Ожидание изменения состояния семафора
m_semaIndxTECComponents.WaitOne();
base.BaseGetRDGValue(key, (DateTime)date);
m_listPrevRDGValues = new List <RDGStruct []> (m_listCurRDGValues);
}
else
{
ASUTP.Logging.Logg().Error($"AdminTS_TG::threadGetRDGValuesWithDate () - <{indxEv}>...", ASUTP.Logging.INDEX_MESSAGE.NOT_SET);
break;
}
}
//}
//m_bSavePPBRValues = true;
}
/// <summary>
/// Метод создания потока получения значений с датой
/// </summary>
/// <param name="obj">Объект, передаваемый в качестве параметра при запуске потока</param>
protected override void threadGetRDGValuesWithDate(object date)
{
int indxEv = -1;
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
//lock (m_lockSuccessGetData)
//{
foreach (int indx in m_listTECComponentIndexDetail)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
m_semaIndxTECComponents.WaitOne();//Ожидание изменения состояния семафора
base.BaseGetRDGValue(indx, (DateTime)date);
m_listPrevRDGValues = new List <RDGStruct[]>(m_listCurRDGValues);
}
else
{
break;
}
}
//}
//m_bSavePPBRValues = true;
}
protected virtual void threadGetRDGValuesWithDate(object date)
{
int indxEv = -1;
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
//lock (m_lockSuccessGetData)
//{
foreach (int indx in m_listTECComponentIndexDetail)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
base.GetRDGValues(/*(int)m_typeFields,*/ indx, (DateTime)date);
}
else
{
break;
}
}
//}
//m_bSavePPBRValues = true;
}
/// <summary>
/// Метод создания потока получения значений без даты
/// </summary>
/// <param name="obj">Объект, передаваемый в качестве параметра при запуске потока</param>
protected override void threadGetRDGValuesWithoutDate(object obj)
{
INDEX_WAITHANDLE_REASON indxEv = INDEX_WAITHANDLE_REASON.SUCCESS;
//lock (m_lockSuccessGetData)
//{
foreach (FormChangeMode.KeyDevice key in m_listKeyTECComponentDetail)
{
indxEv = WaitAny(System.Threading.Timeout.Infinite, true);
if (indxEv == INDEX_WAITHANDLE_REASON.SUCCESS)
{
m_semaIndxTECComponents.WaitOne();
base.BaseGetRDGValue(key, DateTime.MinValue);
m_listPrevRDGValues = new List <RDGStruct[]>(m_listCurRDGValues);
}
else
{
ASUTP.Logging.Logg().Error($"AdminTS_LK::threadGetRDGValuesWithoutDate () - <{indxEv}>...", ASUTP.Logging.INDEX_MESSAGE.NOT_SET);
break;
}
}
//}
//m_bSavePPBRValues = true;
}
public void ResetSyncState()
{
for (INDEX_WAITHANDLE_REASON indx = INDEX_WAITHANDLE_REASON.ERROR; indx < INDEX_WAITHANDLE_REASON.COUNT_INDEX_WAITHANDLE_REASON; indx++)
{
ResetSyncState(indx);
}
}
protected override int StateRequest(int state)
{
INDEX_WAITHANDLE_REASON indxReasonRes =
//!(IndexDbSource < 0)
!(_key._current_type == CONN_SETT_TYPE.UNKNOWN)
? INDEX_WAITHANDLE_REASON.SUCCESS : INDEX_WAITHANDLE_REASON.ERROR;
string query = string.Empty;
//actionReport(string.Format(@"HandlerDbStateValue::StateRequest(type={0}) - state={1}, IndexDbSource={2} ...", _key._current_type, (StatesMachine)state, IndexDbSource));
actionReport(string.Format(@"HandlerDbStateValue::StateRequest(type={0}) - state={1} ...", _key._current_type, (StatesMachine)state));
if (indxReasonRes == INDEX_WAITHANDLE_REASON.SUCCESS)
switch ((StatesMachine)state) {
case StatesMachine.SERVER_TIME:
GetCurrentTimeRequest(DbInterface.DB_TSQL_INTERFACE_TYPE.MSSQL, m_dictIdListeners[_key._current_id_tec][(int)_key._current_type]);
break;
case StatesMachine.LIST_SIGNAL:
case StatesMachine.VALUES:
indxReasonRes = (string.IsNullOrEmpty(query = request_handlers[(StatesMachine)state]()) == false)
? INDEX_WAITHANDLE_REASON.SUCCESS : INDEX_WAITHANDLE_REASON.ERROR;
if (indxReasonRes == INDEX_WAITHANDLE_REASON.SUCCESS)
Request(m_dictIdListeners[_key._current_id_tec][(int)_key._current_type], query);
else
;
break;
default:
break;
} else
;
return (int)indxReasonRes;
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int /*StatesMachine*/ state, int request, int result)
{
INDEX_WAITHANDLE_REASON reasonRes = INDEX_WAITHANDLE_REASON.SUCCESS;
bool bClear = false;
StatesMachine stateMachine = (StatesMachine)state;
delegateStopWait();
switch (stateMachine)
{
case StatesMachine.PPBRValues:
if (request == 0)
{
ErrorReport("Ошибка разбора данных плана. Переход в ожидание.");
}
else
{
ErrorReport("Ошибка получения данных плана. Переход в ожидание.");
bClear = true;
}
break;
case StatesMachine.PPBRDates:
if (request == 0)
{
ErrorReport("Ошибка разбора сохранённых часовых значений (PPBR). Переход в ожидание.");
//saveResult = Errors.ParseError;
}
else
{
ErrorReport("Ошибка получения сохранённых часовых значений (PPBR). Переход в ожидание.");
//saveResult = Errors.NoAccess;
}
try
{
//semaDBAccess.Release(1);
}
catch
{
}
break;
default:
break;
}
if (bClear)
{
ClearValues();
}
errorData?.Invoke();
return(reasonRes);
}
/// <summary>
/// Функция обратного вызова при возникновения ситуации "ошибка"
/// при обработке списка состояний
/// </summary>
/// <param name="state">Состояние при котором возникла ситуация</param>
/// <param name="req">Признак результата выполнения запроса</param>
/// <param name="res">Признак возвращения результата при запросе</param>
/// <returns>Индекс массива объектов синхронизации</returns>
protected override INDEX_WAITHANDLE_REASON StateErrors(int state, int req, int res)
{
INDEX_WAITHANDLE_REASON iRes = INDEX_WAITHANDLE_REASON.SUCCESS;
errorReport(@"Получение значений из БД - состояние: " + ((State)state).ToString());
return(iRes);
}
/// <summary>
/// Функция обратного вызова при возникновения ситуации "ошибка"
/// при обработке списка состояний
/// </summary>
/// <param name="state">Состояние при котором возникла ситуация</param>
/// <param name="req">Признак результата выполнения запроса</param>
/// <param name="res">Признак возвращения результата при запросе</param>
/// <returns>Индекс массива объектов синхронизации</returns>
protected override INDEX_WAITHANDLE_REASON StateErrors(int state, int req, int res)
{
INDEX_WAITHANDLE_REASON iRes = INDEX_WAITHANDLE_REASON.SUCCESS;
func_Completed("StateErrors", (StatesMachine)state, new DataTable(), res);
errorReport(@"Получение значений из БД - состояние: " + ((StatesMachine)state).ToString());
return(iRes);
}
protected override int StateResponse(int state,object obj)
{
INDEX_WAITHANDLE_REASON indxReasonRes = !(_key._current_type == CONN_SETT_TYPE.UNKNOWN) ? INDEX_WAITHANDLE_REASON.SUCCESS : INDEX_WAITHANDLE_REASON.ERROR;
DataTable tableResponse = null;
//actionReport(string.Format(@"HandlerDbStateValue::StateResponse(type={0}) - state={1}, IndexDbSource={2} ...", _key._current_type, (StatesMachine)state, IndexDbSource));
if (indxReasonRes == INDEX_WAITHANDLE_REASON.SUCCESS)
{
tableResponse = obj as DataTable;
switch ((StatesMachine)state)
{
case StatesMachine.SERVER_TIME:
//Values.SetServerTime(_key._current_type, (DateTime)tableResponse.Rows[0][0]);
Values.serverTime = (DateTime)tableResponse.Rows[0][0];
break;
case StatesMachine.LIST_SIGNAL:
indxReasonRes = response_handlers[(StatesMachine)state](tableResponse) == true
? INDEX_WAITHANDLE_REASON.SUCCESS : INDEX_WAITHANDLE_REASON.ERROR;
Logging.Logg().Debug(string.Format(@"::StateResponse () - [id_tec={0}, type={1}] получено строк={2}, сигналов={3}; Рез-т={4}"
,_key._current_id_tec,_key._current_type,tableResponse.Rows.Count,Signals.Count,indxReasonRes)
,Logging.INDEX_MESSAGE.NOT_SET);
break;
case StatesMachine.VALUES:
indxReasonRes = response_handlers[(StatesMachine)state](tableResponse) == true
? INDEX_WAITHANDLE_REASON.SUCCESS : INDEX_WAITHANDLE_REASON.ERROR;
break;
default:
break;
}
}
else
{
;
}
if (isLastState(state) == true)
{
m_arSyncStateCheckResponse[(int)INDEX_SYNC_STATECHECKRESPONSE.RESPONSE].Set();
ReportClear(true);
}
else
{
;
}
return((int)indxReasonRes);
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int state,int req,int res)
{
INDEX_WAITHANDLE_REASON indxReason = INDEX_WAITHANDLE_REASON.SUCCESS;
ItemQueue itemQueue = Peek;
Logging.Logg().Error($"HandlerSignalQueue::StateRequest (CONN_SETT_TYPE={(CONN_SETT_TYPE)itemQueue.Pars [1]}, event={(EVENT)state}) - необработанное событие..."
,Logging.INDEX_MESSAGE.NOT_SET);
return(indxReason);
}
//public int WaitAny (int msec_wait = System.Threading.Timeout.Infinite, bool bExitContext = true)
//{
// return WaitHandle.WaitAny (m_waitHandleState, msec_wait, bExitContext);
//}
public INDEX_WAITHANDLE_REASON WaitAny(int msec_wait, bool bExitContext)
{
INDEX_WAITHANDLE_REASON indxRes = INDEX_WAITHANDLE_REASON.SUCCESS;
indxRes = (INDEX_WAITHANDLE_REASON)WaitHandle.WaitAny(m_waitHandleState, msec_wait, bExitContext);
return
//indxRes == INDEX_WAITHANDLE_REASON.TIMEOUT ? INDEX_WAITHANDLE_REASON.ERROR :
(indxRes
);
}
protected void abortThreadGetValues(INDEX_WAITHANDLE_REASON reason)
{
if (m_waitHandleState.Length > (int)reason)
{
((ManualResetEvent)m_waitHandleState[(int)reason]).Set();
}
else
{
;
}
}
public void ResetSyncState(INDEX_WAITHANDLE_REASON indx)
{
if (((int)indx < m_waitHandleState.Length) &&
(typeof(ManualResetEvent).IsAssignableFrom(m_waitHandleState [(int)indx].GetType()) == true))
{
(m_waitHandleState [(int)indx] as ManualResetEvent).Reset();
}
else
{
;
}
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int /*StatesMachine*/ state, int request, int result)
{
INDEX_WAITHANDLE_REASON reasonRes = INDEX_WAITHANDLE_REASON.SUCCESS;
bool bClear = false;
StatesMachine stateMachine = (StatesMachine)state;
delegateStopWait();
switch (stateMachine)
{
case StatesMachine.PPBRValues:
if (request == 0)
{
ErrorReport("Ошибка разбора данных плана. Переход в ожидание.");
}
else
{
ErrorReport("Ошибка получения данных плана. Переход в ожидание.");
bClear = true;
}
break;
default:
break;
}
if (bClear)
{
ClearValues();
//ClearTables();
}
else
{
;
}
if (!(errorData == null))
{
errorData();
}
else
{
;
}
return(reasonRes);
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int state, int request, int result)
{
INDEX_WAITHANDLE_REASON reasonRes = INDEX_WAITHANDLE_REASON.SUCCESS;
string error = string.Empty,
reason = string.Empty,
waiting = string.Empty;
StatesMachine stateMachine = (StatesMachine)state;
switch (stateMachine)
{
case StatesMachine.CurrentTime:
if (request == 0)
{
reason = @"разбора";
}
else
{
reason = @"получения";
}
reason += @" текущего времени сервера";
waiting = @"Переход в ожидание";
break;
default:
break;
}
error = "Ошибка " + reason + ".";
if (waiting.Equals(string.Empty) == false)
{
error += " " + waiting + ".";
}
else
{
;
}
ErrorReport(error);
//if (! (errorData == null)) errorData (); else ;
Logging.Logg().Error(@"HGetDate::StateErrors () - error=" + error + @" - вЫход...", Logging.INDEX_MESSAGE.NOT_SET);
return(reasonRes);
}
protected void SetSyncState(INDEX_WAITHANDLE_REASON indx)
{
if (typeof(AutoResetEvent).IsAssignableFrom(m_waitHandleState [(int)indx].GetType()) == true)
{
(m_waitHandleState [(int)indx] as AutoResetEvent).Set();
}
else if (typeof(ManualResetEvent).IsAssignableFrom(m_waitHandleState [(int)indx].GetType()) == true)
{
(m_waitHandleState [(int)indx] as ManualResetEvent).Set();
}
else
{
;
}
}
/// <summary>
/// Поток запроса значений для 'TecViewAlarm'
/// </summary>
/// <param name="synch">Объект для синхронизации</param>
private void threadGetRDGValues(object synch)
{
int indxEv = -1;
//if (m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.SUCCESS].WaitOne (0, true) == false)
((AutoResetEvent)m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.SUCCESS]).Set();
//else ;
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < INDEX_WAITHANDLE_REASON.COUNT_INDEX_WAITHANDLE_REASON; i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
foreach (TECComponent tc in allTECComponents)
{
if (tc.IsGTP == true)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == (int)INDEX_WAITHANDLE_REASON.BREAK)
{
break;
}
else
{
if (!(indxEv == (int)INDEX_WAITHANDLE_REASON.SUCCESS))
{
((ManualResetEvent)m_waitHandleState[indxEv]).Reset();
}
else
{
;
}
CurrentKey = new FormChangeMode.KeyDevice()
{
Id = tc.m_id, Mode = tc.Mode
};
getRDGValues();
}
}
else
{
; //Это не ГТП
}
}
}
protected override int StateResponse(int state, object obj)
{
INDEX_WAITHANDLE_REASON indxReasonRes = INDEX_WAITHANDLE_REASON.SUCCESS;
if (isLastState(state) == true)
{
//indxReasonRes = INDEX_WAITHANDLE_REASON.BREAK;
this.completeHandleStates(INDEX_WAITHANDLE_REASON.BREAK);
}
else
{
;
}
// ответ не требуется
return((int)indxReasonRes);
}
/// <summary>
/// Поток запроса значений для 'TecViewAlarm'
/// </summary>
/// <param name="synch">Объект для синхронизации</param>
private void threadGetRDGValues(object synch)
{
INDEX_WAITHANDLE_REASON indxEv = INDEX_WAITHANDLE_REASON.SUCCESS;
//if (m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.SUCCESS].WaitOne (0, true) == false)
SetSyncState(INDEX_WAITHANDLE_REASON.SUCCESS);
//else ;
ResetSyncState();
foreach (TECComponent tc in allTECComponents)
{
if (tc.IsGTP == true)
{
indxEv = WaitAny(Constants.MAX_WATING, true);
if (indxEv == INDEX_WAITHANDLE_REASON.BREAK)
{
break;
}
else
{
if (!(indxEv == INDEX_WAITHANDLE_REASON.SUCCESS))
{
ResetSyncState((INDEX_WAITHANDLE_REASON)indxEv);
}
else
{
;
}
CurrentKey = new FormChangeMode.KeyDevice()
{
Id = tc.m_id, Mode = tc.Mode
};
getRDGValues();
}
}
else
{
; //Это не ГТП
}
}
}
/// <summary>
/// Установить признак окончания обработки всех событий
/// </summary>
protected void completeHandleStates(INDEX_WAITHANDLE_REASON indxEv)
{
try
{
if (((int)indxEv == (int)INDEX_WAITHANDLE_REASON.SUCCESS) ||
((int)indxEv > (m_waitHandleState.Length - 1)))
{
SetSyncState(INDEX_WAITHANDLE_REASON.SUCCESS);
}
else
{
SetSyncState(indxEv);
}
}
catch (Exception e)
{
Logging.Logg().Exception(e, $"HHandler::ThreadFunction () - m_waitHandleState[{indxEv}]).Set() - ...", Logging.INDEX_MESSAGE.NOT_SET);
}
}
/// <summary>
/// Установить признак окончания обработки всех событий
/// </summary>
protected void completeHandleStates(INDEX_WAITHANDLE_REASON indxEv)
{
try
{
if (((int)indxEv == (int)INDEX_WAITHANDLE_REASON.SUCCESS) ||
((int)indxEv > (m_waitHandleState.Length - 1)))
{
((AutoResetEvent)m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.SUCCESS]).Set();
}
else
{
((ManualResetEvent)m_waitHandleState[(int)indxEv]).Set();
}
}
catch (Exception e)
{
Logging.Logg().Exception(e, "HHandler::ThreadFunction () - m_waitHandleState[0]).Set()", Logging.INDEX_MESSAGE.NOT_SET);
}
}
/// <summary>
/// Инициализация объектов синхронизации
/// </summary>
protected void AddSyncState(INDEX_WAITHANDLE_REASON indx, Type syncType, bool bInitState)
{
if (!(indx == INDEX_WAITHANDLE_REASON.SUCCESS))
{
if (Equals(m_waitHandleState [(int)indx], null) == true)
{
initializeSyncState(indx, syncType, bInitState);
}
else
{
Logging.Logg().Warning($"HHandler::InitializeSyncState () - объект синхронизации <{indx}, type={m_waitHandleState [(int)indx].GetType().Name}> был создан ранее..."
, Logging.INDEX_MESSAGE.NOT_SET);
}
}
else
{
Logging.Logg().Warning($"HHandler::InitializeSyncState () - объект синхронизации <{indx}> создается автоматически...", Logging.INDEX_MESSAGE.NOT_SET);
}
}
private void threadImpRDGExcelValues(object date)
{
int indxEv = -1;
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
//lock (m_lockSuccessGetData)
//{
foreach (int indx in m_listTECComponentIndexDetail)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
if (modeTECComponent(indx) == FormChangeMode.MODE_TECCOMPONENT.GTP)
{
base.GetRDGValues(/*(int)m_typeFields,*/ indx, (DateTime)date);
}
else
if (modeTECComponent(indx) == FormChangeMode.MODE_TECCOMPONENT.TG)
{
base.ImpRDGExcelValues(indx, (DateTime)date);
}
else
{
;
}
}
else
{
break;
}
}
//}
//m_bSavePPBRValues = true;
}
/// <summary>
/// Потоковая функция - выполнить запросы к источникам данных в ~ соответствии со сформированной очередью
/// </summary>
/// <param name="obj">Аргумент при вызове</param>
private void fThreadRequest(object obj)
{
INDEX_WAITHANDLE_REASON indxReasonCompleted = INDEX_WAITHANDLE_REASON.COUNT_INDEX_WAITHANDLE_REASON;
string fmtMsg = @"Cохранение значений для {0}";
Query =
//(string)obj
@"INSERT INTO [dbo].[BIYSK_LOADER] ([XML_SECTION_NAME],[XML_ITEM_NAME],[VALUE],[DATA_DATE]) VALUES ('SEC', 'PAR', 0.00, GETDATE())"
;
try {
while (m_queueIdConnSett.Count > 0)
{
IdConnSettCurrent = m_queueIdConnSett.Dequeue();
AddState((int)StatesMachine.Truncate); // добавить состояние для очистки таблицы перед вставкой
AddState((int)StatesMachine.Merge); // добавить состояние для выполнения целевого запроса(вставка значений)
AddState((int)StatesMachine.SP); // добавить состояние для выполнения ХП обработкии вставленных значений
// обработать все состояния
Run(string.Format(fmtMsg, IdConnSettCurrent));
// ожидать завершения обработки всех состояний
indxReasonCompleted = (INDEX_WAITHANDLE_REASON)WaitHandle.WaitAny(m_waitHandleState);
if (indxReasonCompleted == INDEX_WAITHANDLE_REASON.SUCCESS)
{
// оповестить об успешном выполнении группы запросов
DataAskedHost(IdConnSettCurrent);
}
else
{
;
}
}
} catch (Exception e) {
Logging.Logg().Exception(e, string.Format(fmtMsg, IdConnSettCurrent), Logging.INDEX_MESSAGE.NOT_SET);
}
}
/// <summary>
/// Сохранение внесенных изменений
/// </summary>
/// <returns>Ошибка выполнения</returns>
public override ASUTP.Helper.Errors SaveChanges()
{
ASUTP.Helper.Errors errRes = ASUTP.Helper.Errors.NoError,
bErr = ASUTP.Helper.Errors.NoError;
int indxEv = -1;
m_evSaveChangesComplete.Reset();
lock (m_lockResSaveChanges)
{
m_listResSaveChanges.Clear();
}
int prevIndxTECComponent = indxTECComponents;
foreach (RDGStruct[] curRDGValues in m_listCurRDGValues)
{
bErr = ASUTP.Helper.Errors.NoError;
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
if (modeTECComponent(m_listTECComponentIndexDetail[m_listCurRDGValues.IndexOf(curRDGValues)]) == FormChangeMode.MODE_TECCOMPONENT.TG)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
indxTECComponents = m_listTECComponentIndexDetail[m_listCurRDGValues.IndexOf(curRDGValues)];
curRDGValues.CopyTo(m_curRDGValues, 0);
bErr = base.BaseSaveChanges();
}
else
{
break;
}
}
else
if (modeTECComponent(m_listTECComponentIndexDetail[m_listCurRDGValues.IndexOf(curRDGValues)]) == FormChangeMode.MODE_TECCOMPONENT.GTP)
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
indxTECComponents = m_listTECComponentIndexDetail[m_listCurRDGValues.IndexOf(curRDGValues)];
curRDGValues.CopyTo(m_curRDGValues, 0);
bErr = base.BaseSaveChanges();
}
else
{
break;
}
}
;
lock (m_lockResSaveChanges)
{
m_listResSaveChanges.Add(bErr);
if (!(bErr == ASUTP.Helper.Errors.NoError) &&
(errRes == ASUTP.Helper.Errors.NoError))
{
errRes = bErr;
}
else
{
;
}
}
}
indxTECComponents = prevIndxTECComponent;
//if (indxEv == 0)
//if (errRes == Errors.NoError)
m_evSaveChangesComplete.Set();
//else ;
if (!(saveComplete == null))
{
saveComplete();
}
else
{
;
}
return(errRes);
}
public override Errors SaveChanges()
{
Errors errRes = Errors.NoError,
bErr = Errors.NoError;
INDEX_WAITHANDLE_REASON indxEv = INDEX_WAITHANDLE_REASON.SUCCESS;
m_evSaveChangesComplete.Reset();
lock (m_lockResSaveChanges)
{
m_listResSaveChanges.Clear();
}
FormChangeMode.KeyDevice prevKeyTECComponent = CurrentKey;
foreach (RDGStruct [] curRDGValues in m_listCurRDGValues)
{
bErr = Errors.NoError;
ResetSyncState();
if (m_listKeyTECComponentDetail[m_listCurRDGValues.IndexOf(curRDGValues)].Mode == FormChangeMode.MODE_TECCOMPONENT.TG)
{
indxEv = WaitAny(Constants.MAX_WATING, true);
if (indxEv == INDEX_WAITHANDLE_REASON.SUCCESS)
{
CurrentKey = m_listKeyTECComponentDetail[m_listCurRDGValues.IndexOf(curRDGValues)];
curRDGValues.CopyTo(m_curRDGValues, 0);
bErr = base.SaveChanges();
}
else
{
ASUTP.Logging.Logg().Error($"AdminTS_TG::SaveChanges () - <{indxEv}>...", ASUTP.Logging.INDEX_MESSAGE.NOT_SET);
break;
}
}
else
{
;
}
lock (m_lockResSaveChanges)
{
m_listResSaveChanges.Add(bErr);
if (!(bErr == Errors.NoError) && (errRes == Errors.NoError))
{
errRes = bErr;
}
else
{
;
}
}
}
CurrentKey = prevKeyTECComponent;
//if (indxEv == 0)
//if (errRes == Errors.NoError)
m_evSaveChangesComplete.Set();
//else ;
//??? почему AdminValues
saveComplete?.Invoke((m_markSavedValues.IsMarked((int)INDEX_MARK_PPBRVALUES.PBR_SAVED) == true) ? (int)StatesMachine.SavePPBRValues : (int)StatesMachine.SaveAdminValues);
return(errRes);
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int /*StatesMachine*/ state, int request, int result)
{
INDEX_WAITHANDLE_REASON reasonRes = INDEX_WAITHANDLE_REASON.SUCCESS;
bool bClear = false;
StatesMachine stateMachine = (StatesMachine)state;
string mesError = string.Empty;
delegateStopWait();
switch (stateMachine)
{
case StatesMachine.PPBRValues:
if (request == 0)
{
mesError = "Ошибка разбора данных плана. Переход в ожидание.";
}
else
{
mesError = "Ошибка получения данных плана. Переход в ожидание.";
bClear = true;
}
break;
case StatesMachine.PPBRDates:
try
{
if (request == 0)
{
mesError = "Ошибка разбора сохранённых часовых значений (PPBR). Переход в ожидание.";
//saveResult = Errors.ParseError;
}
else
{
mesError = "Ошибка получения сохранённых часовых значений (PPBR). Переход в ожидание.";
//saveResult = Errors.NoAccess;
}
//semaDBAccess.Release(1);
}
catch
{
}
break;
case StatesMachine.MaketEquipment:
if (request == 0)
{
mesError = "Ошибка разбора содержания макетов. Переход в ожидание.";
}
else
{
mesError = "Ошибка получения содержания макетов. Переход в ожидание.";
}
break;
default:
break;
}
if (string.IsNullOrEmpty(mesError) == false)
{
ErrorReport(mesError);
}
if (bClear)
{
ClearValues();
}
errorData?.Invoke((int)stateMachine);
return(reasonRes);
}
private void threadCSVValues(object type)
{
Errors errRes = Errors.NoError;
Thread.CurrentThread.CurrentCulture =
Thread.CurrentThread.CurrentUICulture =
ProgramBase.ss_MainCultureInfo; //new System.Globalization.CultureInfo(@"en-US")
//Определить тип загружаемых значений
CONN_SETT_TYPE typeValues = (CONN_SETT_TYPE)type;
int indxEv = -1
, prevIndxTECComponents = indxTECComponents;
string strPBRNumber = string.Empty; // ...только для ПБР
if (typeValues == CONN_SETT_TYPE.PBR)
{//Только для ПБР
//Противоположные операции при завершении потока 'threadPPBRCSVValues'
//Разрешить запись ПБР-значений
if (m_markSavedValues.IsMarked((int)INDEX_MARK_PPBRVALUES.PBR_ENABLED) == true)
{
m_markSavedValues.Marked((int)INDEX_MARK_PPBRVALUES.PBR_SAVED);
}
else
{
;
}
//Запретить запись Админ-значений
if (m_markSavedValues.IsMarked((int)INDEX_MARK_PPBRVALUES.ADMIN_ENABLED) == true)
{
m_markSavedValues.UnMarked((int)INDEX_MARK_PPBRVALUES.ADMIN_SAVED);
}
else
{
;
}
strPBRNumber = getNamePBRNumber((int)GetPropertiesOfNameFilePPBRCSVValues()[1] - 1);
}
else
{
;
}
//Снять все признаки причин прекращения выполнения обработки событий
for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
{
((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
}
foreach (TECComponent comp in allTECComponents)
{
if (comp.IsGTP == true) //Является ГТП
{
indxEv = WaitHandle.WaitAny(m_waitHandleState);
if (indxEv == 0)
{
switch (typeValues)
{
case CONN_SETT_TYPE.ADMIN:
errRes = saveCSVValues(allTECComponents.IndexOf(comp), typeValues);
break;
case CONN_SETT_TYPE.PBR:
errRes = saveCSVValues(allTECComponents.IndexOf(comp), strPBRNumber);
break;
default:
break;
}
//if (! (errRes == Errors.NoError))
// ; //Ошибка ???
//else
// ;
}
else
{
//Ошибка ???
//break;
//completeHandleStates();
;
}
}
else
{
;
}
}
//Очистить таблицу, полученную из CSV-файла
m_tableValuesResponse.Clear();
m_tableValuesResponse = null;
if (typeValues == CONN_SETT_TYPE.PBR)
{//Только для ПБР
//Противоположные операции в 'ImpPPBRCSVValuesRequest'
//Запретить запись ПБР-значений
// , запрет устанавливается автоматически
//Разрешить запись Админ-значений
if (m_markSavedValues.IsMarked((int)INDEX_MARK_PPBRVALUES.ADMIN_ENABLED) == true)
{
m_markSavedValues.Marked((int)INDEX_MARK_PPBRVALUES.ADMIN_SAVED);
}
else
{
;
}
}
else
{
;
}
//Обновить значения на вкладке
GetRDGValues(/*m_typeFields,*/ prevIndxTECComponents);
}