Example #1
0
        public async Task <SearchResult <InvitationListItem> > Handle(GetInvitationList request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            // todo: check event belongs to user company

            using (var db = _dbContextFactory.Create())
            {
                var all =
                    from i in db.GetTable <DbInvitation>()
                    join c in db.GetTable <DbClassifier>() on i.CounterpartyUid equals c.Uid
                    where i.EventUid == request.EventUid
                    select new InvitationListItem
                {
                    Uid              = i.Uid,
                    StatusCode       = i.StatusCode,
                    CounterpartyUid  = i.CounterpartyUid,
                    CounterpartyName = c.Name,
                    Email            = i.Email
                };

                var data = await all
                           .Apply(request, x => x.CounterpartyName, SortOrder.Descending)
                           .ToListAsync(cancellationToken);

                return(new SearchResult <InvitationListItem>
                {
                    TotalCount = all.GetTotalCount(request),
                    Rows = data
                });
            }
        }
Example #2
0
        public async Task <ActionResult <SearchResult <InvitationListItem> > > List(GetInvitationList request)
        {
            request.CompanyUid = await _currentCompanyProvider.GetCompanyUid();

            request.UserUid = _currentUserProvider.GetUserUid();

            return(await _mediator.Send(request));
        }
        public async Task GetInvitationList_ForNormalRequest_ReturnItems()
        {
            // arrange
            var cancellationToken        = CancellationToken.None;
            var dbContextFactory         = new DefaultDbContextFactory();
            var classifierTypeRepository = new DbClassifierTypeRepository(dbContextFactory);
            var classifierTypeService    = new DbClassifierTypeService(dbContextFactory, classifierTypeRepository);

            var fieldProviderRegistry = new DefaultFieldProviderRegistry();

            fieldProviderRegistry.AddFieldType(typeof(TextField));
            var dbFieldDataRepository = new DbFieldDataRepository(dbContextFactory, fieldProviderRegistry);

            var metadataServiceMock = new Mock <IClassifierTypeMetadataService>();

            metadataServiceMock
            .Setup(x => x.GetMetadata(It.IsAny <ClassifierType>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(() => new FieldMetadata[]
            {
                new TextField {
                    Key = "test1", Active = true, System = false
                },
                new TextField {
                    Key = "test2", Active = true, System = false
                },
                new TextField {
                    Key = "test3", Active = true, System = false
                }
            });

            var classifierRepository = new DbClassifierRepository <Classifier>(dbContextFactory,
                                                                               classifierTypeService, null, metadataServiceMock.Object, dbFieldDataRepository, null);
            var handler = new GetInvitationListHandler(dbContextFactory, classifierRepository);

            // act
            var command = new GetInvitationList
            {
                UserUid = Guid.NewGuid(),
            };

            var result = await handler.Handle(command, cancellationToken);

            // assert
            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Rows);
        }