public void UpdateListMeasTask()
{
ClassConvertTasks ts = new ClassConvertTasks();
ClassesDBGetTasks cl = new ClassesDBGetTasks();
List <MeasTask> mts_ = ts.ConvertTo_MEAS_TASKObjects(cl.ReadlAllSTasksFromDB()).ToList();
foreach (MeasTask FND in mts_.ToArray())
{
// Удаляем данные об объекте с глобального списка
if (GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == FND.Id.Value) == null)
{
GlobalInit.LIST_MEAS_TASK.Add(FND);
}
else
{
//lock (GlobalInit.LIST_MEAS_TASK)
if ((FND.Status != null) && (FND.Status != "N"))
{
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == FND.Id.Value);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, FND);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(FND);
}
}
}
}
ts.Dispose();
cl.Dispose();
}
public override ShortMeasTask Handle(GetShortMeasTaskAppOperationOptions options, IAppOperationContext operationContext)
{
ShortMeasTask Res = new ShortMeasTask();
if (GlobalInit.LIST_MEAS_TASK != null)
{
if (GlobalInit.LIST_MEAS_TASK.Count() > 0)
{
MeasTask mts = GlobalInit.LIST_MEAS_TASK.Find(t => t.Status != "Z" && t.Id.Value == options.TaskId.Value);
if (mts != null)
{
var SMT = new ShortMeasTask {
CreatedBy = mts.CreatedBy, DateCreated = mts.DateCreated, ExecutionMode = mts.ExecutionMode, Id = mts.Id, MaxTimeBs = mts.MaxTimeBs, Name = mts.Name, OrderId = mts.OrderId.GetValueOrDefault(), Prio = mts.Prio, ResultType = mts.ResultType, Status = mts.Status, Task = mts.Task, Type = mts.Type
};
if (mts.MeasDtParam != null)
{
SMT.TypeMeasurements = mts.MeasDtParam.TypeMeasurements;
}
Res = SMT;
}
else
{
Res = null;
}
}
}
return(Res);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <param name="operationContext"></param>
/// <returns></returns>
public override CommonOperationResult Handle(StopMeasTaskAppOperationOptions options, IAppOperationContext operationContext)
{
CommonOperationResult res = new CommonOperationResult();
Task ge = new Task(() =>
{
try
{
if (options.TaskId != null)
{
MeasTask mt = GlobalInit.LIST_MEAS_TASK.Find(z => z.Id.Value == options.TaskId.Value);
if (mt != null)
{
WorkFlowProcessManageTasks tasks = new WorkFlowProcessManageTasks();
//int ID = tasks.Create_New_Meas_Task(mt, "Stop");
List <int> SensorIds = new List <int>();
foreach (MeasSubTask item in mt.MeasSubTasks)
{
foreach (MeasSubTaskStation u in item.MeasSubTaskStations)
{
SensorIds.Add(u.StationId.Value);
}
}
foreach (MeasStation item in mt.Stations)
{
SensorIds.Add(item.StationId.Value);
}
var mt_edit = new MeasTask()
{
CreatedBy = mt.CreatedBy, DateCreated = mt.DateCreated, ExecutionMode = mt.ExecutionMode, Id = mt.Id, MaxTimeBs = mt.MaxTimeBs, MeasDtParam = mt.MeasDtParam, MeasFreqParam = mt.MeasFreqParam, MeasLocParams = mt.MeasLocParams, MeasOther = mt.MeasOther, MeasSubTasks = mt.MeasSubTasks, MeasTimeParamList = mt.MeasTimeParamList, Name = mt.Name, OrderId = mt.OrderId, Prio = mt.Prio, ResultType = mt.ResultType, Stations = mt.Stations, Status = mt.Status, Task = mt.Task, Type = mt.Type
};
if (SensorIds.Count > 0)
{
bool isOnline = false;
WorkFlowProcessManageTasks.Process_Multy_Meas(mt_edit, SensorIds, "Stop", isOnline);
res.State = CommonOperationState.Success;
}
}
}
Logger.Trace(this, options, operationContext);
}
catch (Exception ex)
{
Logger.Trace("StopMeasTask:" + ex.Message);
res.State = CommonOperationState.Fault;
res.FaultCause = ex.Message;
}
});
ge.RunSynchronously();
return(res);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <param name="operationContext"></param>
/// <returns></returns>
public override MeasTaskIdentifier Handle(CreateMeasTaskAppOperationOptions options, IAppOperationContext operationContext)
{
MeasTaskIdentifier md = new MeasTaskIdentifier();
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Highest;
MeasTask mt = options.Task;
if (mt.Id == null)
{
mt.Id = new MeasTaskIdentifier();
}
if (mt.Status == null)
{
mt.Status = "N";
}
WorkFlowProcessManageTasks tasks = new WorkFlowProcessManageTasks();
System.Console.WriteLine("Start Create_New_Meas_Task ");
int ID = tasks.Create_New_Meas_Task(mt, "New");
md.Value = ID;
Logger.Trace(this, options, operationContext);
Task tsg = new Task(() => {
try {
List <int> SensorIds = new List <int>();
if (mt.Stations != null)
{
foreach (MeasStation ts in mt.Stations)
{
if (ts.StationId != null)
{
if (ts.StationId != null)
{
if (!SensorIds.Contains(ts.StationId.Value))
{
SensorIds.Add(ts.StationId.Value);
}
}
}
}
}
WorkFlowProcessManageTasks.Process_Multy_Meas(mt, SensorIds, "New", false);
}
catch (Exception ex)
{
System.Console.WriteLine("CreateMeasTaskAppOperationHandler " + ex.Message);
}
});
tsg.Start();
//tsg.Wait();
return(md);
}
/// <summary>
/// Удаление из общего списка объектов типа MeasTask - таких, которые имеют статус Z
/// и время их существования превышает время, заданное параметром TimeOut
/// </summary>
/// <param name="se"></param>
/// <param name="TimeOut"></param>
public static void FindAndDestroyObject(this MeasTask se, int TimeOut, string Status)
{
lock (tmLife) {
ExtendClases <MeasTask> rx = tmLife.Find(t => t.Key.Id.Value == se.Id.Value && t.Key.Status == Status);
if (rx != null)
{
if (rx.Counter > TimeOut)
{
tmLife.RemoveAll(t => t.Key.Id.Value == se.Id.Value && t.Key.Status == Status);
GlobalInit.LIST_MEAS_TASK.RemoveAll(t => t.Id.Value == se.Id.Value && t.Status == Status);
}
}
}
}
MeasTaskIdentifier ISdrnsController.CreateMeasTask(MeasTask task, CommonOperationArguments otherArgs)
{
var result =
Operation <SdrnsControllerAppService.CreateMeasTaskAppOperation, MeasTaskIdentifier>()
.Invoke(
new CreateMeasTaskAppOperationOptions
{
Task = task,
OtherArgs = otherArgs
},
this.OperationContext
);
return(result);
}
/// <summary>
/// Если валидация MeasTaskSDR была не успешна, то установка для MeasSubTaskStation.Status="E_E"
/// </summary>
/// <param name="task"></param>
/// <param name="ID_MEasSubTaskStation"></param>
/// <param name="ToStatus"></param>
public static void UpdateStatusE_E(this MeasTask task, int ID_MEasSubTaskStation, string ToStatus)
{
if (task != null)
{
foreach (MeasSubTask SubTask in task.MeasSubTasks.ToArray())
{
foreach (MeasSubTaskStation SubTaskStation in SubTask.MeasSubTaskStations.ToArray())
{
if (SubTaskStation.Id == ID_MEasSubTaskStation)
{
SubTaskStation.Status = ToStatus;
}
}
}
}
}
public static int CreateMeasTask(MeasTask task)
{
var otherArgs = new CommonOperationArguments()
{
UserId = MD.Employee.GetCurrentUserId()
};
var result = Execute(contract => contract.CreateMeasTask(task, otherArgs));
if (result == null)
{
return(IM.NullI);
}
return(result.Value);
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <param name="operationContext"></param>
/// <returns></returns>
public override CommonOperationResult Handle(DeleteMeasTaskAppOperationOptions options, IAppOperationContext operationContext)
{
CommonOperationResult res = new CommonOperationResult();
//bool isSuccessSendTOSDR = false;
try {
if (options.TaskId != null)
{
MeasTask mt = GlobalInit.LIST_MEAS_TASK.Find(z => z.Id.Value == options.TaskId.Value);
if (mt != null)
{
WorkFlowProcessManageTasks tasks = new WorkFlowProcessManageTasks();
List <int> SensorIds = new List <int>();
foreach (MeasSubTask item in mt.MeasSubTasks)
{
foreach (MeasSubTaskStation u in item.MeasSubTaskStations)
{
SensorIds.Add(u.StationId.Value);
}
}
foreach (MeasStation item in mt.Stations)
{
SensorIds.Add(item.StationId.Value);
}
var mt_edit = new MeasTask()
{
CreatedBy = mt.CreatedBy, DateCreated = mt.DateCreated, ExecutionMode = mt.ExecutionMode, Id = mt.Id, MaxTimeBs = mt.MaxTimeBs, MeasDtParam = mt.MeasDtParam, MeasFreqParam = mt.MeasFreqParam, MeasLocParams = mt.MeasLocParams, MeasOther = mt.MeasOther, MeasSubTasks = mt.MeasSubTasks, MeasTimeParamList = mt.MeasTimeParamList, Name = mt.Name, OrderId = mt.OrderId, Prio = mt.Prio, ResultType = mt.ResultType, Stations = mt.Stations, Status = mt.Status, Task = mt.Task, Type = mt.Type
};
if (SensorIds.Count > 0)
{
WorkFlowProcessManageTasks.Process_Multy_Meas(mt_edit, SensorIds, "Stop", false);
WorkFlowProcessManageTasks.Process_Multy_Meas(mt_edit, SensorIds, "Del", false);
GlobalInit.LST_MeasurementResults.RemoveAll(t => t.Id.MeasTaskId.Value == options.TaskId.Value);
res.State = CommonOperationState.Success;
}
}
}
Logger.Trace(this, options, operationContext);
}
catch (Exception ex) {
res.State = CommonOperationState.Fault;
res.FaultCause = ex.Message;
}
return(res);
}
public static void UpdateStatusSubTasks(this MeasTask task, int Id_Sensor, string Type, bool isOnline)
{
if (task.MeasSubTasks == null)
{
return;
}
foreach (MeasSubTask SubTask in task.MeasSubTasks.ToArray())
{
foreach (MeasSubTaskStation SubTaskStation in SubTask.MeasSubTaskStations.ToArray())
{
if (SubTaskStation.StationId.Value == Id_Sensor)
{
if (Type == "Run")
{
if (isOnline)
{
SubTaskStation.Status = "O";
}
else
{
SubTaskStation.Status = "A";
}
}
else if (Type == "Stop")
{
if (isOnline)
{
SubTaskStation.Status = "P";
}
else
{
SubTaskStation.Status = "F";
}
}
else if (Type == "Del")
{
SubTaskStation.Status = "Z";
}
}
}
}
}
/// <summary>
/// Добавление нового объекта в список объектов и старт таймера
/// для отсчитывания времени его существования
/// </summary>
/// <param name="se"></param>
public static void StartLifeTime(this MeasTask se)
{
lock (tmLife) {
ExtendClases <MeasTask> rx = tmLife.Find(t => t.Key.Id.Value == se.Id.Value);
if (rx == null)
{
tmLife.Add(new ExtendClases <MeasTask>(se));
GlobalInit.LIST_MEAS_TASK.RemoveAll(t => t.Id.Value == se.Id.Value);
GlobalInit.LIST_MEAS_TASK.Add(se);
}
else
{
if (tmLife.Find(t => t.Key.Id.Value == se.Id.Value) != null)
{
tmLife.RemoveAll(t => t.Key.Id.Value == se.Id.Value);
tmLife.Add(new ExtendClases <MeasTask>(se));
GlobalInit.LIST_MEAS_TASK.RemoveAll(t => t.Id.Value == se.Id.Value);
GlobalInit.LIST_MEAS_TASK.Add(se);
}
}
}
}
/// <summary>
/// Метод, выполняющий преобразование списка объектов CLASS_TASKS (в контексте конкретного адаптера БД)
/// в список универсальных объектов MeasTask
/// </summary>
/// <param name="objs"></param>
/// <returns></returns>
public MeasTask[] ConvertTo_MEAS_TASKObjects(List <CLASS_TASKS> objs)
{
List <MeasTask> L_OUT = new List <MeasTask>();
try
{
#region Convert to MeasTask
foreach (CLASS_TASKS obj in objs.ToArray())
{
MeasTask s_out = new MeasTask();
s_out.Id = new MeasTaskIdentifier();
s_out.Id.Value = obj.meas_task.m_id;
s_out.Name = obj.meas_task.m_name;
s_out.OrderId = obj.meas_task.m_orderid;
s_out.Prio = obj.meas_task.m_prio;
MeasTaskResultType out_res_type;
if (Enum.TryParse <MeasTaskResultType>(obj.meas_task.m_resulttype, out out_res_type))
{
s_out.ResultType = out_res_type;
}
s_out.Status = obj.meas_task.m_status;
MeasTaskExecutionMode out_res_execmode;
if (Enum.TryParse <MeasTaskExecutionMode>(obj.meas_task.m_executionmode, out out_res_execmode))
{
s_out.ExecutionMode = out_res_execmode;
}
s_out.MaxTimeBs = obj.meas_task.m_maxtimebs;
MeasTaskType out_res_meas_type_task;
if (Enum.TryParse <MeasTaskType>(obj.meas_task.m_executionmode, out out_res_meas_type_task))
{
s_out.Task = out_res_meas_type_task;
}
s_out.Type = obj.meas_task.m_type;
s_out.CreatedBy = obj.meas_task.m_createdby;
s_out.DateCreated = obj.meas_task.m_datecreated;
s_out.MeasDtParam = new MeasDtParam();
{
foreach (YXbsMeasdtparam r_dt in obj.MeasDtParam.ToArray())
{
MeasDtParam dtx = new MeasDtParam();
dtx.Demod = r_dt.m_demod;
DetectingType out_res_DetectType;
if (Enum.TryParse <DetectingType>(r_dt.m_detecttype, out out_res_DetectType))
{
dtx.DetectType = out_res_DetectType;
}
dtx.IfAttenuation = r_dt.m_ifattenuation;
dtx.MeasTime = r_dt.m_meastime;
MeasurementMode out_res_MeasurementMode;
if (Enum.TryParse <MeasurementMode>(r_dt.m_detecttype, out out_res_MeasurementMode))
{
dtx.Mode = out_res_MeasurementMode;
}
dtx.Preamplification = r_dt.m_preamplification;
dtx.RBW = r_dt.m_rbw;
dtx.RfAttenuation = r_dt.m_rfattenuation;
MeasurementType out_res_MeasurementType;
if (Enum.TryParse <MeasurementType>(r_dt.m_detecttype, out out_res_MeasurementType))
{
dtx.TypeMeasurements = out_res_MeasurementType;
}
dtx.VBW = r_dt.m_vbw;
s_out.MeasDtParam = dtx;
}
}
//////////////
s_out.MeasFreqParam = new MeasFreqParam();
{
foreach (KeyValuePair <YXbsMeasfreqparam, List <YXbsMeasfreq> > r_dt in obj.MeasFreqLst_param.ToArray())
{
MeasFreqParam fre_param = new MeasFreqParam();
FrequencyMode out_res_FrequencyMode;
if (Enum.TryParse <FrequencyMode>(r_dt.Key.m_mode, out out_res_FrequencyMode))
{
fre_param.Mode = out_res_FrequencyMode;
}
fre_param.RgL = r_dt.Key.m_rgl;
fre_param.RgU = r_dt.Key.m_rgu;
fre_param.Step = r_dt.Key.m_step;
List <MeasFreq> meas_freq_lst = new List <MeasFreq>();
foreach (YXbsMeasfreq F_lst in r_dt.Value.ToArray())
{
MeasFreq f_l = new MeasFreq();
f_l.Freq = F_lst.m_freq;
meas_freq_lst.Add(f_l);
}
fre_param.MeasFreqs = meas_freq_lst.ToArray();
s_out.MeasFreqParam = fre_param;
}
}
//////////////
List <MeasSubTask> MsT = new List <MeasSubTask>();
{
foreach (KeyValuePair <YXbsMeassubtask, List <YXbsMeassubtasksta> > r_dt in obj.meas_st.ToArray())
{
MeasSubTask SUB = new MeasSubTask();
SUB.Interval = r_dt.Key.m_interval;
SUB.Status = r_dt.Key.m_status;
SUB.TimeStart = r_dt.Key.m_timestart;
SUB.TimeStop = r_dt.Key.m_timestop;
SUB.Id = new MeasTaskIdentifier();
SUB.Id.Value = r_dt.Key.m_id;
List <MeasSubTaskStation> L_MeasSubTaskStations = new List <MeasSubTaskStation>();
foreach (YXbsMeassubtasksta F_lst in r_dt.Value.ToArray())
{
MeasSubTaskStation f_l = new MeasSubTaskStation();
f_l.Count = F_lst.m_count;
f_l.Id = F_lst.m_id;
f_l.StationId = new SensorIdentifier();
f_l.StationId.Value = F_lst.m_id_xbs_sensor;
f_l.Status = F_lst.m_status;
f_l.TimeNextTask = F_lst.m_timenexttask;
L_MeasSubTaskStations.Add(f_l);
}
SUB.MeasSubTaskStations = L_MeasSubTaskStations.ToArray();
MsT.Add(SUB);
}
s_out.MeasSubTasks = MsT.ToArray();
}
//////////
{
s_out.MeasTimeParamList = new MeasTimeParamList();
YXbsMeastimeparaml r_dt = obj.MeasTimeParamList;
{
MeasTimeParamList time_param_list = new MeasTimeParamList();
time_param_list.Days = r_dt.m_days;
time_param_list.PerInterval = r_dt.m_perinterval;
time_param_list.PerStart = r_dt.m_perstart;
time_param_list.PerStop = r_dt.m_perstop;
time_param_list.TimeStart = r_dt.m_timestart;
time_param_list.TimeStop = r_dt.m_timestop;
s_out.MeasTimeParamList = time_param_list;
}
}
//////////
{
YXbsMeasother r_dt = obj.MeasOther;
MeasOther other = new MeasOther();
other.LevelMinOccup = r_dt.m_levelminoccup;
other.NChenal = r_dt.m_nchenal;
other.SwNumber = r_dt.m_swnumber;
SpectrumOccupationType out_res_SpectrumOccupationType;
if (Enum.TryParse <SpectrumOccupationType>(obj.MeasOther.m_typespectrumoccupation, out out_res_SpectrumOccupationType))
{
other.TypeSpectrumOccupation = out_res_SpectrumOccupationType;
}
SpectrumScanType out_res_SpectrumScanType;
if (Enum.TryParse <SpectrumScanType>(obj.MeasOther.m_typespectrumscan, out out_res_SpectrumScanType))
{
other.TypeSpectrumScan = out_res_SpectrumScanType;
}
s_out.MeasOther = other;
}
List <MeasLocParam> L_Lock = new List <MeasLocParam>();
foreach (YXbsMeaslocparam r_dt in obj.MeasLocParam.ToArray())
{
MeasLocParam LOCk = new MeasLocParam();
LOCk.ASL = r_dt.m_asl;
LOCk.Lat = r_dt.m_lat;
LOCk.Lon = r_dt.m_lon;
LOCk.MaxDist = r_dt.m_maxdist;
LOCk.Id = new MeasLocParamIdentifier();
LOCk.Id.Value = r_dt.m_id;
L_Lock.Add(LOCk);
}
s_out.MeasLocParams = L_Lock.ToArray();
{
List <MeasStation> L_MeasStation = new List <MeasStation>();
foreach (YXbsMeasstation r_dt in obj.Stations.ToArray())
{
MeasStation MeasStation = new MeasStation();
MeasStation.StationId = new MeasStationIdentifier();
MeasStation.StationId.Value = r_dt.m_stationid;
MeasStation.StationType = r_dt.m_stationtype;
L_MeasStation.Add(MeasStation);
}
s_out.Stations = L_MeasStation.ToArray();
}
{
/*
* List<StationDataForMeasurements> LStationDataForMeasurements = new List<StationDataForMeasurements>();
* foreach (YXbsStationdatform r_dt in obj.XbsStationdatform.ToArray())
* {
* StationDataForMeasurements MeasStation = new StationDataForMeasurements();
* MeasStation.IdStation = r_dt.m_id;
* MeasStation.GlobalSID = r_dt.m_globalsid;
* MeasStation.Standart = r_dt.m_standart;
* MeasStation.Status = r_dt.m_status;
*
* ////////////////////////////////
* OwnerData own = new OwnerData();
* YXbsOwnerdata XbsMeasstation_ = new YXbsOwnerdata(ConnectDB.Connect_Main_);
* XbsMeasstation_.Format("*");
* XbsMeasstation_.Filter = string.Format("(id_stationdatform={0})", r_dt.m_id);
* for (XbsMeasstation_.OpenRs(); !XbsMeasstation_.IsEOF(); XbsMeasstation_.MoveNext())
* {
* own.Addres = XbsMeasstation_.m_addres;
* own.Code = XbsMeasstation_.m_code;
* own.Id = XbsMeasstation_.m_id;
* own.OKPO = XbsMeasstation_.m_okpo;
* own.OwnerName = XbsMeasstation_.m_ownername;
* own.Zip = XbsMeasstation_.m_zip;
* MeasStation.Owner = own;
* break;
* }
* XbsMeasstation_.Close();
* XbsMeasstation_.Dispose();
* ////////////////////////////////
*
* ////////////////////////////////
* PermissionForAssignment perm = new PermissionForAssignment();
* YXbsPermassign Xbsperm_ = new YXbsPermassign(ConnectDB.Connect_Main_);
* Xbsperm_.Format("*");
* Xbsperm_.Filter = string.Format("(id_stationdatform={0})", r_dt.m_id);
* for (Xbsperm_.OpenRs(); !Xbsperm_.IsEOF(); Xbsperm_.MoveNext())
* {
* perm.CloseDate = Xbsperm_.m_closedate;
* perm.DozvilName = Xbsperm_.m_dozvilname;
* perm.EndDate = Xbsperm_.m_enddate;
* perm.Id = Xbsperm_.m_id;
* perm.StartDate = Xbsperm_.m_startdate;
* MeasStation.LicenseParameter = perm;
* break;
* }
* Xbsperm_.Close();
* Xbsperm_.Dispose();
* ////////////////////////////////
*
* ////////////////////////////////
* SiteStationForMeas stM = new SiteStationForMeas();
* YXbsSitestformeas Xbssite_ = new YXbsSitestformeas(ConnectDB.Connect_Main_);
* Xbssite_.Format("*");
* Xbssite_.Filter = string.Format("(id_stationdatform={0})", r_dt.m_id);
* for (Xbssite_.OpenRs(); !Xbssite_.IsEOF(); Xbssite_.MoveNext())
* {
* stM.Adress = Xbssite_.m_addres;
* stM.Lat = Xbssite_.m_lat;
* stM.Lon = Xbssite_.m_lon;
* stM.Region = Xbssite_.m_region;
* MeasStation.Site = stM;
* break;
* }
* Xbssite_.Close();
* Xbssite_.Dispose();
* ////////////////////////////////
*
* ////////////////////////////////
* List<SectorStationForMeas> LsectM = new List<SectorStationForMeas>();
* YXbsSectstformeas Xbssect_ = new YXbsSectstformeas(ConnectDB.Connect_Main_);
* Xbssect_.Format("*");
* Xbssect_.Filter = string.Format("(id_stationdatform={0})", r_dt.m_id);
* for (Xbssect_.OpenRs(); !Xbssect_.IsEOF(); Xbssect_.MoveNext())
* {
* SectorStationForMeas sectM = new SectorStationForMeas();
*
* sectM.AGL = Xbssect_.m_agl;
* sectM.Azimut = Xbssect_.m_azimut;
* sectM.BW = Xbssect_.m_bw;
* sectM.ClassEmission = Xbssect_.m_classemission;
* sectM.EIRP = Xbssect_.m_eirp;
* sectM.IdSector = Xbssect_.m_id;
*
* List<FrequencyForSectorFormICSM> LFreqICSM = new List<FrequencyForSectorFormICSM>();
* YXbsFreqforsectics XbsFreqforsectics_ = new YXbsFreqforsectics(ConnectDB.Connect_Main_);
* XbsFreqforsectics_.Format("*");
* XbsFreqforsectics_.Filter = string.Format("(id_sectstformeas={0})", Xbssect_.m_id);
* for (XbsFreqforsectics_.OpenRs(); !XbsFreqforsectics_.IsEOF(); XbsFreqforsectics_.MoveNext())
* {
* FrequencyForSectorFormICSM freqM = new FrequencyForSectorFormICSM();
* freqM.ChannalNumber = XbsFreqforsectics_.m_channalnumber;
* freqM.Frequency = (decimal)XbsFreqforsectics_.m_frequency;
* freqM.Id = XbsFreqforsectics_.m_id;
* freqM.IdPlan = XbsFreqforsectics_.m_idplan;
* LFreqICSM.Add(freqM);
* }
* XbsFreqforsectics_.Close();
* XbsFreqforsectics_.Dispose();
*
* sectM.Frequencies = LFreqICSM.ToArray();
*
*
*
* List<MaskElements> L_Mask = new List<MaskElements>();
* YXbsMaskelements Xbsaskelements_ = new YXbsMaskelements(ConnectDB.Connect_Main_);
* Xbsaskelements_.Format("*");
* Xbsaskelements_.Filter = string.Format("(id_sectstformeas={0})", Xbssect_.m_id);
* for (Xbsaskelements_.OpenRs(); !Xbsaskelements_.IsEOF(); Xbsaskelements_.MoveNext())
* {
* MaskElements MaskElementsM = new MaskElements();
* MaskElementsM.BW = Xbsaskelements_.m_bw;
* MaskElementsM.level = Xbsaskelements_.m_level;
* L_Mask.Add(MaskElementsM);
* }
* Xbsaskelements_.Close();
* Xbsaskelements_.Dispose();
* sectM.MaskBW = L_Mask.ToArray();
*
*
* LsectM.Add(sectM);
* MeasStation.Sectors = LsectM.ToArray();
* }
* Xbssect_.Close();
* Xbssect_.Dispose();
* ////////////////////////////////
* LStationDataForMeasurements.Add(MeasStation);
* }
* s_out.StationsForMeasurements = LStationDataForMeasurements.ToArray();
*/
}
L_OUT.Add(s_out);
Console.WriteLine("Convert to MEAS_TASK Objects ...");
}
#endregion
}
catch (Exception ex)
{ CoreICSM.Logs.CLogs.WriteError(ELogsWhat.Unknown, "[ConvertTo_MEAS_TASKObjects]: " + ex.Message); }
return(L_OUT.ToArray());
}
/// <summary>
/// Функция обновления статуса MeasTask,MeasSubTask,MeasSubTaskStation
/// </summary>
/// <param name="task"></param>
/// <param name="Type"></param>
public static void UpdateStatus(this MeasTask task, string Type = "New")
{
//правила переходов из статуса в статусы при заданной операции
//Task tsk = new Task(() =>
//{
List <RuleStatusTransition> OperationTransitionRule = new List <RuleStatusTransition>();
OperationTransitionRule.Add(new RuleStatusTransition("Stop", "N", "F"));
OperationTransitionRule.Add(new RuleStatusTransition("Stop", "A", "F"));
OperationTransitionRule.Add(new RuleStatusTransition("Run", "F", "A"));
OperationTransitionRule.Add(new RuleStatusTransition("Stop", "E_L", "F"));
OperationTransitionRule.Add(new RuleStatusTransition("Run", "P", "O"));
OperationTransitionRule.Add(new RuleStatusTransition("Stop", "O", "P"));
List <StatusDescription> Descr_MeasSubTaskStation = new List <StatusDescription>();
Descr_MeasSubTaskStation.Add(new StatusDescription("", 0, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("N", 2, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("A", 9, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("C", 4, ModeStatus.final));
Descr_MeasSubTaskStation.Add(new StatusDescription("T", 3, ModeStatus.final));
Descr_MeasSubTaskStation.Add(new StatusDescription("F", 8, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("Z", 1, ModeStatus.final));
Descr_MeasSubTaskStation.Add(new StatusDescription("E_L", 5, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("E_T", 6, ModeStatus.final));
Descr_MeasSubTaskStation.Add(new StatusDescription("E_E", 7, ModeStatus.final));
Descr_MeasSubTaskStation.Add(new StatusDescription("P", 10, ModeStatus.cur));
Descr_MeasSubTaskStation.Add(new StatusDescription("O", 11, ModeStatus.cur));
List <StatusDescription> Descr_MeasSubTask = new List <StatusDescription>();
Descr_MeasSubTask.Add(new StatusDescription("", 0, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("N", 2, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("A", 9, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("C", 4, ModeStatus.final));
Descr_MeasSubTask.Add(new StatusDescription("T", 3, ModeStatus.final));
Descr_MeasSubTask.Add(new StatusDescription("F", 8, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("Z", 1, ModeStatus.final));
Descr_MeasSubTask.Add(new StatusDescription("E_L", 5, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("E_T", 6, ModeStatus.final));
Descr_MeasSubTask.Add(new StatusDescription("E_E", 7, ModeStatus.final));
Descr_MeasSubTask.Add(new StatusDescription("P", 10, ModeStatus.cur));
Descr_MeasSubTask.Add(new StatusDescription("O", 11, ModeStatus.cur));
List <int> MaxWeightLst = new List <int>();
if (task.MeasSubTasks == null)
{
return;
}
foreach (MeasSubTask SubTask in task.MeasSubTasks.ToArray())
{
string StatusWithMaxWeight = "";
MaxWeightLst = new List <int>();
foreach (MeasSubTaskStation SubTaskStation in SubTask.MeasSubTaskStations.ToArray())
{
if (Type == "Run")
{
if (SubTaskStation.Status == "P")
{
if ((OperationTransitionRule.Find(t => t.NameOperation == Type && t.StartStatus == SubTaskStation.Status && t.ToStatuses == "O")) != null)
{
SubTaskStation.Status = "O";
SubTask.Status = "O";
task.Status = "O";
}
}
if (SubTaskStation.Status == "F")
{
if ((OperationTransitionRule.Find(t => t.NameOperation == Type && t.StartStatus == SubTaskStation.Status && t.ToStatuses == "A")) != null)
{
SubTaskStation.Status = "A";
SubTask.Status = "A";
task.Status = "A";
}
}
}
else if (Type == "Del")
{
SubTaskStation.Status = "Z";
SubTask.Status = "Z";
task.Status = "Z";
}
else if (Type == "Stop")
{
StatusDescription DescrStat = Descr_MeasSubTaskStation.Find(t => t.Type != ModeStatus.final && t.NameStatus == SubTaskStation.Status);
if (DescrStat != null)
{
if ((OperationTransitionRule.Find(t => t.NameOperation == Type && t.StartStatus == SubTaskStation.Status && t.ToStatuses == "P")) != null)
{
SubTaskStation.Status = "P";
SubTask.Status = "P";
task.Status = "P";
}
if ((OperationTransitionRule.Find(t => t.NameOperation == Type && t.StartStatus == SubTaskStation.Status && t.ToStatuses == "F")) != null)
{
SubTaskStation.Status = "F";
SubTask.Status = "F";
task.Status = "F";
}
}
}
StatusDescription val_fnd_status = Descr_MeasSubTaskStation.Find(t => t.NameStatus == SubTaskStation.Status);
if (val_fnd_status != null)
{
MaxWeightLst.Add(val_fnd_status.Weight);
}
}
if (MaxWeightLst.Count > 0)
{
int Max_ = MaxWeightLst.Max();
StatusDescription val_fnd_status_ = Descr_MeasSubTaskStation.Find(t => t.Weight == Max_);
if (val_fnd_status_ != null)
{
StatusWithMaxWeight = val_fnd_status_.NameStatus;
SubTask.Status = StatusWithMaxWeight;
}
}
}
MaxWeightLst = new List <int>();
foreach (MeasSubTask SubTask in task.MeasSubTasks.ToArray())
{
StatusDescription val_fnd_status = Descr_MeasSubTask.Find(t => t.NameStatus == SubTask.Status);
if (val_fnd_status != null)
{
MaxWeightLst.Add(val_fnd_status.Weight);
}
}
if (MaxWeightLst.Count > 0)
{
int Max_ = MaxWeightLst.Max();
StatusDescription val_fnd_status_ = Descr_MeasSubTask.Find(t => t.Weight == Max_);
if (val_fnd_status_ != null)
{
task.Status = val_fnd_status_.NameStatus;
}
}
OperationTransitionRule.Clear();
Descr_MeasSubTaskStation.Clear();
Descr_MeasSubTask.Clear();
MaxWeightLst.Clear();
//});
//tsk.Start();
//tsk.Wait();
}
// Создание MeasTaskSDRs 26.12.2017 обновление функции Максим 27.12.2017
public static List <MeasSdrTask> CreateeasTaskSDRs(this MeasTask task, string Type = "New")
{
List <MeasSdrTask> ListMTSDR = new List <MeasSdrTask>();
if (task.MeasSubTasks == null)
{
return(ListMTSDR);
}
foreach (MeasSubTask SubTask in task.MeasSubTasks)
{
foreach (MeasSubTaskStation SubTaskStation in SubTask.MeasSubTaskStations)
{
if ((Type == "New") || ((Type == "Stop") && ((SubTaskStation.Status == "F") || (SubTaskStation.Status == "P"))) || ((Type == "Run") && ((SubTaskStation.Status == "O") || (SubTaskStation.Status == "A"))) ||
((Type == "Del") && (SubTaskStation.Status == "Z")))
{
MeasSdrTask MTSDR = new MeasSdrTask();
MTSDR.MeasSubTaskId = SubTask.Id;
MTSDR.MeasSubTaskStationId = SubTaskStation.Id;
MTSDR.MeasTaskId = task.Id;
MTSDR.status = SubTaskStation.Status;
MTSDR.SensorId = SubTaskStation.StationId;
if (Type == "New")
{
if (task.Id == null)
{
task.Id = new MeasTaskIdentifier();
}
if (task.MeasOther == null)
{
task.MeasOther = new MeasOther();
}
if (task.MeasDtParam == null)
{
task.MeasDtParam = new MeasDtParam();
}
MTSDR.MeasDataType = task.MeasDtParam.TypeMeasurements;
MTSDR.MeasFreqParam = task.MeasFreqParam;
if (task.MeasLocParams != null)
{
MTSDR.MeasLocParam = task.MeasLocParams;
}
MTSDR.MeasSDRParam = new MeasSdrParam();
MTSDR.MeasSDRSOParam = new MeasSdrSOParam();
MTSDR.MeasSDRParam.DetectTypeSDR = task.MeasDtParam.DetectType;
if (task.MeasDtParam.MeasTime != null)
{
MTSDR.MeasSDRParam.MeasTime = task.MeasDtParam.MeasTime.GetValueOrDefault();
}
else
{
MTSDR.MeasSDRParam.MeasTime = 0.001;
}
MTSDR.MeasSDRParam.PreamplificationSDR = task.MeasDtParam.Preamplification;
if (task.MeasDtParam.RBW != null)
{
MTSDR.MeasSDRParam.RBW = task.MeasDtParam.RBW.GetValueOrDefault();
}
else
{
MTSDR.MeasSDRParam.RBW = 10;
}
if (task.MeasOther.LevelMinOccup != null)
{
MTSDR.MeasSDRSOParam.LevelMinOccup = task.MeasOther.LevelMinOccup.GetValueOrDefault();
}
else
{
MTSDR.MeasSDRSOParam.LevelMinOccup = -70;
}
MTSDR.MeasSDRParam.RfAttenuationSDR = (int)task.MeasDtParam.RfAttenuation;
if (task.MeasDtParam.VBW != null)
{
MTSDR.MeasSDRParam.VBW = task.MeasDtParam.VBW.GetValueOrDefault();
}
else
{
MTSDR.MeasSDRParam.VBW = 10;
}
// MTSDR.MeasSDRParam.ref_level_dbm = 70; // Для SDR пока не присваевается
MTSDR.MeasSDRParam.ref_level_dbm = -30;
if (task.MeasOther.NChenal != null)
{
MTSDR.MeasSDRSOParam.NChenal = task.MeasOther.NChenal.GetValueOrDefault();
}
else
{
MTSDR.MeasSDRSOParam.NChenal = 10;
}
MTSDR.MeasSDRSOParam.TypeSO = task.MeasOther.TypeSpectrumOccupation;
if (task.Prio != null)
{
MTSDR.prio = task.Prio.GetValueOrDefault();
}
else
{
MTSDR.prio = 10;
}
MTSDR.status = "N";
if (task.MeasOther.SwNumber != null)
{
MTSDR.SwNumber = task.MeasOther.SwNumber.GetValueOrDefault();
} //else { MTSDR.SwNumber = 10; }
MTSDR.Time_start = SubTask.TimeStart;
MTSDR.Time_stop = SubTask.TimeStop;
if (SubTask.Interval != null)
{
MTSDR.PerInterval = SubTask.Interval.GetValueOrDefault();
} //else { MTSDR.SwNumber = 10; }
MTSDR.TypeM = task.MeasOther.TypeSpectrumScan;
if (task.MeasDtParam.TypeMeasurements == MeasurementType.MonitoringStations)
{ // 21_02_2018 в данном случае мы передаем станции исключительно для системы мониторинга станций т.е. один таск на месяц Надо проверить.
if (task.StationsForMeasurements != null)
{
MTSDR.StationsForMeasurements = task.StationsForMeasurements;
// далее сформируем переменную GlobalSID
for (int i = 0; i < MTSDR.StationsForMeasurements.Count(); i++)
{
string CodeOwener = "0";
if (MTSDR.StationsForMeasurements[i].Owner.OKPO == "14333937")
{
CodeOwener = "1";
}
;
if (MTSDR.StationsForMeasurements[i].Owner.OKPO == "22859846")
{
CodeOwener = "6";
}
;
if (MTSDR.StationsForMeasurements[i].Owner.OKPO == "21673832")
{
CodeOwener = "3";
}
;
if (MTSDR.StationsForMeasurements[i].Owner.OKPO == "37815221")
{
CodeOwener = "7";
}
;
MTSDR.StationsForMeasurements[i].GlobalSID = "255 " + CodeOwener + " 00000 " + string.Format("{0:00000}", MTSDR.StationsForMeasurements[i].IdStation);
}
}
}
}
ListMTSDR.Add(MTSDR);
}
}
}
return(ListMTSDR);
}
// Создание MeasSubTask и MeasSubTaskStation
// Создание MeasSubTask и MeasSubTaskStation
public static void CreateAllSubTasks(this MeasTask task)
{
if (task.Status == "N")
{
List <MeasSubTask> ListMST = new List <MeasSubTask>();
if (task.MeasDtParam == null)
{
task.MeasDtParam = new MeasDtParam();
}
;
if (task.MeasDtParam.TypeMeasurements == MeasurementType.MonitoringStations)
{ // 21_02_2018 в данном случае мы делаем таски исключительно для системы мониторинга станций т.е. один таск на месяц.
MeasSubTask MST = new MeasSubTask();
if (task.MeasTimeParamList.PerInterval != null)
{
MST.Interval = (int)task.MeasTimeParamList.PerInterval;
}
else
{
MST.Interval = 3600;
};
MST.Id = new MeasTaskIdentifier();
MST.Id.Value = 1;
MST.TimeStart = task.MeasTimeParamList.PerStart;
MST.TimeStop = task.MeasTimeParamList.PerStop;
MST.Status = "A";
List <MeasSubTaskStation> ListMSTS = new List <MeasSubTaskStation>();
int j = 0;
foreach (MeasStation St in task.Stations)
{
MeasSubTaskStation MSTS = new MeasSubTaskStation();
MSTS.Id = j; j++;
MSTS.Status = "N";
MSTS.StationId = new SensorIdentifier();
MSTS.StationId.Value = St.StationId.Value;
ListMSTS.Add(MSTS);
}
MST.MeasSubTaskStations = ListMSTS.ToArray();
ListMST.Add(MST);
}
else
{
int i = 0;
int hour_start = 0; int hour_stop = 24;
int min_start = 0; int min_stop = 0;
int sec_start = 0; int sec_stop = 0;
if (task.MeasTimeParamList.TimeStart != null)
{
hour_start = task.MeasTimeParamList.TimeStart.GetValueOrDefault().Hour; min_start = task.MeasTimeParamList.TimeStart.GetValueOrDefault().Minute; sec_start = task.MeasTimeParamList.TimeStart.GetValueOrDefault().Second;
}
if (task.MeasTimeParamList.TimeStop != null)
{
hour_stop = task.MeasTimeParamList.TimeStop.GetValueOrDefault().Hour; min_stop = task.MeasTimeParamList.TimeStop.GetValueOrDefault().Minute; sec_stop = task.MeasTimeParamList.TimeStop.GetValueOrDefault().Second;
}
for (var day = task.MeasTimeParamList.PerStart; day.Date <= task.MeasTimeParamList.PerStop; day = day.AddDays(1))
{
MeasSubTask MST = new MeasSubTask();
if (task.MeasTimeParamList.PerInterval != null)
{
MST.Interval = (int)task.MeasTimeParamList.PerInterval;
}
else
{
MST.Interval = 3600;
};
MST.Id = new MeasTaskIdentifier();
MST.Id.Value = i; i++;
MST.TimeStart = new DateTime(day.Year, day.Month, day.Day, hour_start, min_start, sec_start);
MST.TimeStop = new DateTime(day.Year, day.Month, day.Day, hour_stop, min_stop, sec_stop);
MST.Status = "A";
List <MeasSubTaskStation> ListMSTS = new List <MeasSubTaskStation>();
int j = 0;
foreach (MeasStation St in task.Stations)
{
MeasSubTaskStation MSTS = new MeasSubTaskStation();
MSTS.Id = j; j++;
MSTS.Status = "N";
MSTS.StationId = new SensorIdentifier();
MSTS.StationId.Value = St.StationId.Value;
ListMSTS.Add(MSTS);
}
MST.MeasSubTaskStations = ListMSTS.ToArray();
ListMST.Add(MST);
}
}
task.MeasSubTasks = ListMST.ToArray();
}
task.Status = "A";
}
void IAppServerComponent.Activate()
{
BaseXMLConfiguration xml_conf = new BaseXMLConfiguration();
GlobalInit.Initialization();
ClassesDBGetResult DbGetRes = new ClassesDBGetResult();
ClassConvertToSDRResults conv = new ClassConvertToSDRResults();
///
// Начальная инициализация (загрузка конфигурационных данных)
/*
* Task tt = new Task(() => {
* System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Normal;
* if (GlobalInit.LST_MeasurementResults.Count == 0) {
* MeasurementResults[] msResltConv = conv.ConvertTo_SDRObjects(DbGetRes.ReadlAllResultFromDB());
* if (msResltConv != null) {
* foreach (MeasurementResults inb in msResltConv.ToArray()) {
* GlobalInit.LST_MeasurementResults.Add(inb);
* }
* }
* }
* });
* tt.Start();
* tt.Wait();
*/
Task tsg = new Task(() => {
ClassesDBGetTasks cl = new ClassesDBGetTasks();
ClassConvertTasks ts = new ClassConvertTasks();
List <MeasTask> mts_ = ts.ConvertTo_MEAS_TASKObjects(cl.ReadlAllSTasksFromDB()).ToList();
foreach (MeasTask mtsd in mts_.ToArray())
{
if (((GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == mtsd.Id.Value) == null)))
{
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == mtsd.Id.Value);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, mtsd);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(mtsd);
}
}
}
cl.Dispose();
ts.Dispose();
});
tsg.Start();
Sheduler_Up_Meas_SDR_Results Sc_Up_Meas_SDR = new Sheduler_Up_Meas_SDR_Results(); Sc_Up_Meas_SDR.ShedulerRepeatStart(BaseXMLConfiguration.xml_conf._TimeUpdateMeasResult);
ShedulerReceiveStatusMeastaskSDR sc = new ShedulerReceiveStatusMeastaskSDR();
sc.ShedulerRepeatStart(BaseXMLConfiguration.xml_conf._TimeUpdateMeasTaskStatus);
ShedulerCheckActivitySensor CheckActivitySensor = new ShedulerCheckActivitySensor();
CheckActivitySensor.ShedulerRepeatStart(BaseXMLConfiguration.xml_conf._RescanActivitySensor);
ShedulerGetMeasTask getMeasTask = new ShedulerGetMeasTask(); getMeasTask.ShedulerRepeatStart(20);
//Sheduler_ArchiveSDRResults arch_sdrRes = new Sheduler_ArchiveSDRResults(); arch_sdrRes.ShedulerRepeatStart(BaseXMLConfiguration.xml_conf._TimeArchiveResult);
ShedulerCheckStart Quartz = new ShedulerCheckStart();
Quartz.ShedulerRepeatStart(BaseXMLConfiguration.xml_conf._ReloadStart);
}
/// <summary>
/// Добавление в очередь новых тасков
/// </summary>
/// <param name="s_out"></param>
/// <returns>количество новых объектов, добавленных в глобальный список</returns>
public int Create_New_Meas_Task(MeasTask s_out, string ActionType)
{
ClassesDBGetTasks cl = new ClassesDBGetTasks();
ClassConvertTasks ts = new ClassConvertTasks();
int NewIdMeasTask = -1;
try
{
if (s_out != null)
{
//lock (GlobalInit.LIST_MEAS_TASK)
//UpdateListMeasTask();
MeasTask Data_ = s_out;
// создаём объект список подзадач типа MEAS_SUB_TASK и записываем в объект Data_
Data_.CreateAllSubTasks();
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "[CreateAllSubTasks] success...");
// конвертируем объекты тасков с БД в список List<MEAS_TASK>
//List<MeasTask> mts_ = ts.ConvertTo_MEAS_TASKObjects(cl.ReadlAllSTasksFromDB()).ToList();
List <MeasTask> mts_ = GlobalInit.LIST_MEAS_TASK;
if (mts_.Find(r => r.Id.Value == Data_.Id.Value) == null)
{
if (((GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value) == null)))
{
Data_.UpdateStatus(ActionType);
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "Success UpdateStatus !!!...");
NewIdMeasTask = cl.SaveTaskToDB(Data_);
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "Success create new TASK !!!...");
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, Data_);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(Data_);
}
}
else
{
if (GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value) != null)
{
Data_ = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value);
Data_.UpdateStatus(ActionType);
//cl.SaveStatusTaskToDB(Data_);
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, Data_);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(Data_);
}
}
}
}
else
{
if (GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value) != null)
{
Data_ = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value);
Data_.UpdateStatus();
//cl.SaveStatusTaskToDB(Data_);
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Data_.Id.Value);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, Data_);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(Data_);
}
}
}
}
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "[Create_New_Meas_Task] success...");
}
catch (Exception er) {
CoreICSM.Logs.CLogs.WriteError(ELogsWhat.Unknown, "[Create_New_Meas_Task]: " + er.Message);
}
cl.Dispose();
ts.Dispose();
return(NewIdMeasTask);
}
//ClassConvertTasks ts = new ClassConvertTasks();
void IJob.Execute(IJobExecutionContext context)
{
//foreach (IDisposable d in GlobalInit.Lds_Activity_MEAS_TASK_SDR_Main_List_SDR) d.SafeDispose();
//Task stx = new Task(() =>
//{
try
{
BusManager <List <MeasSdrTask> > busManager = new BusManager <List <MeasSdrTask> >();
foreach (Sensor s in GlobalInit.SensorListSDRNS.ToArray())
{
if (ClassStaticBus.bus.Advanced.IsConnected)
{
uint cnt = busManager.GetMessageCount(GlobalInit.Template_MEAS_TASK_SDR_Main_List_SDR + s.Name + s.Equipment.TechId);
for (int i = 0; i < cnt; i++)
{
var message = busManager.GetDataObject(GlobalInit.Template_MEAS_TASK_SDR_Main_List_SDR + s.Name + s.Equipment.TechId);
if (message != null)
{
List <MeasSdrTask> fnd_s = message as List <MeasSdrTask>;
if (fnd_s != null)
{
foreach (MeasSdrTask h in fnd_s)
{
if (h.MeasTaskId != null)
{
MeasTask tsk = GlobalInit.LIST_MEAS_TASK.Find(t => t.Id.Value == h.MeasTaskId.Value);
if (tsk != null)
{
tsk.Status = h.status;
cl.SaveStatusTaskToDB(tsk);
}
}
}
}
}
else
{
break;
}
}
/*
* GlobalInit.Lds_Activity_MEAS_TASK_SDR_Main_List_SDR.Add(ClassStaticBus.bus.Receive(GlobalInit.Template_MEAS_TASK_SDR_Main_List_SDR + s.Name + s.Equipment.TechId, x => x
* .Add<List<MeasSdrTask>>(message =>
* {
* List<MeasSdrTask> fnd_s = message;
* if (fnd_s != null)
* {
* foreach (MeasSdrTask h in fnd_s)
* {
* if (h.MeasTaskId != null)
* {
* MeasTask tsk = GlobalInit.LIST_MEAS_TASK.Find(t => t.Id.Value == h.MeasTaskId.Value);
* if (tsk != null)
* {
* tsk.Status = h.status;
* cl.SaveStatusTaskToDB(tsk);
* }
* }
* }
* }
* })));
*/
}
else
{
ClassStaticBus.bus.Dispose();
GC.SuppressFinalize(ClassStaticBus.bus);
ClassStaticBus.bus = RabbitHutch.CreateBus(GlobalInit.MainRabbitMQServices);
CoreICSM.Logs.CLogs.WriteInfo(CoreICSM.Logs.ELogsWhat.Unknown, "-> Bus dispose... ");
}
}
CoreICSM.Logs.CLogs.WriteInfo(CoreICSM.Logs.ELogsWhat.Unknown, "ShedulerGetMeasTask ");
}
catch (Exception ex)
{
CoreICSM.Logs.CLogs.WriteError(CoreICSM.Logs.ELogsWhat.Unknown, "ShedulerGetMeasTask " + ex.Message);
}
cl.Dispose();
//});
//stx.Start();
//stx.Wait();
System.GC.Collect();
}
/// <summary>
///
/// </summary>
public static bool Process_Multy_Meas(MeasTask mt, List <int> SensorIds, string ActionType, bool isOnline)
{
bool isSendSuccess = false;
try
{
ClassesDBGetTasks cl = new ClassesDBGetTasks();
List <MeasSdrTask> Checked_L = new List <MeasSdrTask>();
//Task tdf = new Task(() =>
//{
if (mt != null)
{
List <MeasSdrTask> LM_SDR = new List <MeasSdrTask>();
foreach (int SensorId in SensorIds.ToArray())
{
Sensor fnd_s = GlobalInit.SensorListSDRNS.Find(t => t.Id.Value == SensorId);
if (fnd_s != null)
{
Task tsk = new Task(() =>
{
Checked_L.Clear();
if (GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == mt.Id.Value) != null)
{
MeasTask M = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == mt.Id.Value);
int Id_Old = M.Id.Value;
MeasSubTask[] msbd_old = M.MeasSubTasks;
M = mt;
M.Id.Value = Id_Old;
if (M.Stations.ToList().FindAll(e => e.StationId.Value == SensorId) != null)
{
M.UpdateStatusSubTasks(SensorId, ActionType, isOnline);
LM_SDR = M.CreateeasTaskSDRs(ActionType);
//if (isCreateTasksSdr == false) { LM_SDR = M.CreateeasTaskSDRs(ActionType); }
if (LM_SDR != null)
{
string ids = "";
int MaxVal = cl.GetMaXIdsSdrTasks(M);
int idx = MaxVal + 1;
foreach (MeasSdrTask mx in LM_SDR.ToArray())
{
mx.Id = idx;
ids = idx.ToString() + ";";
//Task ts = new Task(() => {
//если сенсор активен
//if (fnd_s.Status == "A")
//{
if (mx.SensorId.Value == SensorId)
{
/// Перед отправкой включаем валидацию созданных объектов MeasTaskSDR
if (mx.ValidationMeas())
{
Checked_L.Add(mx);
M.UpdateStatus(ActionType);
}
else
{
// если вадидация не прошла
M.UpdateStatusE_E(mx.MeasSubTaskStationId, "E_E");
M.UpdateStatus(ActionType);
//обновление группы статусов для объекта MeasTask
cl.SaveStatusTaskToDB(M);
}
}
idx++;
}
if (ids.Length > 0)
{
ids = ids.Remove(ids.Count() - 1, 1);
}
cl.SaveIdsSdrTasks(M, ids);
}
}
M.MeasSubTasks = msbd_old;
MeasTask fnd = GlobalInit.LIST_MEAS_TASK.Find(j => j.Id.Value == Id_Old);
if (fnd != null)
{
GlobalInit.LIST_MEAS_TASK.ReplaceAll <MeasTask>(fnd, M);
}
else
{
GlobalInit.LIST_MEAS_TASK.Add(M);
}
if (ActionType == "Del")
{
GlobalInit.LIST_MEAS_TASK.RemoveAll(t => t.Id.Value == M.Id.Value);
}
}
});
tsk.Start();
tsk.Wait();
if (Checked_L.Count > 0)
{
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "--> Start busManager send new task...");
BusManager <List <MeasSdrTask> > busManager = new BusManager <List <MeasSdrTask> >();
if (busManager.SendDataObject(Checked_L, GlobalInit.Template_MEAS_TASK_Main_List_APPServer + fnd_s.Name + fnd_s.Equipment.TechId, XMLLibrary.BaseXMLConfiguration.xml_conf._TimeExpirationTask.ToString()))
{
isSendSuccess = true;
CoreICSM.Logs.CLogs.WriteInfo(ELogsWhat.Unknown, "--> Success send new task...");
}
else
{
isSendSuccess = false;
//Sheduler_Send_MeasSdr shed = new Sheduler_Send_MeasSdr();
//если отправка не получилась - пытаемся отправить сообщение через 1 минуту
//shed.ShedulerRepeatStart(60, mt, SensorIds, ActionType, isOnline);
}
// Отправка сообщения в СТОП-ЛИСТ
if ((ActionType == "Stop") && (isOnline) && ((Checked_L[0].status == "F") || (Checked_L[0].status == "P")))
{
if (busManager.SendDataObject(Checked_L, GlobalInit.Template_MEAS_TASK_Stop_List + fnd_s.Name + fnd_s.Equipment.TechId + Checked_L[0].MeasTaskId.Value.ToString() + Checked_L[0].SensorId.Value.ToString(), XMLLibrary.BaseXMLConfiguration.xml_conf._TimeExpirationTask.ToString()))
{
isSendSuccess = true;
}
}
else
{
//busManager.DeleteQueue(GlobalInit.Template_MEAS_TASK_Stop_List + fnd_s.Name + fnd_s.Equipment.TechId + Checked_L[0].MeasTaskId.Value.ToString() + Checked_L[0].SensorId.Value.ToString());
}
}
Checked_L.Clear();
}
}
//});
//tsk.Start();
//tsk.Wait();
}
//cl.Dispose();
//});
//tdf.Start();
//tdf.Wait();
}
catch (Exception ex)
{
CoreICSM.Logs.CLogs.WriteError(ELogsWhat.Unknown, "[Process_Multy_Meas]: " + ex.Message);
}
return(isSendSuccess);
}
