示例#1
0
        public async Task <ActionResult> GetAgentProfilesAsync(
            [BindRequired, FromQuery] Agent agent,
            [FromQuery] DateTimeOffset?since = null,
            CancellationToken cancelToken    = default)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var profiles = await _mediator.Send(GetAgentProfilesQuery.Create(agent, since), cancelToken);

            if (profiles == null || profiles.Count == 0)
            {
                return(Ok(Array.Empty <Guid>()));
            }

            IEnumerable <string> ids = profiles.Select(x => x.ProfileId).ToList();

            string lastModified = profiles.OrderByDescending(x => x.Document.LastModified)
                                  .FirstOrDefault()?.Document.LastModified?.ToString("o");

            Response.Headers.Add(HeaderNames.LastModified, lastModified);
            return(Ok(ids));
        }
示例#2
0
        public async Task <ICollection <AgentProfileDocument> > Handle(GetAgentProfilesQuery request, CancellationToken cancellationToken)
        {
            var agentEntity = _mapper.Map <AgentEntity>(request.Agent);
            var query       = _context.AgentProfiles
                              .Where(a => a.Agent.Hash == agentEntity.Hash);

            if (request.Since.HasValue)
            {
                query = query.Where(x => x.Document.LastModified >= request.Since.Value);
            }

            query = query.OrderByDescending(x => x.Document.LastModified);

            return(_mapper.Map <ICollection <AgentProfileDocument> >(await query.ToListAsync(cancellationToken)));
        }
        public async Task <ICollection <AgentProfileEntity> > Handle(GetAgentProfilesQuery request, CancellationToken cancellationToken)
        {
            var query = _context.Documents
                        .AsNoTracking()
                        .OfType <AgentProfileEntity>()
                        .Where(a => a.Agent.AgentId == request.AgentId);

            if (request.Since.HasValue)
            {
                query = query.Where(x => x.UpdatedAt >= request.Since.Value);
            }

            query = query.OrderByDescending(x => x.UpdatedAt);

            return(await query.ToListAsync(cancellationToken));
        }
示例#4
0
        public async Task <MultipleDocumentResult> GetAgentProfiles(Agent agent, DateTimeOffset?since = null, CancellationToken cancellationToken = default)
        {
            var agentEntity = await mediator.Send(GetAgentQuery.Create(agent), cancellationToken);

            if (agentEntity == null)
            {
                return(MultipleDocumentResult.Empty());
            }

            var profiles = await mediator.Send(GetAgentProfilesQuery.Create(agentEntity.AgentId, since), cancellationToken);

            if (!profiles.Any())
            {
                return(MultipleDocumentResult.Empty());
            }

            ICollection <string> ids          = profiles.Select(x => x.Key).ToHashSet();
            DateTimeOffset?      lastModified = profiles.OrderByDescending(x => x.UpdatedAt).Select(x => x.UpdatedAt).FirstOrDefault();

            return(MultipleDocumentResult.Success(ids, lastModified));
        }