/// <summary>
/// Adjudicates the claim data thread.
/// </summary>
/// <param name="taskId">The task identifier.</param>
/// <param name="facilityId">The facility identifier.</param>
/// <param name="noOfRecords">The no of records.</param>
/// <param name="connectionString">The connection string.</param>
/// <param name="isBackgroundTask">if set to <c>true</c> [is background task].</param>
/// <returns></returns>
public Task <Dictionary <long, List <PaymentResult> > > AdjudicateClaimDataThread(long?taskId, int facilityId,
int noOfRecords, string connectionString, bool isBackgroundTask)
{
if (taskId.HasValue)
{
try
{
long claimsCount = AddClaimsForATask(Convert.ToInt64(taskId));
// Get Contracts for Adjudication
List <Contract> contracts = GetContracts(Convert.ToInt64(taskId),
facilityId, claimsCount);
// Adjudication with multithreading
AdjudicateClaimTasks(Convert.ToInt64(taskId), noOfRecords, claimsCount, contracts, connectionString, isBackgroundTask);
}
catch (Exception ex)
{
TrackTask task = new TrackTask
{
TaskId = Convert.ToString(taskId, CultureInfo.InvariantCulture),
Status = Convert.ToString((byte)Enums.JobStatus.Failed, CultureInfo.InvariantCulture),
UserName = Constants.BackgroundServiceUser
};
Log.LogError(Constants.ClaimSelectionExceptionLog + taskId, Constants.BackgroundServiceUser, ex);
UpdateJobStatus(task);
}
}
return(Task.FromResult(new Dictionary <long, List <PaymentResult> >()));
}
/// <summary>
/// Retrieves all available jobs
/// </summary>
/// <returns></returns>
public JsonResult GetAllJobs(string jobStatusId, int take, int skip)
{
PageSetting pageSetting = new PageSetting {
Skip = skip, Take = take
};
// bool isVerified = false;
TrackTask data = new TrackTask
{
PageSetting = pageSetting,
UserName = GetCurrentUserName(),
FacilityId = GetCurrentFacilityId(),
ThresholdDaysToExpireJobs = GlobalConfigVariables.NumberOfDaysToDismissCompletedJobs,
Status = jobStatusId
};
List <TrackTask> jobsList = PostApiResponse <List <TrackTask> >(Constants.JobsData, Constants.GetAllJobs, data);
List <JobStatusViewModel> jobs = new List <JobStatusViewModel>();
if (jobsList != null && jobsList.Count > 0)
{
jobs = jobsList.Select(Mapper.Map <TrackTask, JobStatusViewModel>).ToList();
}
var jobStatusViewModel = jobs.FirstOrDefault();
return(Json(jobStatusViewModel != null ? new { data = jobs, total = jobStatusViewModel.TotalJobs } : new { data = jobs, total = 0 }));
}
/// <summary>
/// Determines whether [is model exist] [the specified model identifier].
/// </summary>
/// <param name="modelId">The model identifier.</param>
/// <returns></returns>
public ActionResult IsModelExist(long modelId)
{
TrackTask job = new TrackTask {
ModelId = modelId
};
return(Json(new { IsSuccess = PostApiResponse <bool>(Constants.JobsData, Constants.IsModelExist, job) }));
}
/// <summary>
/// Updates Job status
/// </summary>
/// <param name="taskid"></param>
/// <param name="status"></param>
public ActionResult UpdateJobStatus(string taskid, string status)
{
TrackTask job = new TrackTask {
TaskId = taskid, Status = status, UserName = GetCurrentUserName()
};
int jobsstatus = PostApiResponse <int>(Constants.JobsData, Constants.UpdateJobStatus, job);
return(Json(jobsstatus == 1 ? new { IsSuccess = true } : new { IsSuccess = false }));
}
public JsonResult UpdateJobsCount(int jobUpdateId)
{
TrackTask job = new TrackTask {
TaskId = jobUpdateId.ToString(CultureInfo.InvariantCulture)
};
bool jobsstatus = PostApiResponse <bool>(Constants.JobsData, Constants.UpdateJobVerifiedStatus, job);
return(Json(new { data = jobsstatus }));
}
/// <summary>
/// Updates task status in DB
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public void UpdateJobStatus(TrackTask job)
{
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("UpdateJobStatus");
_databaseObj.AddInParameter(_databaseCommand, "@TaskId", DbType.Int64, job.TaskId);
_databaseObj.AddInParameter(_databaseCommand, "@RunningStatus", DbType.Int16, job.Status);
_databaseObj.AddInParameter(_databaseCommand, "@UserName", DbType.String, job.UserName);
//// Retrieve the results of the Stored Procedure
_databaseObj.ExecuteScalar(_databaseCommand);
}
/// <summary>
/// Updates the job verified status.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public bool UpdateJobVerifiedStatus(TrackTask data)
{
if (data != null)
{
_databaseCommand = _databaseObj.GetStoredProcCommand("UpdateVerifiedSatusForJobs");
_databaseObj.AddInParameter(_databaseCommand, "@TaskID", DbType.Int64, data.TaskId);
_databaseObj.ExecuteNonQuery(_databaseCommand);
return(true);
}
return(false);
}
/// <summary>
/// Determines whether [is model exist] [the specified job].
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public bool IsModelExist(TrackTask job)
{
if (job != null)
{
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("IsModelExist");
_databaseObj.AddInParameter(_databaseCommand, "@ModelId", DbType.Int64, Convert.ToInt64(job.ModelId));
// Retrieve the results of the Stored Procedure
return(Convert.ToInt32(_databaseObj.ExecuteScalar(_databaseCommand)) > 0);
}
return(false);
}
/// <summary>
/// UpdateJob
/// </summary>
/// <param name="taskId"></param>
private void UpdateJob(long?taskId)
{
UpdateRunningTasksThread(Convert.ToInt64(taskId));
TrackTask task = new TrackTask
{
TaskId = Convert.ToString(taskId, CultureInfo.InvariantCulture),
Status = Convert.ToString((byte)Enums.JobStatus.Completed, CultureInfo.InvariantCulture),
UserName = Constants.BackgroundServiceUser
};
UpdateJobStatus(task);
}
/// <summary>
/// Gets all jobs.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public List <TrackTask> GetAllJobs(TrackTask data)
{
List <TrackTask> jobs = new List <TrackTask>();
//Lots of magic integers are used like 29,130 and no comments are there for those what does it do
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("GetAllJobs");
_databaseObj.AddInParameter(_databaseCommand, "@FacilityID", DbType.Int64, data.FacilityId);
_databaseObj.AddInParameter(_databaseCommand, "@RunningStatus", DbType.Int32,
Convert.ToInt32(data.Status.ToTrim()));
_databaseObj.AddInParameter(_databaseCommand, "@Take", DbType.String, data.PageSetting.Take);
_databaseObj.AddInParameter(_databaseCommand, "@Skip", DbType.String, data.PageSetting.Skip);
// Retrieve the results of the Stored Procedure
DataSet jobsDataSet = _databaseObj.ExecuteDataSet(_databaseCommand);
DataRow[] myJobs = jobsDataSet.Tables[0].Select();
jobs.AddRange(myJobs.Select(ssiJobTrack => new TrackTask
{
RequestName =
GetStringValue(ssiJobTrack["RequestName"]),
TaskId = GetStringValue(ssiJobTrack["JobId"]),
UserName = GetStringValue(ssiJobTrack["UserName"]),
Status = Enum.GetName(typeof(Enums.JobStatus), ssiJobTrack["STATUS"]),
ModelId = GetValue <long>(ssiJobTrack["ModelId"], typeof(long)),
ElapsedTime = string.Format("{0:D2}:{1:D2}:{2:D2}",
TimeSpan.FromSeconds(Convert.ToDouble(ssiJobTrack["ElapsedTime"])).Days,
TimeSpan.FromSeconds(Convert.ToDouble(ssiJobTrack["ElapsedTime"])).Hours,
TimeSpan.FromSeconds(Convert.ToDouble(ssiJobTrack["ElapsedTime"])).Minutes),
ClaimsSelectionCount =
GetStringValue(
ssiJobTrack["NoOfClaimsSelected"]),
AdjudicatedClaimsCount =
GetStringValue(
ssiJobTrack["NoOfClaimsAdjudicated"]),
IsVerified = DBNull.Value != ssiJobTrack["IsVerified"] &&
GetValue <bool>((ssiJobTrack["IsVerified"]), typeof(bool)),
ModelName = GetStringValue(ssiJobTrack["ModelName"]),
Criteria = GetStringValue(ssiJobTrack["Criteria"])
}));
var firstOrDefault = jobs.FirstOrDefault();
if (firstOrDefault != null)
{
firstOrDefault.TotalJobs = Convert.ToInt32(jobsDataSet.Tables[1].Rows[0][0]);
}
return(jobs);
}
/// <summary>
/// Res the adjudicate.
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public long ReAdjudicate(TrackTask job)
{
if (job != null)
{
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("ReAdjudicateTask");
_databaseObj.AddInParameter(_databaseCommand, "@TaskId", DbType.Int64, Convert.ToInt64(job.TaskId));
_databaseObj.AddInParameter(_databaseCommand, "@UserName", DbType.String, job.UserName);
// Retrieve the results of the Stored Procedure
return(Convert.ToInt64(_databaseObj.ExecuteScalar(_databaseCommand)));
}
return(0);
}
/// <summary>
/// Jobs the count alert.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public int JobCountAlert(TrackTask data)
{
if (data != null)
{
_databaseCommand = _databaseObj.GetStoredProcCommand("GetUnVerifiedJobsCount");
_databaseObj.AddInParameter(_databaseCommand, "@FacilityID", DbType.Int64, data.FacilityId);
_databaseObj.AddOutParameter(_databaseCommand, "@UnVerifiedJobsCount", DbType.Int32, Int32.MaxValue);
_databaseObj.ExecuteNonQuery(_databaseCommand);
return(Convert.ToInt32(_databaseCommand.Parameters["@UnVerifiedJobsCount"].Value));
}
//returns 0 if any exception occurs
return(0);
}
/// <summary>
/// Updates task status in DB
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public int UpdateJobStatus(TrackTask job)
{
if (job != null)
{
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("UpdateJobStatus");
_databaseObj.AddInParameter(_databaseCommand, "@TaskId", DbType.Int64, Convert.ToInt64(job.TaskId));
_databaseObj.AddInParameter(_databaseCommand, "@RunningStatus", DbType.Int16,
Convert.ToInt16(job.Status));
_databaseObj.AddInParameter(_databaseCommand, "@UserName", DbType.String, job.UserName);
//// Retrieve the results of the Stored Procedure
_databaseObj.ExecuteScalar(_databaseCommand);
return(1);
}
return(0);
}
/// <summary>
/// Starts the new requests.
/// </summary>
/// <param name="allJobs">All jobs.</param>
/// <param name="connectionString">The connection string.</param>
private void StartNewRequests(IEnumerable <TrackTask> allJobs, string connectionString)
{
if (GlobalConfigVariable.IsLogEvent)
{
Log.LogInfo("New Job request", string.Empty);
}
if (allJobs != null)
{
foreach (
TrackTask newJob in
allJobs.Where(
newJob => newJob.Status != null && newJob.Status == Enums.JobStatus.Requested.ToString()))
{
if (GlobalConfigVariable.IsLogEvent)
{
Log.LogInfo("New Job status - " + newJob.Status + "........" + Enums.JobStatus.Requested,
string.Empty);
Log.LogInfo(
"Create Job - TaskId - JobStatus.Running.ToString()" + newJob.TaskId + ".. " +
Convert.ToInt16(Enums.JobStatus.Running), string.Empty);
}
_job = _jobManager.CreateJob(Convert.ToInt64(newJob.TaskId));
_job.RunJob(Convert.ToInt64(newJob.TaskId), newJob.FacilityId, connectionString);
TrackTask updatejob = new TrackTask
{
TaskId = newJob.TaskId,
Status =
Convert.ToString(
Convert.ToInt16(Enums.JobStatus.Running)),
UserName = "******"
};
if (GlobalConfigVariable.IsLogEvent)
{
Log.LogInfo(
"Update Job request - TaskId - JobStatus.Running.ToString()" + newJob.TaskId + ".. " +
Convert.ToInt16(Enums.JobStatus.Running), string.Empty);
}
_jobManager.UpdateJobStatus(updatejob);
}
}
}
/// <summary>
/// Updates Job status
/// </summary>
/// <returns></returns>
public ActionResult GetAllJobsAlertCount()
{
int facilityId = GetCurrentFacilityId();
if (facilityId != 0)
{
//FIXED-FEB16 Use Object initializer
TrackTask data = new TrackTask
{
FacilityId = facilityId,
UserName = GetCurrentUserName(),
ThresholdDaysToExpireJobs = GlobalConfigVariables.NumberOfDaysToDismissCompletedJobs
};
int jobsstatus = PostApiResponse <int>(Constants.JobsData, Constants.JobCountAlert, data);
int contractAlertCount = ContractAlertCount(facilityId);
return(Json(new { data = string.Format("{0}-{1}", jobsstatus, contractAlertCount) },
JsonRequestBehavior.AllowGet));
}
return(Json(new { data = string.Format("{0}-{1}", facilityId, facilityId) },
JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Res the adjudicate.
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public long ReAdjudicate(TrackTask job)
{
return(_jobStatusLogic.ReAdjudicate(job));
}
public void NotifyUser(TrackTask trackTask)
{
}
public List <TrackTask> GetAllJobs(TrackTask data)
{
return(_jobStatusLogic.GetAllJobs(data));
}
/// <summary>
/// Updates job status
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public int UpdateJobStatus(TrackTask job)
{
return(_jobStatusLogic.UpdateJobStatus(job));
}
private void DoTrackTaskMoveToStart()
{
var cancelTuple = cancellationTokenSource.FirstOrDefault(el => el.Item1 == TrackTask.MoveToStart.ToString());
if (cancelTuple == null)
{
cancelTuple = new Tuple<string, CancellationTokenSource>(TrackTask.MoveToStart.ToString(), new CancellationTokenSource());
cancellationTokenSource.Add(cancelTuple);
}
CancellationToken cancel = cancelTuple.Item2.Token;
if (cancel.IsCancellationRequested)
return;
_logger.With(l => l.Trace(string.Format("ToStart step = {0}", step)));
switch (_state.Track)
{
case TrackState.End:
if (_state.Lift != LiftState.Down && step < 1)
{
_trackTaskWait = () => _state.Lift == LiftState.Down;
_moveLiftDown();
step = 1;
break;
}
if (_state.OutDoorState != DoorState.Open && step < 2)
{
_trackTaskWait = () => _state.OutDoorState == DoorState.Open;
_openOutDoor();
step = 2;
break;
}
_moveTrackToLeft(_timings.TimeEndToLiftT2Start, _timings.TimeEndToLiftT2Stop, cancel);
_trackTaskWait = () => _state.Track == TrackState.Lift;
break;
case TrackState.Lift:
//if (step < 3)
//{
// _tightenTelfer2Left(_timings.TimeTightenLeftT2Stop, cancel);
// step = 3;
// break;
//}
if (_state.OutDoorState != DoorState.Close && step < 4)
{
_trackTaskWait = () => _state.OutDoorState == DoorState.Close;
_closeOutDoor();
step = 4;
break;
}
if (_state.Lift != LiftState.Up && step < 5)
{
_trackTaskWait = () => _state.Lift == LiftState.Up;
_moveLiftUp();
//_tightenTelfer2Left(_timings.TimeTightenLeftT2Start, _timings.TimeTightenLeftT2Stop, cancel);
step = 5;
break;
}
//if (step < 6)
//{
// _tightenTelfer2Left(_timings.TimeTightenLeftT2Stop, cancel);
// _trackTaskWait = () => _state.TightenTelfer2;
// step = 6;
// break;
//}
if (_state.InDoorState != DoorState.Open && step < 7)
{
_trackTaskWait = () => _state.InDoorState == DoorState.Open;
_openInDoor();
step = 7;
break;
}
_moveTrackToLeft(_timings.TimeLiftToStartT2Start, _timings.TimeLiftToStartT2Stop, cancel);
_trackTaskWait = () => _state.Track == TrackState.Start;
break;
case TrackState.Start:
if (_state.InDoorState != DoorState.Close && step < 8)
{
_trackTaskWait = () => _state.InDoorState == DoorState.Close;
_closeInDoor();
step = 8;
}
TrackTask = TrackTask.None;
_trackTaskWait = () => false;
break;
case TrackState.Error:
TrackTask = TrackTask.None;
_trackTaskWait = () => false;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Gets count of jobs alert
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public int JobCountAlert(TrackTask job)
{
return(_jobStatusLogic.JobCountAlert(job));
}
/// <summary>
/// Премещение телеги в начало пилорамы
/// </summary>
/// <param name="value"></param>
/// <param name="cancel"></param>
public void MoveTrackToStart(bool value)
{
var key = TrackTask.MoveToStart.ToString();
if (value)
{
if (cancellationTokenSource.All(el => el.Item1 != key) || cancellationTokenSource.Count == 0)
{
var cancel = new CancellationTokenSource();
cancellationTokenSource.Add(new Tuple<string, CancellationTokenSource>(key, cancel));
}
}
else
{
cancellationTokenSource.ForEach(el => { if (el.Item1 == key) el.Item2.Cancel(); });
cancellationTokenSource.RemoveAll(el => el.Item1 == key);
}
TrackTask = value ? TrackTask.MoveToStart : TrackTask.None;
if (value)
DoTrackTask();
}
private void DoTrackTaskMoveToEnd()
{
var cancelTuple =
cancellationTokenSource.FirstOrDefault(el => el.Item1 == TrackTask.MoveToEnd.ToString());
if (cancelTuple == null)
{
cancelTuple = new Tuple<string, CancellationTokenSource>(TrackTask.MoveToEnd.ToString(), new CancellationTokenSource());
cancellationTokenSource.Add(cancelTuple);
}
CancellationToken cancel = cancelTuple.Item2.Token;
if (cancel.IsCancellationRequested)
return;
_logger.With(l => l.Trace(string.Format("ToEnd step = {0}", step)));
switch (_state.Track)
{
case TrackState.Start:
//if (Lift != LiftState.Up && step < 1)
//{
// _trackTaskWait = () => Lift == LiftState.Up;
// _moveLiftUp();
// step = 1;
// break;
//}
if (_state.InDoorState != DoorState.Open && step < 2)
{
_trackTaskWait = () => _state.InDoorState == DoorState.Open;
_openInDoor();
step = 2;
break;
}
_logger.With(l => l.Trace(string.Format("{0}:step {1}; doorState = {2}",
_state.Track.ToString(), step, _state.InDoorState)));
_moveTrackToRight(_timings.TimeStartToLiftT2Start, _timings.TimeStartToLiftT2Stop, cancel);
_trackTaskWait = () => _state.Track == TrackState.Lift;
break;
case TrackState.Lift:
if (_state.InDoorState != DoorState.Close && step < 3)
{
_trackTaskWait = () => _state.InDoorState == DoorState.Close;
_closeInDoor();
step = 3;
break;
}
_switchSaw(true);
if (_state.Lift != LiftState.Down && step < 5)
{// Если лифт не внизу - опускаем
_trackTaskWait = () => _state.Lift == LiftState.Down;
var startDown = DateTime.Now;
var localCancel = cancel;
Task.Factory.StartNew(() =>
{ // Наопускание лифта дается максимум 22 сек, в противном случае - стоп
while (DateTime.Now - startDown < TimeSpan.FromSeconds(22) && !localCancel.IsCancellationRequested)
{
if(_state.Lift == LiftState.Down)
return;
Thread.Sleep(10);
}
_moveLiftDownSTOP();
EmergencyStop(true);
OnStopByTime(true);
}, localCancel);
_moveLiftDown(); //Опускаем лифт
step = 5;
break;
}
if (_state.OutDoorState != DoorState.Open && step < 6)
{// Если выходная дверка не открыта - открываем
_trackTaskWait = () => _state.OutDoorState == DoorState.Open;//Следующее обрабатываемое событие - выходная дверка открыта
_openOutDoor();//открытие выходной дверки
step = 6;
break;
}
_moveTrackToRight(_timings.TimeLiftToEndT2Start, _timings.TimeLiftToEndT2Stop, cancel);
_trackTaskWait = () => _state.Track == TrackState.End;
break;
case TrackState.End:
if (_state.OutDoorState != DoorState.Close && step < 7)
{
_switchSaw(false);
_trackTaskWait = () => false;
//_liftUpDown(_timings.TimeLiftUpDown, cancel);
_closeOutDoor();
step = 7;
}
//cancelTuple.Item2.Cancel();
//cancellationTokenSource.Remove(cancelTuple);
_trackTaskWait = () => false;
TrackTask = TrackTask.None;
if(_runQuest)
UpdateStateAvailableGoToBaseState();
break;
case TrackState.Error:
TrackTask = TrackTask.None;
_trackTaskWait = () => false;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Updates the job verified status.
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public bool UpdateJobVerifiedStatus(TrackTask job)
{
return(_jobStatusLogic.UpdateJobVerifiedStatus(job));
}
/// <summary>
/// Updates the job status.
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public int UpdateJobStatus(TrackTask job)
{
int jobStatus = _jobsStatusRepository.UpdateJobStatus(job);
return(jobStatus);
}
public long ReAdjudicate(TrackTask job)
{
return(_jobsStatusRepository.ReAdjudicate(job));
}
/// <summary>
/// Updates the job verified status.
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public bool UpdateJobVerifiedStatus(TrackTask job)
{
return(_jobsStatusRepository.UpdateJobVerifiedStatus(job));
}
/// <summary>
/// Determines whether [is model exist] [the specified job].
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public bool IsModelExist(TrackTask job)
{
return(_jobStatusLogic.IsModelExist(job));
}
/// <summary>
/// UpdateJobStatus
/// </summary>
/// <param name="task"></param>
private void UpdateJobStatus(TrackTask task)
{
_claimSelectorRepository.UpdateJobStatus(task);
}
void _state_CorrectStart(object sender, EventArgs e)
{
if(!_runQuest)
return;
if (TrackTask == TrackTask.None && Track == TrackState.Start)
{
TrackTask = TrackTask.MoveToEnd;
DoTrackTask();
}
}
/// <summary>
/// Determines whether [is model exist] [the specified job].
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public bool IsModelExist(TrackTask job)
{
return(_jobsStatusRepository.IsModelExist(job));
}
/// <summary>
/// Остановить оба телфера
/// </summary>
private void _stopTrack()
{
var deleteCancels = new List<Tuple<string, CancellationTokenSource>>();
foreach (var cancelTuple in cancellationTokenSource)
{
if (cancelTuple.Item1 == TrackTask.ToString())
{
cancelTuple.Item2.Cancel();
deleteCancels.Add(cancelTuple);
}
}
deleteCancels.ForEach(el => cancellationTokenSource.Remove(el));
_logger.With(l => l.Trace(string.Format("_stopTrack")));
SetRelay(new Dictionary<string, bool>(){
{StrConst.TumblerTrackT2Forward, false},
{StrConst.TumblerTrackT2Back, false}});
_trackTaskWait = () => false;
TrackTask = TrackTask.None;
}
public List <TrackTask> GetAllJobs(TrackTask data)
{
return(_jobsStatusRepository.GetAllJobs(data));
}
/// <summary>
/// Экстренный останов
/// </summary>
/// <param name="value"></param>
public void EmergencyStop(bool value)
{
_logger.With(l => l.Trace("EmergencyStop"));
_runQuest = false;
_deviceManager.SetRelayState(_relays.ToDictionary(el => el.Value, el => el.Key == StrConst.TumblerTrackT1Back));
cancellationTokenSource.ForEach(el => el.Item2.Cancel());
cancellationTokenSource.Clear();
_state.TightenTelfer2 = false;
TrackTask = TrackTask.None;
_trackTaskWait = () => false;
_DoPeriodicLampOn(false);
}
/// <summary>
/// Gets count of Job alerts.
/// </summary>
/// <param name="job">The job.</param>
/// <returns></returns>
public int JobCountAlert(TrackTask job)
{
return(_jobsStatusRepository.JobCountAlert(job));
}
/// <summary>
/// Приведение в начальное состояние
/// </summary>
public void GoToBaseState()
{
if (!_runQuest )//|| !_state.IsLockTrack ) TODO: off lock
return;
_DoPeriodicLampOn(false);
_runQuest = false;
if (Track == TrackState.End && TrackTask == TrackTask.None)
{
TrackTask = TrackTask.MoveToStart;
DoTrackTask();
}
}
