public async Task <CreateResult> Handle
(DbCreateCommand <Actor> request,
CancellationToken cancellationToken)
{
try
{
Logger.LogInformation(LogEvent.DatabaseRequest,
"Request={Request}", request.ToDictionary());
var validation = new DbCreateActorCommandValidator()
.Validate(request);
if (!validation.IsValid)
{
Logger.LogWarning
(LogEvent.DatabaseRequestArgumentError,
"Database request validation error. " +
"Error={Error}.", validation.Errors);
return(ErrorResult("Database request validation error."));
}
await DbContext.Db.GetCollection <Actor>
(Defaults.ActorCollectionName)
.InsertOneAsync(request.Entity)
.ConfigureAwait(false);
var newId = request.Entity?.Id;
return(new CreateResult(newId));
}
catch (Exception e)
{
Logger.LogWarning(LogEvent.DatabaseExceptionError, e,
"Database exception error. Error={Error}.", e.Message);
return(ErrorResult("Database exception error"));
}
}
public async Task <CreateResult> Handle
(DbCreateCommand <GeoTask> request,
CancellationToken cancellationToken)
{
try
{
Logger.LogInformation(LogEvent.DatabaseRequest,
"Request={Request}", request.ToDictionary());
var validation = new DbCreateGeoTaskCommandValidator()
.Validate(request);
if (!validation.IsValid)
{
Logger.LogWarning
(LogEvent.DatabaseRequestArgumentError,
"Database request validation error. Error={Error}.",
validation.Errors);
return(ErrorResult("Database request validation error."));
}
DbGeoTask dbEntity = request.Entity.ToDbGeoTask();
await DbContext.Db.GetCollection <DbGeoTask>
(Defaults.TaskCollectionName)
.InsertOneAsync(dbEntity)
.ConfigureAwait(false);
var newId = dbEntity?.Id;
// Error while creating the entity
if (String.IsNullOrEmpty(newId))
{
return(ErrorResult("Unknown error."));
}
return(new CreateResult(newId));
}
catch (Exception e)
{
Logger.LogWarning(LogEvent.DatabaseExceptionError, e,
"Database exception error. Error={Error}.", e.Message);
return(ErrorResult("Database exception error"));
}
}
public static Dictionary <string, object> ToDictionary
(this DbCreateCommand <GeoTask> from)
{
if (from is null)
{
return(null);
}
if (from.Entity is null)
{
return(new Dictionary <string, object>());
}
return(new Dictionary <string, object>
{
{ nameof(from.Entity.AssistentActors),
string.Join(',', from.Entity.AssistentActors
.Select(x => x.Id)) },
{ nameof(from.Entity.CreatedAt), from.Entity.CreatedAt },
{ nameof(from.Entity.CreatedBy), from.Entity.CreatedBy?.Id },
{ nameof(from.Entity.Description), from.Entity.Description },
{ nameof(from.Entity.GeosIds),
string.Join(',', from.Entity.GeosIds) },
{ nameof(from.Entity.Id), from.Entity.Id },
{ nameof(from.Entity.IsArchived), from.Entity.IsArchived },
{ nameof(from.Entity.ObserverActors),
string.Join(',', from.Entity.ObserverActors
.Select(x => x.Id)) },
{ nameof(from.Entity.PlanFinishAt), from.Entity.PlanFinishAt },
{ nameof(from.Entity.PlanStartAt), from.Entity.PlanStartAt },
{ nameof(from.Entity.ProjectId), from.Entity.ProjectId },
{ nameof(from.Entity.ResponsibleActor),
from.Entity.ResponsibleActor?.Id },
{ nameof(from.Entity.Status), from.Entity.Status },
{ nameof(from.Entity.StatusChangedAt),
from.Entity.StatusChangedAt },
{ nameof(from.Entity.Title), from.Entity.Title },
});
}
public static Dictionary <string, object> ToDictionary
(this DbCreateCommand <Actor> from)
{
if (from is null)
{
return(null);
}
if (from.Entity is null)
{
return(new Dictionary <string, object>());
}
var dict = new Dictionary <string, object>();
var entityDict = from.Entity.ToDictionary();
foreach (var item in entityDict)
{
dict.TryAdd(item.Key, item.Value);
}
return(dict);
}
public async Task <CreateResult> Handle(ActorCreateCommand command,
CancellationToken cancellationToken)
{
Logger.LogInformation(AppLogEvent.HandleRequest,
"Handle Actor Create Command. Command={Command}",
command.ToDictionary());
if (command is null)
{
Logger.LogWarning(AppLogEvent.HandleArgumentError,
"Handle Create Actor Command got empty command");
return(ErrorResult("Empty Actor Create command"));
}
try
{
var validator = new ActorCreateCommandValidator();
var validationResult = await validator.ValidateAsync(command)
.ConfigureAwait(false);
if (!validationResult.IsValid)
{
Logger.LogWarning(AppLogEvent.RequestValidationError,
"Validation command error. Command = {command}. " +
"Error = {Error}",
command.ToDictionary(), validationResult.Errors);
return(ErrorResult(validationResult.Errors
.Select(x => x.ErrorMessage)));
}
// Check duplicates
var dbActorRequest = new DbGetActorByNameRequest(command.Login);
var duplicateResponse = await Mediator.Send(dbActorRequest)
.ConfigureAwait(false);
if (duplicateResponse.Success &&
duplicateResponse.Entity != null)
{
Logger.LogWarning(AppLogEvent.RequestValidationError,
"Validation command error. Command={command}. " +
"Error={Error}.",
command.ToDictionary(), "Duplicated actor login");
return(ErrorResult("Duplicated actor login"));
}
// Get Actor for current user by user name
Actor createdBy = null;
if (!command.DataSeedMode)
{
var currentUserName = command.CurrentPrincipal?
.Identity?
.Name;
var creatorRequest = new DbGetActorByNameRequest
(currentUserName);
var creatorResponse = await Mediator.Send(creatorRequest)
.ConfigureAwait(false);
if (creatorResponse.Success)
{
createdBy = creatorResponse.Entity;
}
}
var actor = command.ToActor(createdBy?.Id);
var validatorBeforeSave = new ActorBeforeSaveValidator();
var validationBeforeSaveResult = await validatorBeforeSave
.ValidateAsync(actor)
.ConfigureAwait(false);
if (!validationBeforeSaveResult.IsValid)
{
Logger.LogWarning(AppLogEvent.RequestNotValid,
"Actor validation error. Entity={Entity}. " +
"Error={Error}",
actor.ToDictionary(),
validationBeforeSaveResult.Errors);
return(ErrorResult(validationBeforeSaveResult.Errors
.Select(x => x.ErrorMessage)));
}
if (!command.DataSeedMode)
{
var checkPermissionResult =
await CheckPermission(actor, createdBy)
.ConfigureAwait(false);
if (!checkPermissionResult.Success)
{
Logger.LogWarning(AppLogEvent.SecurityNotPassed,
"Actor check create permission error. " +
"Entity={Entity}. CurrentActor={CurrentActor}." +
" Error={Error}",
actor.ToDictionary(), createdBy?.ToDictionary(),
checkPermissionResult.Errors);
return(checkPermissionResult);
}
}
var createCommand = new DbCreateCommand <Actor>(actor);
var createResult = await Mediator.Send(createCommand)
.ConfigureAwait(false);
return(createResult);
}
catch (Exception e)
{
Logger.LogError(AppLogEvent.HandleErrorResponse, e,
"Call repository exception");
return(ErrorResult("Not found"));
}
}
