示例#1
0
        public async Task <IDocument> UpdateAgentProfile(Agent agent, string profileId, byte[] content, string contentType, CancellationToken cancellationToken = default)
        {
            var agentEntity = await mediator.Send(GetAgentQuery.Create(agent), cancellationToken);

            var document = await mediator.Send(UpdateAgentProfileCommand.Create(agentEntity.AgentId, profileId, content, contentType));

            return(mapper.Map <IDocument>(document));
        }
示例#2
0
        public async Task <AgentProfileDocument> Handle(MergeAgentProfileCommand request, CancellationToken cancellationToken)
        {
            var profile = await Handle(GetAgentProfileQuery.Create(request.Agent, request.ProfileId), cancellationToken);

            if (profile == null)
            {
                return(await Handle(
                           CreateAgentProfileCommand.Create(request.Agent, request.ProfileId, request.Content, request.ContentType),
                           cancellationToken));
            }

            return(await Handle(UpdateAgentProfileCommand.Create(request.Agent, request.ProfileId, request.Content, request.ContentType), cancellationToken));
        }
示例#3
0
        public async Task <AgentProfileDocument> Handle(UpdateAgentProfileCommand request, CancellationToken cancellationToken)
        {
            var agentEntity = _mapper.Map <AgentEntity>(request.Agent);

            var profile = await GetAgentProfile(agentEntity, request.ProfileId, cancellationToken);

            profile.Document.UpdateDocument(request.Content, request.ContentType);

            _context.AgentProfiles.Update(profile);
            await _context.SaveChangesAsync(cancellationToken);

            return(_mapper.Map <AgentProfileDocument>(profile));
        }
示例#4
0
        public async Task <AgentProfileEntity> Handle(UpsertAgentProfileCommand request, CancellationToken cancellationToken)
        {
            var profile = await _mediator.Send(GetAgentProfileQuery.Create(request.AgentId, request.ProfileId), cancellationToken);

            if (profile == null)
            {
                return(await _mediator.Send(
                           CreateAgentProfileCommand.Create(request.AgentId, request.ProfileId, request.Content, request.ContentType),
                           cancellationToken));
            }

            return(await _mediator.Send(UpdateAgentProfileCommand.Create(request.AgentId, request.ProfileId, request.Content, request.ContentType), cancellationToken));
        }
示例#5
0
        public async Task <ActionResult> SaveAgentProfileAsync(
            [BindRequired, FromQuery] string profileId,
            [BindRequired, FromQuery] Agent agent,
            [BindRequired, FromHeader(Name = "Content-Type")] string contentType,
            [BindRequired, FromBody] byte[] content,
            CancellationToken cancellationToken = default)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var profile = await _mediator.Send(GetAgentProfileQuery.Create(agent, profileId), cancellationToken);

            if (Request.TryConcurrencyCheck(profile?.Document.Checksum, profile?.Document.LastModified, out int statusCode))
            {
                return(StatusCode(statusCode));
            }

            if (profile == null)
            {
                profile = await _mediator.Send(
                    CreateAgentProfileCommand.Create(agent, profileId, content, contentType),
                    cancellationToken);
            }
            else
            {
                profile = await _mediator.Send(
                    UpdateAgentProfileCommand.Create(agent, profileId, content, contentType),
                    cancellationToken);
            }

            Response.Headers.Add(HeaderNames.ETag, $"\"{profile.Document.Checksum}\"");
            Response.Headers.Add(HeaderNames.LastModified, profile.Document.LastModified?.ToString("o"));

            return(NoContent());
        }