private void Resolve(ResolveRequestDTO req)
{
Entity <DataType> .ResolveStarted(req);
this.resolver.Resolve(req, (r =>
{
if (ResolveErrorHelper.HandledError(req.key, r, Entity <DataType> .RESOLVE_FAILED, debug: this.debug))
{
return;
}
var resultItem = r.item;
if (!this.isOkStatus(resultItem.status))
{
NotificationBus.Send(
Entity <DataType> .RESOLVE_FAILED,
ResolveFailedDTO.For(req, resultItem.status)
);
return;
}
Entity <DataType> .ResolveSucceeded(
new ResolveSucceededDTO <DataType> {
key = req.key,
id = resultItem.id,
resolveRequestId = req.resolveRequestId,
data = resultItem.data,
timestamp = resultItem.timestamp,
maxAgeSecs = resultItem.maxAgeSecs
});
}));
}
/// <summary>
/// Wraps call to ResolveAsync in a request
/// </summary>
virtual public Request <ResolveResultDTO <DataType> > Resolve(
ResolveRequestDTO req,
Action <Request <ResolveResultDTO <DataType> > > callback = null
)
{
return(this.helper.Resolve(req, callback));
}
#pragma warning disable 1998
virtual public async Task <ResolveResultDTO <DataType> > ResolveAsync(
ResolveRequestDTO req
)
#pragma warning restore 1998
{
return(GetStoredEntityAsResolveResult(req));
}
public ResolveResultDTO <DataType> GetStoredEntityAsResolveResult(ResolveRequestDTO req)
{
if (string.IsNullOrEmpty(req.key))
{
return(ResolveResultDTO <DataType> .ResolveError(
req, "null or empty key"
));
}
var store = Services.Require <HasEntities <DataType> >();
Entity <DataType> entity;
if (!store.GetEntity(req.key, out entity) || !entity.status.hasResolved)
{
return(string.IsNullOrEmpty(entity.status.resolveError) ?
ResolveResultDTO <DataType> .ResolveNotFound(req) :
ResolveResultDTO <DataType> .ResolveError(
req, entity.status.resolveError
));
}
var status = entity.status;
return(ResolveResultDTO <DataType> .ResolveSucceeded(
req, entity.id, entity.data, status.maxAgeSecs, status.timestamp
));
}
public static int RequestResolve(
ResolveRequestDTO req,
Opts opts = Opts.RequireReceiver
)
{
N.Send(RESOLVE_REQUESTED, req, opts);
return(req.resolveRequestId);
}
public static ResolveFailedDTO For(ResolveRequestDTO req, string error)
{
return(new ResolveFailedDTO
{
key = req.key,
error = error,
resolveRequestId = req.resolveRequestId
});
}
public Request <ResolveResultDTO <DataType> > Resolve(
ResolveRequestDTO req,
Action <Request <ResolveResultDTO <DataType> > > callback = null)
{
var result = GetStoredEntityAsResolveResult(req);
var request = new LocalRequest <ResolveResultDTO <DataType> >(result);
request.Execute(callback);
return(request);
}
/// <summary>
/// Wraps call to ResolveAsync in a request
/// </summary>
public Request <ResolveResultDTO <DataType> > Resolve(
ResolveRequestDTO req,
Action <Request <ResolveResultDTO <DataType> > > callback = null
)
{
var r = new TaskRequest <ResolveResultDTO <DataType> >(ResolveAsync(req));
r.Execute(callback);
return(r);
}
public static ResolveResultDTO <DataType> ResolveNotFound(
ResolveRequestDTO req
)
{
return(new ResolveResultDTO <DataType>
{
status = ResolveStatusCode.NOT_FOUND,
message = "not found",
id = req.key,
key = req.key,
resolveRequestId = req.resolveRequestId,
timestamp = DateTimeOffset.Now
});
}
public static ResolveResultDTO <DataType> ResolveError(
ResolveRequestDTO req,
string error
)
{
return(new ResolveResultDTO <DataType>
{
status = ResolveStatusCode.ERROR,
message = error,
id = req.key,
key = req.key,
resolveRequestId = req.resolveRequestId,
timestamp = DateTimeOffset.Now
});
}
public static ResolveResultDTO <DataType> ResolveError(
ResolveRequestDTO req,
Exception error,
string message = null
)
{
return(new ResolveResultDTO <DataType>
{
status = ResolveStatusCode.ERROR,
message = !string.IsNullOrEmpty(message)? message: error.Message,
id = req.key,
key = req.key,
resolveRequestId = req.resolveRequestId,
timestamp = DateTimeOffset.Now
});
}
public void Execute(ResolveRequestDTO req)
{
var key = req.key;
if (string.IsNullOrEmpty(key))
{
#if UNITY_EDITOR || DEBUG_UNSTRIP
Debug.LogWarningFormat(
"[{0}] null or empty key passed to resolve for {1}",
Time.frameCount, typeof(DataType).Name
);
Entity <DataType> .ResolveFailed(new ResolveFailedDTO
{
key = "",
error = "null or empty key passed to resolve"
});
return;
#endif
}
if (!req.forceUpdate)
{
var resolveAdvice = ResolveAdviceHelper.AdviseOnAndSendErrorIfCoolingDown(
key, hasData, Entity <DataType> .RESOLVE_FAILED, debug: this.debug
);
switch (resolveAdvice)
{
case ResolveAdvice.PROCEED:
break;
default:
#if UNITY_EDITOR || DEBUG_UNSTRIP
if (this.debug)
{
Debug.LogFormat(
"[{0}] will skip resolve for {1} with key {2} on advice {3}",
Time.frameCount, typeof(DataType).Name, key, resolveAdvice
);
}
#endif
return;
}
}
Resolve(req);
}
private async void Resolve(ResolveRequestDTO req)
{
#if UNITY_EDITOR || DEBUG_UNSTRIP
if (this.debug)
{
Debug.LogFormat(
"[{0}] will resolve {1} with key {2}",
Time.frameCount, typeof(DataType).Name, req.key
);
}
#endif
Entity <DataType> .ResolveStarted(req);
try
{
var resultItem = await this.resolver.ResolveAsync(req);
if (!this.isOkStatus(resultItem.status))
{
NotificationBus.Send(
Entity <DataType> .RESOLVE_FAILED,
ResolveFailedDTO.For(req, resultItem.status)
);
return;
}
Entity <DataType> .ResolveSucceeded(
new ResolveSucceededDTO <DataType>
{
key = req.key,
id = resultItem.id,
resolveRequestId = req.resolveRequestId,
data = resultItem.data,
timestamp = resultItem.timestamp,
maxAgeSecs = resultItem.maxAgeSecs
});
}
catch (Exception e)
{
Entity <DataType> .ResolveFailed(
ResolveFailedDTO.For(req, e.Message)
);
}
}
public static ResolveResultDTO <DataType> ResolveSucceeded(
ResolveRequestDTO req,
string id,
DataType data,
int maxAgeSecs = 0,
DateTimeOffset?timestamp = null
)
{
return(new ResolveResultDTO <DataType>
{
status = ResolveStatusCode.OK,
message = "ok",
id = id,
key = req.key,
data = data,
resolveRequestId = req.resolveRequestId,
timestamp = timestamp.HasValue? timestamp.Value: DateTimeOffset.Now,
maxAgeSecs = maxAgeSecs
});
}
/// <summary>
/// Called at the beginning of an Entity::Resolve request
/// and triggers the EntityStore for the associated data type
/// to update its resolve status to IN_PROGRESS for the entity id/key
/// </summary>
/// <param name="dto">Dto.</param>
/// <param name="opts">Opts.</param>
public static void ResolveStarted(ResolveRequestDTO req, Opts opts = Opts.RequireReceiver)
{
N.Send(RESOLVE_STARTED, req, opts);
}
public DataRequest(ResolveRequestDTO req, HasEntities <DataType> store)
{
this.store = store;
this.requestDTO = req;
}
private void OnResolve(ResolveRequestDTO req)
{
this.cmd.Execute(req);
}
virtual protected ResolveResultDTO <DataType> GetStoredEntityAsResolveResult(ResolveRequestDTO req)
{
return(this.helper.GetStoredEntityAsResolveResult(req));
}
