public async Task <Unit> Handle(UpdateActivityProfileCommand request, CancellationToken cancellationToken)
{
ActivityProfileEntity profile = await GetProfile(request.ActivityId, request.ProfileId, request.Registration, cancellationToken);
profile.Document.UpdateDocument(request.Content, request.ContentType);
_context.ActivityProfiles.Update(profile);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public async Task <AgentProfileDocument> Handle(CreateAgentProfileCommand request, CancellationToken cancellationToken)
{
var agent = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Agent), cancellationToken);
var profile = new AgentProfileEntity(request.Content, request.ContentType)
{
ProfileId = request.ProfileId,
Agent = agent
};
_context.AgentProfiles.Add(profile);
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <AgentProfileDocument>(profile));
}
public async Task <IActivity> Handle(UpsertActivityCommand request, CancellationToken cancellationToken)
{
var entity = _mapper.Map <ActivityEntity>(request.Activity);
var current = await _context.Activities
.Include(ac => ac.Definition)
.SingleOrDefaultAsync(x => x.Hash == entity.Hash, cancellationToken);
if (current != null)
{
if (entity.Definition != null)
{
if (current.Definition == null)
{
current.Definition = new ActivityDefinitionEntity();
}
_mapper.Map(entity.Definition, current.Definition);
}
return(current);
}
entity.ActivityId = Guid.NewGuid();
_context.Activities.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
return(entity);
}
public async Task <VerbEntity> Handle(UpsertVerbCommand request, CancellationToken cancellationToken)
{
string hash = request.Verb.Id.ComputeHash();
VerbEntity verb = await _context.Verbs.SingleOrDefaultAsync(x => x.Hash == hash, cancellationToken);
bool isNew = true;
if (verb == null)
{
verb = _mapper.Map <VerbEntity>(request.Verb);
verb.VerbId = Guid.NewGuid();
_context.Verbs.Add(verb);
isNew = true;
}
if (!isNew && request.Verb.Display != null)
{
foreach (var dis in request.Verb.Display)
{
if (verb.Display.ContainsKey(dis.Key))
{
verb.Display[dis.Key] = dis.Value;
}
else
{
verb.Display.Add(dis);
}
}
_context.Verbs.Update(verb);
}
await _context.SaveChangesAsync(cancellationToken);
return(verb);
}
public async Task <ActivityStateDocument> Handle(CreateStateDocumentCommand request, CancellationToken cancellationToken)
{
ActivityEntity activity = (ActivityEntity)await _mediator.Send(MergeActivityCommand.Create(request.ActivityId), cancellationToken);
AgentEntity agent = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Agent), cancellationToken);
var state = new ActivityStateEntity(request.Content, request.ContentType)
{
StateId = request.StateId,
Activity = activity,
Agent = agent,
Registration = request.Registration
};
_context.ActivityStates.Add(state);
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ActivityStateDocument>(state));
}
public async Task <Unit> Handle(DeleteActivityProfileCommand request, CancellationToken cancellationToken)
{
var activity = await _mediator.Send(GetActivityQuery.Create(request.ActivityId), cancellationToken);
var profile = await _context.ActivityProfiles.GetProfileAsync(activity.ActivityId, request.ProfileId, request.Registration, cancellationToken);
_context.ActivityProfiles.Remove(profile);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
/// <summary>
/// Creates statement without saving to database
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns>Guid of the created statement</returns>
public async Task <Guid> Handle(CreateStatementCommand request, CancellationToken cancellationToken)
{
await _mediator.Publish(StatementCreating.Create(), cancellationToken);
// Prepare statement for mapping
if (request.Statement.Id.HasValue)
{
bool any = await _context.Statements.AnyAsync(x => x.StatementId == request.Statement.Id, cancellationToken);
if (any)
{
return(request.Statement.Id.Value);
}
}
request.Statement.Stamp();
// Ensure statement version and stored date
request.Statement.Version = request.Statement.Version ?? ApiVersion.GetLatest().ToString();
request.Statement.Stored = request.Statement.Stored ?? DateTimeOffset.UtcNow;
if (request.Statement.Authority == null)
{
// Set authority before saving JSON encoded statement
request.Statement.Authority = _clientContext.GetClientAuthority();
}
else
{
// TODO: Validate authority
var client = await _mediator.Send(ClientByAgentQuery.Create(request.Statement.Authority));
}
// Start mapping statement
StatementEntity newStatement = new StatementEntity();
newStatement.StatementId = request.Statement.Id.GetValueOrDefault();
newStatement.ClientId = _clientContext.GetClientId();
await HandleStatementBase(request.Statement, newStatement, cancellationToken);
newStatement.Stored = request.Statement.Stored;
newStatement.Timestamp = request.Statement.Timestamp;
newStatement.Version = request.Statement.Version.ToString();
newStatement.FullStatement = request.Statement.ToJson();
_context.Statements.Add(newStatement);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(StatementCreated.Create(newStatement), cancellationToken);
return(newStatement.StatementId);
}
public async Task <Unit> Handle(DeleteActivityStatesCommand request, CancellationToken cancellationToken)
{
string activityHash = request.ActivityId.ComputeHash();
var activities = _context.ActivityStates.Where(x => x.Activity.Hash == activityHash)
.Where(x => x.Agent.AgentId == request.AgentId);
_context.ActivityStates.RemoveRange(activities);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public async Task Handle(StatementCreated notification, CancellationToken cancellationToken)
{
var entity = notification.Created;
if (entity.Verb.Id == VoidedVerb)
{
if (entity.ObjectType == EntityObjectType.StatementRef)
{
Guid statementId = entity.ObjectId;
StatementEntity statement = await _context.Statements
.Include(x => x.Verb)
.SingleOrDefaultAsync(x =>
x.StatementId == statementId
, cancellationToken);
if (statement != null &&
statement.Verb.Id != VoidedVerb)
{
statement.VoidingStatementId = entity.StatementId;
await _context.SaveChangesAsync(cancellationToken);
}
}
}
else
{
// Detect if current statement has already been voided
var voidingStatement = await _context.Statements.SingleOrDefaultAsync(x =>
x.ObjectType == EntityObjectType.StatementRef &&
x.ObjectId == entity.StatementId &&
x.Verb.Id == VoidedVerb
, cancellationToken);
if (voidingStatement != null)
{
entity.VoidingStatement = entity;
await _context.SaveChangesAsync(cancellationToken);
}
}
}
public async Task <Unit> Handle(PutStatementCommand request, CancellationToken cancellationToken)
{
if (!request.Statement.Id.HasValue)
{
request.Statement.Id = request.StatementId;
}
await _mediator.Send(CreateStatementCommand.Create(request.Statement), cancellationToken).ConfigureAwait(false);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public async Task <AgentProfileEntity> Handle(CreateAgentProfileCommand request, CancellationToken cancellationToken)
{
var profile = new AgentProfileEntity(request.Content, request.ContentType)
{
Key = request.ProfileId,
AgentId = request.AgentId
};
_context.Documents.Add(profile);
await _context.SaveChangesAsync(cancellationToken);
return(profile);
}
public async Task <ActivityStateEntity> Handle(CreateStateDocumentCommand request, CancellationToken cancellationToken)
{
var state = new ActivityStateEntity(request.Content, request.ContentType)
{
Key = request.StateId,
ActivityId = request.ActivityId,
AgentId = request.AgentId,
RegistrationId = request.Registration
};
_context.Documents.Add(state);
await _context.SaveChangesAsync(cancellationToken);
return(state);
}
public async Task <AgentProfileEntity> Handle(CreateAgentProfileCommand request, CancellationToken cancellationToken)
{
var agent = await _mediator.Send(UpsertActorCommand.Create(request.Agent), cancellationToken);
var profile = new AgentProfileEntity(request.Content, request.ContentType)
{
ProfileId = request.ProfileId,
AgentId = agent.AgentId
};
_context.AgentProfiles.Add(profile);
await _context.SaveChangesAsync(cancellationToken);
return(profile);
}
public async Task <ActivityProfileEntity> Handle(CreateActivityProfileCommand request, CancellationToken cancellationToken)
{
var activity = await _mediator.Send(UpsertActivityCommand.Create(request.ActivityId));
var profile = new ActivityProfileEntity(request.Content, request.ContentType)
{
Key = request.ProfileId,
ActivityId = activity.ActivityId,
RegistrationId = request.Registration
};
_context.Documents.Add(profile);
await _context.SaveChangesAsync(cancellationToken);
return(profile);
}
public async Task <Unit> Handle(DeleteActivityStatesCommand request, CancellationToken cancellationToken)
{
var agent = await mediator.Send(GetAgentQuery.Create(request.Agent));
string activityHash = request.ActivityId.ComputeHash();
var activities = _context.Documents
.OfType <ActivityStateEntity>()
.Where(x => x.Activity.Hash == activityHash)
.Where(x => x.Agent.AgentId == agent.AgentId);
_context.Documents.RemoveRange(activities);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public async Task <Unit> Handle(DeleteAgentProfileCommand request, CancellationToken cancellationToken)
{
AgentProfileEntity profile = await _context.Documents
.OfType <AgentProfileEntity>()
.AsNoTracking()
.Where(x => x.AgentId == request.AgentId)
.SingleOrDefaultAsync(x => x.Key == request.ProfileId, cancellationToken);
if (profile != null)
{
_context.Documents.Remove(profile);
await _context.SaveChangesAsync(cancellationToken);
}
return(await Unit.Task);
}
public async Task <ICollection <Guid> > Handle(CreateStatementsCommand request, CancellationToken cancellationToken)
{
var tasks = new List <Task <Guid> >();
foreach (var statement in request.Statements)
{
tasks.Add(_mediator.Send(CreateStatementCommand.Create(statement), cancellationToken));
}
var ids = await Task.WhenAll(tasks);
await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(new StatementsSaved());
return(ids);
}
public async Task <Unit> Handle(DeleteActivityStateCommand request, CancellationToken cancellationToken)
{
string activityHash = request.ActivityId.ComputeHash();
var activity = await _context.ActivityStates
.Where(x => x.StateId == request.StateId && x.Activity.Hash == activityHash &&
(!request.Registration.HasValue || x.Registration == request.Registration))
.Where(x => x.Agent.AgentId == request.AgentId)
.FirstOrDefaultAsync(cancellationToken);
if (activity != null)
{
_context.ActivityStates.Remove(activity);
await _context.SaveChangesAsync(cancellationToken);
}
return(await Unit.Task);
}
public async Task <Unit> Handle(UpdateActivityProfileCommand request, CancellationToken cancellationToken)
{
var activity = await _mediator.Send(GetActivityQuery.Create(request.ActivityId));
if (activity == null)
{
throw new NotFoundException("No activity profiles for activity.");
}
ActivityProfileEntity profile = await _context.ActivityProfiles.GetProfileAsync(activity.ActivityId, request.ProfileId, request.Registration, cancellationToken);
profile.Document.UpdateDocument(request.Content, request.ContentType);
_context.ActivityProfiles.Update(profile);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public async Task <ActivityStateDocument> Handle(UpdateStateDocumentCommand request, CancellationToken cancellationToken)
{
string activityHash = request.ActivityId.ComputeHash();
var query = _context.Documents
.OfType <ActivityStateEntity>()
.Where(x => x.Key == request.StateId)
.Where(x => x.Activity.Hash == activityHash)
.Where(x => x.Agent.AgentId == request.AgentId);
if (request.Registration.HasValue && request.Registration.Value != Guid.Empty)
{
query.Where(x => x.RegistrationId == request.Registration);
}
ActivityStateEntity state = await query.SingleOrDefaultAsync(cancellationToken);
if (state == null)
{
throw new NotFoundException("State", request.StateId);
}
var stateDocument = state;
if (stateDocument.ContentType != MediaTypes.Application.Json ||
request.ContentType != MediaTypes.Application.Json)
{
throw new BadRequestException();
}
JsonString jsonString = Encoding.UTF8.GetString(request.Content);
JsonString savedJsonString = Encoding.UTF8.GetString(stateDocument.Content);
// Merge, and overwrite duplicate props with props in new json document
savedJsonString.Merge(jsonString);
byte[] mergedJsonBytes = Encoding.UTF8.GetBytes(jsonString.ToString());
state.UpdateDocument(mergedJsonBytes, request.ContentType);
_context.Documents.Update(state);
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ActivityStateDocument>(state));
}
public async Task <Unit> Handle(DeleteActivityStateCommand request, CancellationToken cancellationToken)
{
var agent = await _mediator.Send(GetAgentQuery.Create(request.Agent));
string activityHash = request.ActivityId.ComputeHash();
var activity = await _context.Documents
.OfType <ActivityStateEntity>()
.Where(x => x.Key == request.StateId && x.Activity.Hash == activityHash &&
(!request.Registration.HasValue || x.RegistrationId == request.Registration))
.Where(x => x.Agent.AgentId == agent.AgentId)
.FirstOrDefaultAsync(cancellationToken);
if (activity != null)
{
_context.Documents.Remove(activity);
await _context.SaveChangesAsync(cancellationToken);
}
return(await Unit.Task);
}
public async Task <AgentProfileEntity> Handle(UpdateAgentProfileCommand request, CancellationToken cancellationToken)
{
var profile = await _context.Documents
.OfType <AgentProfileEntity>()
.Where(x => x.AgentId == request.AgentId)
.SingleOrDefaultAsync(x => x.Key == request.ProfileId, cancellationToken);
if (profile == null)
{
throw new NotFoundException("AgentProfile", request.ProfileId);
}
profile.UpdateDocument(request.Content, request.ContentType);
_context.Documents.Update(profile);
await _context.SaveChangesAsync(cancellationToken);
return(profile);
}
public async Task <AgentProfileEntity> Handle(UpdateAgentProfileCommand request, CancellationToken cancellationToken)
{
var agent = await _mediator.Send(GetAgentQuery.Create(request.Agent));
var profile = await _context.AgentProfiles
.Include(x => x.Document)
.Where(x => x.AgentId == agent.AgentId)
.SingleOrDefaultAsync(x => x.ProfileId == request.ProfileId, cancellationToken);
if (profile == null)
{
throw new NotFoundException("AgentProfile", request.ProfileId);
}
profile.Document.UpdateDocument(request.Content, request.ContentType);
_context.AgentProfiles.Update(profile);
await _context.SaveChangesAsync(cancellationToken);
return(profile);
}
public async Task <Unit> Handle(DeleteAgentProfileCommand request, CancellationToken cancellationToken)
{
var agentEntity = await _mediator.Send(GetAgentQuery.Create(request.Agent));
if (agentEntity == null)
{
return(await Unit.Task);
}
AgentProfileEntity profile = await _context.AgentProfiles
.AsNoTracking()
.Where(x => x.AgentId == agentEntity.AgentId)
.SingleOrDefaultAsync(x => x.ProfileId == request.ProfileId, cancellationToken);
if (profile != null)
{
_context.AgentProfiles.Remove(profile);
await _context.SaveChangesAsync(cancellationToken);
}
return(await Unit.Task);
}
public async Task <AgentEntity> Handle(UpsertActorCommand request, CancellationToken cancellationToken)
{
AgentEntity persona = await _mediator.Send(GetAgentQuery.Create(request.Actor), cancellationToken);
bool isNew = false;
if (persona == null)
{
persona = (request.Actor.ObjectType == ObjectType.Agent
? _mapper.Map <AgentEntity>(request.Actor)
: _mapper.Map <GroupEntity>(request.Actor));
persona.AgentId = Guid.NewGuid();
if (persona.ObjectType == EntityObjectType.Agent &&
!string.IsNullOrEmpty(request.Actor.Name))
{
persona.Person = new PersonEntity()
{
PersonId = Guid.NewGuid(),
Name = request.Actor.Name
};
}
_context.Agents.Add(persona);
await _context.SaveChangesAsync(cancellationToken);
isNew = true;
}
if (!isNew)
{
if (request.Actor is Group group &&
!group.IsAnonymous() &&
persona is GroupEntity groupEntity)
{
var upserts = group.Member.Select(member => _mediator.Send(UpsertActorCommand.Create(member), cancellationToken));
var members = await Task.WhenAll(upserts);
// Remove any members that does not exist in the request group
foreach (var member in groupEntity.Members)
{
if (!members.Any(x => x.AgentId == member.AgentId))
{
groupEntity.Members.Remove(member);
}
}
// Add any member that does not exist in the stored group from the request group
foreach (var member in members)
{
if (!groupEntity.Members.Any(x => x.AgentId == member.AgentId))
{
groupEntity.Members.Add(new GroupMemberEntity()
{
GroupId = groupEntity.AgentId,
AgentId = member.AgentId
});
}
}
await _mediator.Publish(AgentUpdated.Create(persona));
}
}
await _context.SaveChangesAsync(cancellationToken);
return(persona);
}
/// <summary>
/// Creates statement without saving to database
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns>Guid of the created statement</returns>
public async Task <Guid> Handle(CreateStatementCommand request, CancellationToken cancellationToken)
{
// Prepare statement for mapping
if (request.Statement.Id.HasValue)
{
bool any = await _context.Statements.AnyAsync(x => x.StatementId == request.Statement.Id, cancellationToken).ConfigureAwait(false);
if (any)
{
return(request.Statement.Id.Value);
}
}
request.Statement.Stamp();
// Ensure statement version and stored date
request.Statement.Version = request.Statement.Version ?? ApiVersion.GetLatest().ToString();
request.Statement.Stored = request.Statement.Stored ?? DateTimeOffset.UtcNow;
if (request.Statement.Authority == null)
{
// TODO: Map group?
request.Statement.Authority = _mapper.Map <Agent>(_authorityContext.Authority);
}
else
{
// TODO: Validate authority
}
// Start mapping statement
StatementEntity newStatement = new StatementEntity();
newStatement.StatementId = request.Statement.Id.GetValueOrDefault();
newStatement.Verb = (VerbEntity)await _mediator.Send(UpsertVerbCommand.Create(request.Statement.Verb), cancellationToken).ConfigureAwait(false);
newStatement.Actor = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Actor), cancellationToken).ConfigureAwait(false);
newStatement.Authority = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Authority), cancellationToken).ConfigureAwait(false);
if (request.Statement.Context != null)
{
newStatement.Context = _mapper.Map <ContextEntity>(request.Statement.Context);
ContextEntity context = newStatement.Context;
if (context.Instructor != null)
{
context.Instructor = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Context.Instructor), cancellationToken).ConfigureAwait(false);
}
if (context.Team != null)
{
context.Team = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Context.Team), cancellationToken).ConfigureAwait(false);
}
}
var objType = request.Statement.Object.ObjectType;
newStatement.Object = new StatementObjectEntity();
if (objType == ObjectType.Activity)
{
newStatement.Object.Activity = (ActivityEntity)await _mediator.Send(UpsertActivityCommand.Create((Activity)request.Statement.Object), cancellationToken).ConfigureAwait(false);
}
else if (objType == ObjectType.Agent || objType == ObjectType.Group)
{
newStatement.Object.Agent = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create((Agent)request.Statement.Object), cancellationToken).ConfigureAwait(false);
}
else if (objType == ObjectType.SubStatement)
{
newStatement.Object.SubStatement = (SubStatementEntity)await _mediator.Send(CreateSubStatementCommand.Create((SubStatement)request.Statement.Object), cancellationToken).ConfigureAwait(false);
}
else if (objType == ObjectType.StatementRef)
{
newStatement.Object.StatementRef = _mapper.Map <StatementRefEntity>((StatementRef)request.Statement.Object);
}
if (request.Statement.Result != null)
{
newStatement.Result = _mapper.Map <ResultEntity>(request.Statement.Result);
}
newStatement.Stored = request.Statement.Stored;
newStatement.Timestamp = request.Statement.Timestamp;
newStatement.Version = request.Statement.Version.ToString();
newStatement.FullStatement = request.Statement.ToJson();
_context.Statements.Add(newStatement);
// await _context.SaveChangesAsync(cancellationToken);
await _mediator.Publish(StatementAdded.Create(newStatement), cancellationToken).ConfigureAwait(false);
if (request.Persist)
{
await _context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
return(newStatement.StatementId);
}