public async Task DeleteTest()
{
var actor = this.InitContext();
var uid = Guid.Parse("{72C23018-0C49-4419-8982-D7C0168E8DC2}");
var request = new CrudActionMessage <User, Guid> {
ActionType = EnActionType.Delete, Id = uid
};
var result = await actor.Ask <CrudActionResponse <User> >(request, TimeSpan.FromSeconds(5));
Assert.NotNull(result);
if (result.Exception != null)
{
this.Sys.Log.Error(result.Exception, "Exception");
}
Assert.Null(result.Exception);
Assert.NotNull(result.Data);
Assert.Equal("user1", result.Data.Login);
var contextFactory = this.Container.Resolve <UniversalContextFactory>();
using (var context = contextFactory.CreateContext <TestDataContext>("InMemory", null, "test"))
{
Assert.Equal(1, context.Users.Count());
}
}
protected virtual async Task OnRequest <TObject, TId>(CrudActionMessage <TObject, TId> request)
where TObject : class
{
CrudActionResponse <TObject> response;
try
{
response = await this.ProcessRequest(request);
}
catch (Exception exception)
{
Context.GetLogger().Error(
exception,
"{Type}: Error while processing {ActionType} for {EntityType}",
this.GetType().Name,
request.ActionType,
typeof(TObject).Name);
response = new CrudActionResponse <TObject> {
Exception = exception, ExtraData = request.ExtraData
};
}
if (typeof(ILargeObject).GetTypeInfo().IsAssignableFrom(typeof(TObject)))
{
Context.GetParcelManager().Tell(new Parcel {
Payload = response, Recipient = this.Sender
}, this.Self);
}
else
{
this.Sender.Tell(response);
}
}
public async Task UpdateWithApiRequestTest()
{
var actor = this.InitContext();
var uid = Guid.Parse("{72C23018-0C49-4419-8982-D7C0168E8DC2}");
var argumentsJson = @"
{
""id"": ""72C23018-0C49-4419-8982-D7C0168E8DC2"",
""newNode"": {
""login"": ""new_user""
}
}
";
var apiRequest = new ApiRequest {
Arguments = JObject.Parse(argumentsJson)
};
var request =
new CrudActionMessage <User, Guid>
{
ActionType = EnActionType.Update,
Id = uid,
Data = new User
{
Login = "******",
Password = "******",
Uid = uid
},
ApiRequest = apiRequest
};
var result = await actor.Ask <CrudActionResponse <User> >(request, TimeSpan.FromSeconds(5));
Assert.NotNull(result);
if (result.Exception != null)
{
this.Sys.Log.Error(result.Exception, "Exception");
}
Assert.Null(result.Exception);
Assert.NotNull(result.Data);
Assert.Equal("new_user", result.Data.Login);
Assert.Equal("123", result.Data.Password);
var contextFactory = this.Container.Resolve <UniversalContextFactory>();
using (var context = contextFactory.CreateContext <TestDataContext>("InMemory", null, "test"))
{
var user = context.Users.FirstOrDefault(u => u.Uid == uid);
Assert.NotNull(user);
Assert.Equal("new_user", user.Login);
Assert.Equal("123", user.Password);
}
}
public virtual async Task <IActionResult> Delete(TId id)
{
var request = new CrudActionMessage <TObject, TId>
{
ActionType = EnActionType.Delete,
Id = id,
RequestContext =
this.GetRequestDescription()
};
return(this.Ok(await this.SendRequest(request)));
}
public virtual async Task <IActionResult> Update(TId id, [FromBody] TObject data)
{
var request = new CrudActionMessage <TObject, TId>
{
ActionType = EnActionType.Update,
Data = data,
Id = id,
RequestContext =
this.GetRequestDescription()
};
return(this.Ok(await this.SendRequest(request)));
}
public virtual async Task <IActionResult> Create(TObject data)
{
var request = new CrudActionMessage <TObject, TId>
{
ActionType = EnActionType.Create,
Data = data,
RequestContext =
this.GetRequestDescription()
};
var result = await this.SendRequest(request);
return(this.Ok(result));
}
/// <inheritdoc />
public async Task <MutationResult <TObject> > Delete(TId id)
{
var request =
new CrudActionMessage <TObject, TId>
{
ActionType = EnActionType.Delete,
Id = id,
RequestContext = this.Context
};
var result = await this.System.ActorSelection(this.DataActorPath)
.Ask <CrudActionResponse <TObject> >(request, this.Timeout);
return(CreateResponse(result));
}
/// <summary>
/// Creates request to actor system and accepts response
/// </summary>
/// <param name="request">The request to the actor system</param>
/// <returns>The object</returns>
protected virtual async Task <TObject> SendRequest(CrudActionMessage <TObject, TId> request)
{
CrudActionResponse <TObject> result;
if (DataIsLarge)
{
var notification = request.ActionType == EnActionType.Get
? await this.System.ActorSelection(this.GetDbActorProxyPath())
.Ask <ParcelNotification>(request, this.AkkaTimeout)
: await this.System.GetParcelManager()
.Ask <ParcelNotification>(
new Parcel
{
Payload = request,
Recipient =
this.System.ActorSelection(
this.GetDbActorProxyPath())
},
this.AkkaTimeout);
result = (CrudActionResponse <TObject>) await notification.Receive(this.System);
}
else
{
result =
await this.System.ActorSelection(this.GetDbActorProxyPath())
.Ask <CrudActionResponse <TObject> >(request, this.AkkaTimeout);
}
if (result.Exception != null && result.Exception.GetType() != typeof(EntityNotFoundException))
{
throw result.Exception;
}
if (result.Exception?.GetType() == typeof(EntityNotFoundException) || result.Data == null)
{
return(null);
}
return(result.Data);
}
public virtual async Task <IActionResult> Get(TId id)
{
var request = new CrudActionMessage <TObject, TId>
{
ActionType = EnActionType.Get,
Id = id,
RequestContext =
this.GetRequestDescription()
};
var response = await this.SendRequest(request);
SecurityLog.CreateRecord(
EnSecurityLogType.DataReadGranted,
response is ICrucialObject ? EnSeverity.Crucial : EnSeverity.Trivial,
this.GetRequestDescription(),
"{ObjectType} with id {ObjectId} was read.",
typeof(TObject).FullName,
id);
return(this.Ok(response));
}
public async Task GetByIdTest()
{
var actor = this.InitContext();
var request =
new CrudActionMessage <User, Guid>
{
ActionType = EnActionType.Get,
Id = Guid.Parse("{72C23018-0C49-4419-8982-D7C0168E8DC2}")
};
var result = await actor.Ask <CrudActionResponse <User> >(request, TimeSpan.FromSeconds(5));
Assert.NotNull(result);
if (result.Exception != null)
{
this.Sys.Log.Error(result.Exception, "Exception");
}
Assert.Null(result.Exception);
Assert.NotNull(result.Data);
Assert.Equal("user1", result.Data.Login);
}
protected virtual async Task <CrudActionResponse <TObject> > ProcessRequest <TObject, TId>(
CrudActionMessage <TObject, TId> request)
where TObject : class
{
using (var ds = this.GetContext())
{
var factory = DataFactory <TContext, TObject, TId> .CreateFactory(this.ComponentContext, ds);
switch (request.ActionType)
{
case EnActionType.Get:
try
{
var result = await factory.Get(request.Id);
if (result.HasValue)
{
result = this.OnSelect(result.Value);
}
// security read log should be set on client endpoint
return(result.HasValue
? CrudActionResponse <TObject> .Success(result, request.ExtraData)
: CrudActionResponse <TObject> .Error(
new EntityNotFoundException(),
request.ExtraData));
}
catch (Exception exception)
{
return(CrudActionResponse <TObject> .Error(
new DatasourceInnerException("Exception on Get operation", exception),
request.ExtraData));
}
case EnActionType.Create:
{
var entity = request.Data;
if (entity == null)
{
return(CrudActionResponse <TObject> .Error(
new RequestEmptyException(),
request.ExtraData));
}
entity = this.BeforeCreate(entity);
var oldObject = await factory.Get(factory.GetId(entity));
if (oldObject != null)
{
var crudActionResponse = CrudActionResponse <TObject> .Error(
new InsertDuplicateIdException(),
request.ExtraData);
crudActionResponse.Data = oldObject;
return(crudActionResponse);
}
if (entity == null)
{
return(CrudActionResponse <TObject> .Error(
new BeforeActionException(),
request.ExtraData));
}
try
{
await factory.Insert(entity);
// security update logs are set here to be sure that they are made independently of client notification success
SecurityLog.CreateRecord(
EnSecurityLogType.DataCreateGranted,
entity is ICrucialObject ? EnSeverity.Crucial : EnSeverity.Trivial,
request.RequestContext,
"{ObjectType} with {ObjectId} id was created",
typeof(TObject).FullName,
factory.GetId(entity));
this.AfterCreate(entity);
return(CrudActionResponse <TObject> .Success(entity, request.ExtraData));
}
catch (Exception exception)
{
return(CrudActionResponse <TObject> .Error(
new DatasourceInnerException("Exception on Insert operation", exception),
request.ExtraData));
}
}
case EnActionType.Update:
{
var entity = request.Data;
if (entity == null)
{
return(CrudActionResponse <TObject> .Error(
new RequestEmptyException(),
request.ExtraData));
}
var oldObject = await factory.Get(request.Id);
if (oldObject == null)
{
return(CrudActionResponse <TObject> .Error(
new EntityNotFoundException(),
request.ExtraData));
}
if (request.ApiRequest != null)
{
var updatedObject = await factory.Get(request.Id);
if (updatedObject == null)
{
return(CrudActionResponse <TObject> .Error(
new EntityNotFoundException(),
request.ExtraData));
}
DataUpdater <TObject> .Update(updatedObject, entity, request.ApiRequest);
entity = updatedObject;
}
entity = this.BeforeUpdate <TObject>(entity, oldObject);
if (entity == null)
{
return(CrudActionResponse <TObject> .Error(
new BeforeActionException(),
request.ExtraData));
}
try
{
await factory.Update(entity, oldObject);
// security update logs are set here to be sure that they are made independently of client notification success
if (!factory.GetId(entity).Equals(factory.GetId(oldObject)))
{
SecurityLog.CreateRecord(
EnSecurityLogType.DataUpdateGranted,
entity is ICrucialObject ? EnSeverity.Crucial : EnSeverity.Trivial,
request.RequestContext,
"{ObjectType} with id {ObjectId} was updated. New id is {NewObjectId}",
typeof(TObject).FullName,
factory.GetId(oldObject),
factory.GetId(entity));
}
else
{
SecurityLog.CreateRecord(
EnSecurityLogType.DataUpdateGranted,
entity is ICrucialObject ? EnSeverity.Crucial : EnSeverity.Trivial,
request.RequestContext,
"{ObjectType} with id {ObjectId} was updated.",
typeof(TObject).FullName,
factory.GetId(entity));
}
this.AfterUpdate <TObject>(entity, oldObject);
return(CrudActionResponse <TObject> .Success(entity, request.ExtraData));
}
catch (Exception exception)
{
return(CrudActionResponse <TObject> .Error(
new DatasourceInnerException("Exception on Update operation", exception),
request.ExtraData));
}
}
case EnActionType.Delete:
{
var oldObject = await factory.Get(request.Id);
if (oldObject == null)
{
return(CrudActionResponse <TObject> .Error(
new EntityNotFoundException(),
request.ExtraData));
}
oldObject = this.BeforeDelete(oldObject.Value);
if (oldObject == null)
{
return(CrudActionResponse <TObject> .Error(
new BeforeActionException(),
request.ExtraData));
}
try
{
oldObject = await factory.Delete(factory.GetId(oldObject));
}
catch (Exception exception)
{
return(CrudActionResponse <TObject> .Error(
new DatasourceInnerException("Exception on Delete operation", exception),
request.ExtraData));
}
if (oldObject == null)
{
return(CrudActionResponse <TObject> .Error(
new EntityNotFoundException("After \"Before\" action modification"),
request.ExtraData));
}
// security update logs are set here to be sure that they are made independently of client notification success
SecurityLog.CreateRecord(
EnSecurityLogType.DataDeleteGranted,
oldObject.Value is ICrucialObject ? EnSeverity.Crucial : EnSeverity.Trivial,
request.RequestContext,
"{ObjectType} with id {ObjectId} was deleted.",
typeof(TObject).FullName,
factory.GetId(oldObject));
this.AfterDelete <TObject>(oldObject);
return(CrudActionResponse <TObject> .Success(oldObject, request.ExtraData));
}
default:
return(CrudActionResponse <TObject> .Error(
new ArgumentOutOfRangeException(nameof(request.ActionType)),
request.ExtraData));
}
}
}
