public async Task<RequestResultState> ExecuteRequestAsync(Request currentRequest)
{
FailToken token = new FailToken();
if (FindOneAction)
{
currentRequest.ResolvedActions = new List<ResolvedAction>() {new ResolvedAction()};
}
return token.Fail ? RequestResultState.Failed : RequestResultState.Success;
}
public override IList<ResolvedAction> GetResolvedActionsForPidAndEvent(Request request)
{
if (ShouldFail != null)
{
FailToken token = new FailToken();
ShouldFail(request, token);
if (token.Fail)
{
return null;
}
}
return new List<ResolvedAction>() {new ResolvedAction()};
}
public async Task<int> CreateRequest(BeaconEventArgs beaconEventArgs)
{
int requestId = SdkData.NextId();
Logger.Debug("Resolver: Beacon " + beaconEventArgs.Beacon.Id1 + " " + beaconEventArgs.Beacon.Id2 + " " + beaconEventArgs.Beacon.Id3 + " ---> Request: " + requestId);
Request request = new Request(beaconEventArgs, requestId);
if (SynchronResolver)
{
await Resolve(request);
Finished?.Invoke();
}
else
{
AddAsynchronRequest(request);
}
return requestId;
}
/// <summary>
/// Resolves the beacon actions associated with the given PID and event type.
/// </summary>
/// <returns>A list of actions based on the given values or an empty list if none found.</returns>
public virtual IList<ResolvedAction> GetResolvedActionsForPidAndEvent(Request request)
{
List<ResolvedAction> actions = new List<ResolvedAction>();
foreach (ResolvedAction item in ResolvedActions)
{
if (item.BeaconPids.Contains(request.BeaconEventArgs.Beacon.Pid) && (item.EventTypeDetectedByDevice == request.BeaconEventArgs.EventType ||
(item.EventTypeDetectedByDevice == BeaconEventType.EnterExit && (request.BeaconEventArgs.EventType == BeaconEventType.Enter || request.BeaconEventArgs.EventType == BeaconEventType.Exit))))
{
actions.Add(item);
}
}
return actions;
}
private void AddAsynchronRequest(Request request)
{
RequestQueue.Enqueue(request);
Logger.Trace("Add new request {0}", request.RequestId);
if (RequestQueue.Count > 0 &&
(WorkerTask == null || WorkerTask.Status == TaskStatus.Canceled || WorkerTask.Status == TaskStatus.Faulted || WorkerTask.Status == TaskStatus.RanToCompletion))
{
CancelToken = new CancellationTokenSource();
(WorkerTask = Task.Run(ServeNextRequest, CancelToken.Token)).ConfigureAwait(false);
}
}
private async Task Resolve(Request request)
{
Logger.Trace("take next request " + request?.RequestId + " "+request?.BeaconEventArgs.EventType);
if (request == null)
{
FailedToResolveActions?.Invoke(this, "request is null");
return;
}
request.TryCount++;
if (request.BeaconEventArgs.EventType == BeaconEventType.Unknown)
{
request.BeaconEventArgs.EventType = BeaconManager.ResolveBeaconState(request.BeaconEventArgs.Beacon);
}
Logger.Trace("request resolved " + request.BeaconEventArgs.EventType);
if (request.BeaconEventArgs.EventType == BeaconEventType.None)
{
return;
}
if (request.BeaconEventArgs.EventType == BeaconEventType.Enter && EventHistory != null)
{
await EventHistory.SaveBeaconEventAsync(request.BeaconEventArgs, request.BeaconEventArgs.Location);
}
RequestResultState requestResult = RequestResultState.Failed;
try
{
Logger.Debug("LayoutManager.InternalExecuteRequestAsync(): Request ID is " + request.RequestId);
if (request.BeaconEventArgs?.Beacon != null && await ServiceManager.LayoutManager.VerifyLayoutAsync() && ServiceManager.LayoutManager.Layout != null)
{
request.ResolvedActions = ServiceManager.LayoutManager.Layout.GetResolvedActionsForPidAndEvent(request);
foreach (ResolvedAction resolvedAction in request.ResolvedActions)
{
if (resolvedAction != null && resolvedAction.BeaconAction != null)
{
resolvedAction.BeaconAction.Id = request.RequestId;
}
}
requestResult = RequestResultState.Success;
}
}
catch (ArgumentNullException ex)
{
request.ErrorMessage = ex.Message;
requestResult = RequestResultState.Failed;
}
catch (Exception ex)
{
request.ErrorMessage = ex.Message;
requestResult = RequestResultState.Failed;
}
Logger.Debug("request result " + request.RequestId + " " + requestResult);
switch (requestResult)
{
case RequestResultState.Failed:
{
if (request.TryCount >= request.MaxNumberOfRetries)
{
Logger.Info("OnRequestServed: Request with ID " + request.RequestId + " failed");
FailedToResolveActions?.Invoke(this, request.ErrorMessage);
}
else
{
int numberOfTriesLeft = request.MaxNumberOfRetries - request.TryCount;
Logger.Debug("RequestQueue.ServeNextRequestAsync(): Request with ID "
+ request.RequestId + " failed, will try "
+ numberOfTriesLeft + " more " + (numberOfTriesLeft > 1 ? "times" : "time"));
await Resolve(request);
}
break;
}
case RequestResultState.Success:
{
if (ActionsResolved != null)
{
ResolvedActionsEventArgs eventArgs = new ResolvedActionsEventArgs();
eventArgs.ResolvedActions = request.ResolvedActions;
eventArgs.RequestId = request.RequestId;
eventArgs.BeaconEventType = request.BeaconEventArgs.EventType;
eventArgs.Location = await ServiceManager.LocationService.GetGeoHashedLocation();
if (request.BeaconEventArgs != null && request.BeaconEventArgs.Beacon != null)
{
eventArgs.BeaconPid = request.BeaconEventArgs.Beacon.Pid;
}
ActionsResolved(this, eventArgs);
}
break;
}
}
}
