public void run(object item)
{
Download_Data_Info inf = item as Download_Data_Info;
//Trend_Analyser_Connector.Trend_Analyser_Module_2_Download_Data(inf.symbol, inf.fYear, inf.fMonth, inf.fDay, inf.tYear, inf.tMonth, inf.tDay);
if (UpdateEvent != null)
{
UpdateEvent.Invoke();
}
Interlocked.Increment(ref i);
if (i == count)
{
prog.Close();
if (CompletedEvent != null)
{
CompletedEvent.Invoke();
}
}
else
{
prog.setPercentage(i * 100 / count);
}
}
private void SignalReady()
{
switch (signalReadyHitCounter)
{
case 0:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady for MANUAL VendorRepairBegin job.");
signalReadyHitCounter++;
break;
case 1:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady for giving approval to a normal FC's job's StartJobStep.");
signalReadyHitCounter++;
break;
case 2:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady for MANUAL VendorRepairEnd job.");
signalReadyHitCounter++;
NotificationContext.ImpactedInstances = new List <ImpactedInstance>
{
new ImpactedInstance("RoleA_IN_1", new List <ImpactReason> {
ImpactReason.Reboot
})
};
break;
case 3:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady for giving approval to a normal FC's job's CompleteJobStep.");
signalReadyHitCounter++;
CompletedEvent.Set();
break;
}
}
private void WebRequestOperationCompleted(AsyncOperation op)
{
UnityWebRequestAsyncOperation remoteReq = op as UnityWebRequestAsyncOperation;
var webReq = remoteReq.webRequest;
if (string.IsNullOrEmpty(webReq.error))
{
downloadHandler = webReq.downloadHandler as DownloadHandlerAssetBundle;
provideHandle.Complete(this, true, null);
}
else
{
downloadHandler = webReq.downloadHandler as DownloadHandlerAssetBundle;
downloadHandler.Dispose();
downloadHandler = null;
if (retries++ < options.RetryCount)
{
UDebug.LogFormat("Web request {0} failed with error '{1}', retrying ({2}/{3})...", webReq.url, webReq.error, retries, options.RetryCount);
BeginOperation();
}
else
{
var exception = new Exception(string.Format("RemoteAssetBundleProvider unable to load from url {0}, result='{1}'.", webReq.url, webReq.error));
CompletedEvent?.Invoke(null, false, exception);
}
}
webReq.Dispose();
}
private void SignalReady()
{
switch (signalReadyHitCounter)
{
case 0:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady for giving approval to FC's job.");
signalReadyHitCounter++;
break;
case 1:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady after job execution and completion of health check from CM.");
Verify.AreEqual(state, State.FromCMAckedCompletedJob,
string.Format(CultureInfo.InvariantCulture, "SignalReady invoked after after health checks from CM to ack completed job: {0}", state));
signalReadyHitCounter++;
break;
case 2:
Trace.ConsoleWriteLine(TraceType, "IS: Invoking SignalReady 2nd time since MR/FC missed out the previous CompleteJobStep ack.");
Verify.AreEqual(state, State.FromISSendSignalReady,
string.Format(CultureInfo.InvariantCulture, "SignalReady invoked 2nd time to re-ack completed job: {0}", state));
CompletedEvent.Set();
break;
}
}
private async Task HandleReceivedMessage(IReceiverClient receiverClient, ISenderClient senderClient,
Message message, CancellationToken token)
{
var eventName = message.Label;
var messageData = Encoding.UTF8.GetString(message.Body);
await ProcessEvent(eventName, messageData);
// Complete the message so that it is not received again.
await receiverClient.CompleteAsync(message.SystemProperties.LockToken);
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
if (eventType != null && eventType != typeof(CompletedEvent))
{
var eventData = JObject.Parse(messageData);
if (Guid.TryParse((string)eventData["Id"], out var eventId))
{
var publisherId = (string)eventData["PublisherId"];
var completedEvent = new CompletedEvent(eventId, publisherId);
await PublishEventAsync(completedEvent, senderClient);
}
}
}
protected override void Run(CancellationToken cancellationToken)
{
var tenantJob = TenantJobHelper.CreateNewTenantJob();
PolicyAgentService.CreateTenantJob(tenantJob);
RepairManager.CompletedEvent.WaitOne();
CompletedEvent.Set();
}
private void SignalError(string errorDescription)
{
Trace.ConsoleWriteLine(TraceType,
"IS: Invoking SignalError after job execution and task failure from CM. Error description: {0}", errorDescription);
Verify.AreEqual(state, State.FromCMHealthCheckFailed,
string.Format(CultureInfo.InvariantCulture, "SignalError invoked after health checks from CM failed. Workflow state: {0}", state));
CompletedEvent.Set();
}
protected override void AfterUpdateRepairExecutionState(Guid activityId, MockRepairTask repairTask)
{
base.AfterUpdateRepairExecutionState(activityId, repairTask);
if (repairTask.State == RepairTaskState.Completed)
{
CompletedEvent.Set();
}
}
protected override void Run(CancellationToken cancellationToken)
{
IRepairTask repairTask = CreateRepairTask();
RepairManager.CreateRepairTaskAsync(Guid.NewGuid(), repairTask).GetAwaiter().GetResult();
RepairManager.CompletedEvent.WaitOne();
PolicyAgentService.CompletedEvent.WaitOne();
CompletedEvent.Set();
}
protected override void Run(CancellationToken cancellationToken)
{
var tenantJob = TenantJobHelper.CreateNewTenantJob(ImpactActionEnum.PlatformUpdate); // Root HE
// this kicks things off
PolicyAgentService.CreateTenantJob(tenantJob);
RepairManager.CompletedEvent.WaitOne();
CompletedEvent.Set();
}
private void HandleJobCompleted(object sender, CompletedEvent e)
{
var job = (Job)sender;
_hubContext.Clients.Group(job.Id).jobCompleted(job.Id);
job.ProgressChanged -= HandleJobProgressChanged;
job.Completed -= HandleJobCompleted;
job.VerboseReport -= HandleJobVerboseMessage;
}
private void OnComplete(AsyncOperationHandle <IList <object> > handle)
{
handle.Completed -= OnComplete;
if (!_isDisposed && handle.Status == AsyncOperationStatus.Succeeded)
{
Assets = handle.Result.ToList();
}
CompletedEvent?.Invoke(this, handle.Status);
}
protected override void Run(CancellationToken cancellationToken)
{
var tenantJob = TenantJobHelper.CreateNewTenantJob(ImpactActionEnum.PlatformMaintenance);
// this kicks things off
PolicyAgentService.CreateTenantJob(tenantJob);
ProcessCloser.ExitEvent.WaitOne();
CompletedEvent.Set();
}
public async Task <ResultWrapper <CompletedEvent> > CreateEvent(CompletedEvent newEvent, TokenDto token)
{
if (!TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> error = new List <ErrorResult>();
error.Add(new ErrorResult(401, "Invalid token."));
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(tk => tk.token.Equals(token.AccessToken)).FirstOrDefault());
return(new ResultWrapper <CompletedEvent>(null, error));
}
var errors = eventValid.ValidateEventCreation(newEvent);
if (errors.Count() > 0)
{
return(new ResultWrapper <CompletedEvent>(null, errors));
}
CompletedEvent existEvent = null;
if (newEvent.EventId.HasValue)
{
existEvent = await GetEvent(newEvent.EventId.Value);
}
if (existEvent != null)
{
return(await UpdateEvent(existEvent, newEvent, token));
}
Event ev = Mapper.Map <Event>(newEvent);
Location location = Mapper.Map <Location>(newEvent.Location);
// Insert a new location in DB
_unitOfWork.LocationRepo.AddAsync(location);
await _unitOfWork.LocationRepo.SaveAsync();
// Get user from token
var userId = TokenValidation.GetUserIdFromToken(token, _unitOfWork);
ev.Author = userId;
ev.Location = location.LocationId;
_unitOfWork.EventRepo.AddAsync(ev);
await _unitOfWork.EventRepo.SaveAsync();
Category c = _unitOfWork.categoriesRepo.Find(e => e.Category1.Equals(newEvent.Category)).FirstOrDefault();
EventHasCategories ehc = new EventHasCategories();
ehc.EventId = ev.EventId;
ehc.CategoryId = c.CategoryId;
_unitOfWork.eventHasCategories.Add(ehc);
await _unitOfWork.eventHasCategories.SaveAsync();
return(new ResultWrapper <CompletedEvent>(newEvent, null));
}
public virtual void SetCompleted(bool success, ResultError errorCode)
{
Success = success;
ErrorCode = errorCode;
#if DEBUG
#elif TRACE
Traces = Debugging.CollectTraces();
#endif
CompletedEvent.Set();
}
protected override void Run(CancellationToken cancellationToken)
{
IRepairTask repairTask = CreateRepairTask();
RepairManager.CreateRepairTaskAsync(Guid.NewGuid(), repairTask).GetAwaiter().GetResult();
((MockRepairTask)repairTask).CreatedTimestamp = DateTime.UtcNow;
RepairManager.CompletedEvent.WaitOne();
CompletedEvent.Set();
}
private PatientInfo CreatePatientInfoFromEvent(CompletedEvent completedEvent)
{
return(new PatientInfo
{
NHSNumber = completedEvent.Period.Pathway.Patient.NHSNumber,
PatientName = completedEvent.Period.Pathway.Patient.Name,
DateOfBirth = completedEvent.Period.Pathway.Patient.DateOfBirth,
Age = completedEvent.Period.Pathway.Patient.GetAgeAt(_clock.TodayDate),
Hospital = completedEvent.Clinician.Hospital.Name,
PpiNumber = completedEvent.Period.Pathway.PPINumber,
PeriodId = completedEvent.Period.Id
});
}
private async Task <ResultWrapper <CompletedEvent> > UpdateEvent(CompletedEvent existingEvent, CompletedEvent newEvent, TokenDto token)
{
var tokenOwnerId = TokenValidation.GetUserIdFromToken(token, _unitOfWork);
if (tokenOwnerId != existingEvent.Author.UserId)
{
List <ErrorResult> error = new List <ErrorResult>();
error.Add(new ErrorResult(401, "Unauthorized operation."));
return(new ResultWrapper <CompletedEvent>(null, error));
}
// Update Location
var location = _unitOfWork.LocationRepo.Find(l => l.LocationId == existingEvent.Location.LocationId).FirstOrDefault();
location.Latitude = newEvent.Location.Latitude;
location.Longitude = newEvent.Location.Longitude;
location.Address = newEvent.Location.Address;
await _unitOfWork.LocationRepo.SaveAsync();
// Update Event
var eventToUpdate = _unitOfWork.EventRepo.Find(x => x.EventId == existingEvent.EventId).FirstOrDefault();
eventToUpdate.Description = newEvent.Description;
eventToUpdate.StartDate = newEvent.StartDate;
eventToUpdate.EndDate = newEvent.EndDate;
eventToUpdate.Radius = newEvent.Radius;
eventToUpdate.Name = newEvent.Name;
await _unitOfWork.EventRepo.SaveAsync();
EventHasCategories evCategories = _unitOfWork.eventHasCategories.Find(evt => evt.EventId == newEvent.EventId).FirstOrDefault();
Category cf = _unitOfWork.categoriesRepo.Get(evCategories.CategoryId);
if (!cf.Category1.Equals(newEvent.Category))
{
Category newCate = _unitOfWork.categoriesRepo.Find(ct => ct.Category1.Equals(newEvent.Category)).FirstOrDefault();
_unitOfWork.eventHasCategories.Remove(evCategories);
EventHasCategories newCategory = new EventHasCategories
{
CategoryId = newCate.CategoryId,
EventId = evCategories.EventId
};
_unitOfWork.eventHasCategories.Add(newCategory);
await _unitOfWork.eventHasCategories.SaveAsync();
}
return(new ResultWrapper <CompletedEvent>(newEvent, null));
}
protected override void Run(CancellationToken cancellationToken)
{
var tenantJob = TenantJobHelper.CreateNewTenantJob(ImpactActionEnum.PlatformMaintenance);
// this kicks things off
PolicyAgentService.CreateTenantJob(tenantJob);
ProcessCloser.ExitEvent.WaitOne();
var elapsed = DateTimeOffset.UtcNow - startTime;
Assert.IsTrue(elapsed >= TimeSpan.FromSeconds(MaxRetryDurationInSeconds), "Verifying if max retry duration is exceeded");
CompletedEvent.Set();
}
private DateTime?ComputeDateReference(DestinationEvent destinationEvent, CompletedEvent currentCompletedEvent, Period period)
{
var destinationEventForDateReferenceForTarget = destinationEvent.EventForDateReferenceForTarget == null ? (EventCode?)null : destinationEvent.EventForDateReferenceForTarget.Code;
var eventReference = period.CompletedEvents
.OrderByDescending(e => e.EventDate)
.FirstOrDefault(e => e.Period.Pathway.PPINumber == currentCompletedEvent.Period.Pathway.PPINumber && e.Name.Code == destinationEventForDateReferenceForTarget);
if (eventReference != null)
{
return(eventReference.EventDate);
}
return(null);
}
protected override void AfterUpdateRepairExecutionState(Guid activityId, MockRepairTask repairTask)
{
base.AfterUpdateRepairExecutionState(activityId, repairTask);
if (repairTask.State == RepairTaskState.Claimed && !repairTask.ClaimedTimestamp.HasValue)
{
repairTask.ClaimedTimestamp = DateTime.UtcNow;
}
if (repairTask.State == RepairTaskState.Completed && repairTask.ResultStatus == RepairTaskResult.Cancelled)
{
CompletedEvent.Set();
}
}
public void Dispose()
{
CompletedEvent.RemoveAllListeners();
SetUrl(string.Empty);
if (mAsyncOperation != default)
{
mAsyncOperation.completed -= CheckResult;
}
mAsyncOperation = default;
mRequester = default;
ResultData = default;
Assets = default;
}
public virtual void Execute()
{
var cts = new CancellationTokenSource();
Coordinator.RunAsync(0, cts.Token);
CompletedEvent.WaitOne(TimeSpan.FromSeconds(TestExecutionTimeInSeconds));
cts.Cancel();
// Wait for the IS to return gracefully
Task.Delay(TimeSpan.FromSeconds(2)).Wait();
traceType.ConsoleWriteLine("Completed executing workflow. Time taken: {0}", stopwatch.Elapsed);
}
private DateTime?GetTargetReferenceDate(CompletedEvent currentCompletedEvent, UnitOfWork unitOfWork)
{
var destinationEvent = unitOfWork.DestinationEvents.FirstOrDefault(e => e.DestinationName.Code == currentCompletedEvent.Name.Code);
if (destinationEvent == null || destinationEvent.TargetNumberOfDays == null || destinationEvent.EventForDateReferenceForTarget == null)
{
return(null);
}
var referenceEventForTargetDate = currentCompletedEvent.Period.CompletedEvents.OrderBy(ev => ev.EventDate).ToList().LastOrDefault(ev => ev.Name.Code == destinationEvent.EventForDateReferenceForTarget.Code);
if (referenceEventForTargetDate == null)
{
return(null);
}
return(referenceEventForTargetDate.EventDate.AddDays((int)destinationEvent.TargetNumberOfDays).AddDays(currentCompletedEvent.Period.GetNumberOfPausedDays(currentCompletedEvent.EventDate, referenceEventForTargetDate.EventDate)));
}
private void OnPlayAssetPackRequestCompleted(string assetPackName, PlayAssetPackRequest request)
{
if (request.Error != AssetDeliveryErrorCode.NoError)
{
CompletedEvent?.Invoke(this, false, new Exception($"Error downloading error pack: {request.Error}"));
return;
}
if (request.Status != AssetDeliveryStatus.Available)
{
CompletedEvent?.Invoke(this, false, new Exception($"Error downloading status: {request.Status}"));
return;
}
var assetLocation = request.GetAssetLocation(assetPackName);
requestOperation = AssetBundle.LoadFromFileAsync(assetLocation.Path, /* crc= */ 0, assetLocation.Offset);
requestOperation.completed += LocalRequestOperationCompleted;
}
void Complete()
{
StopAllCoroutines();
textTMP.text = current.Text;
completed = true;
queue.Dequeue();
CompletedEvent?.Invoke(this);
if (queue.Count > 0)
{
ShowNext();
}
else
{
Hide();
}
}
private void BeginOperation(string assetPackName)
{
Debug.LogFormat("[{0}.{1}] assetPackName={2}", nameof(AssetPackBundleSyncResource), nameof(BeginOperation), assetPackName);
playAssetPackRequest = PlayAssetDelivery.RetrieveAssetPackAsync(assetPackName);
Exception exception = null;
if (playAssetPackRequest.IsDone)
{
var assetLocation = playAssetPackRequest.GetAssetLocation(assetPackName);
assetBundle = AssetBundle.LoadFromFile(assetLocation.Path, /* crc= */ 0, assetLocation.Offset);
}
else
{
exception = new Exception($"Asset Pack was not retrieved Synchronously: '{assetPackName}'.");
}
CompletedEvent?.Invoke(this, assetBundle != null, exception);
}
public IEnumerable <ErrorResult> ValidateEventCreation(CompletedEvent _event)
{
IEnumerable <ErrorResult> errors = new List <ErrorResult>();
if (_event.StartDate != null && _event.EndDate != null)
{
errors.Union(ValidateDates(_event.StartDate, _event.EndDate));
}
if (_event.Location == null)
{
// TODO Validar locations
}
errors.Union(ValidateLocation(_event.Location.Longitude, _event.Location.Latitude));
return(errors);
}
public async Task Execute(BehaviorContext <RequestState, RequestCompleted> context, Behavior <RequestState, RequestCompleted> next)
{
if (!context.Instance.ExpirationTime.HasValue || context.Instance.ExpirationTime.Value > DateTime.UtcNow)
{
if (!context.TryGetPayload(out ConsumeContext <RequestCompleted> consumeContext))
{
throw new ArgumentException("The ConsumeContext was not present", nameof(context));
}
string body = GetResponseBody(consumeContext, context.Instance);
IPipe <SendContext> pipe = new CompletedMessagePipe(context.GetPayload <ConsumeContext <RequestCompleted> >(), context.Instance, body);
var endpoint = await context.GetSendEndpoint(context.Instance.ResponseAddress).ConfigureAwait(false);
var scheduled = new CompletedEvent();
await endpoint.Send(scheduled, pipe).ConfigureAwait(false);
}
await next.Execute(context).ConfigureAwait(false);
}
private bool IsCompletedEventMatched(CompletedEvent completedEvent, PeriodEventsFilterInputInfo periodEventsFilterInput)
{
if (periodEventsFilterInput == null)
{
return(true);
}
var isCompletedEventMatched = (String.IsNullOrEmpty(periodEventsFilterInput.Specialty) || completedEvent.Clinician.Specialty.Name.ToLowerInvariant().Contains(periodEventsFilterInput.Specialty.ToLowerInvariant())) &&
(periodEventsFilterInput.TargetYear == null || (completedEvent.TargetDate != null && completedEvent.TargetDate.Value.Year == periodEventsFilterInput.TargetYear)) &&
(periodEventsFilterInput.ActualYear == null || completedEvent.EventDate.Year == periodEventsFilterInput.ActualYear) &&
(string.IsNullOrEmpty(periodEventsFilterInput.EventDescription) || completedEvent.Name.Description.Contains(periodEventsFilterInput.EventDescription));
if (periodEventsFilterInput.Breaches == null)
{
return(isCompletedEventMatched);
}
if (periodEventsFilterInput.Breaches < 0)
{
return(isCompletedEventMatched && completedEvent.PostBreachDays != null && completedEvent.PostBreachDays.Value > 0);
}
return(false);
}
public async Task <JsonResult> CreateEvent([FromBody] CreateEventDto newEvent)
{
DateTime startEventTime;
DateTime endEventTime;
if (newEvent == null || newEvent.Token == null || newEvent.Event == null || newEvent.Event.Location == null || !DateTime.TryParse(newEvent.Event.StartDate, out startEventTime) ||
!DateTime.TryParse(newEvent.Event.EndDate, out endEventTime))
{
Response.StatusCode = 400;
return(new JsonResult("Bad Request"));
}
TokenDto token = TokenInDto.ConvertFromDTO(newEvent.Token);
// EventDto to Model
CompletedEvent completedEvent = new CompletedEvent
{
Description = newEvent.Event.Description,
Name = newEvent.Event.Name,
Location = newEvent.Event.Location,
State = newEvent.Event.State,
StartDate = startEventTime,
EndDate = endEventTime,
Radius = newEvent.Event.Radius,
Category = newEvent.Event.Category,
EventId = newEvent.Event.EventId != null ? newEvent.Event.EventId : 0
};
var events = await this._eventService.CreateEvent(completedEvent, token);
if (events.Errors != null)
{
Response.StatusCode = 401;
return(new JsonResult(events.Errors));
}
Response.StatusCode = 200;
return(new JsonResult(events.Result));
}
private void CompletedARequest(object sender, CompletedEvent e)
{
BeginInvoke((Action)(() => statusStrip.Items[0].Text = e.Method + " completed!"));
}
protected virtual void OnCompleted(CompletedEvent completedEvent)
{
var handler = Completed;
if (handler != null) handler(this, completedEvent);
}
