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); }