Beispiel #1
0
        /// <inheritdoc/>
        protected override async Task <PaginationResultModel <EventModel> > ProtectedHandleAsync(GetPaginatedQuery request, CancellationToken cancellationToken)
        {
            var principal = PrincipalProvider.GetPrincipal();

            if (principal == null)
            {
                throw new ForbiddenException("Not authenticated");
            }

            Expression <Func <EventEntity, bool> > expression = PredicateBuilder.True <EventEntity>();

            if (!principal.IsInRole(RoleType.Administrator))
            {
                expression = expression.And(e => e.UserId == principal.Identity.Name);
            }

            int total = await Context.EventRepository.CountAsync(expression, cancellationToken);

            var query = Context.EventRepository
                        .GetQuery(expression)
                        .OrderByDescending(e => e.CreatedDate)
                        .Skip(request.Page * request.Limit)
                        .Take(request.Limit);

            var entities = await Context.ToListAsync(query, cancellationToken);

            var models = entities.Select(e => EventModel.Create(e, Serializer));

            return(PaginationResultModel <EventModel> .Create(models, request.Page, request.Limit, total));
        }
Beispiel #2
0
        /// <inheritdoc/>
        protected override async Task <PaginationResultModel <AppLogModel> > ProtectedHandleAsync(GetPaginatedQuery request, CancellationToken cancellationToken)
        {
            int total = await appLogRepository.CountAsync(cancellationToken);

            var result = appLogRepository
                         .GetQuery()
                         .OrderByDescending(e => e.Timestamp)
                         .Skip(request.Page * request.Limit)
                         .Take(request.Limit)
                         .Select(e => AppLogModel.Create(e));

            return(PaginationResultModel <AppLogModel> .Create(result, request.Page, request.Limit, total));
        }
        /// <inheritdoc/>
        public async Task <PaginationResultModel <ObjectModel> > Handle(GetObjectsQuery request, CancellationToken cancellationToken)
        {
            int total = await context.ObjectRepository.CountAsync(cancellationToken);

            var query = context.ObjectRepository
                        .GetQuery()
                        .Select(e => new
            {
                Object  = e,
                Tasks   = e.Tasks.OrderByDescending(e1 => e1.CreatedDate).Take(request.Limit),
                Results = e.Tasks.OrderByDescending(e1 => e1.CreatedDate).Select(e1 => e1.Result).Take(request.Limit)
            })
                        .OrderByDescending(e => e.Object.CreatedDate)
                        .Skip((request.Page - 1) * request.Limit)
                        .Take(request.Limit);

            var entities = await context.ToListAsync(query, cancellationToken);

            var models = entities.Select(e => ObjectModel.Create(e.Object, e.Tasks, e.Results, serializer));

            return(PaginationResultModel <ObjectModel> .Create(models, request.Page, request.Limit, total));
        }