Esempio n. 1
0
        public void BrowseAssignments_UsesQuery_ReturnsResultOfDispatch()
        {
            var query  = new BrowseAssignments();
            var result = new Mock <IPagedResult <AssignmentDto> >(MockBehavior.Strict).Object;

            _dispatcherMock.Setup(d => d.QueryAsync(query)).ReturnsAsync(result).Verifiable();

            var actionResult = _controller.BrowseAssignments(query).GetAwaiter().GetResult();

            Assert.AreEqual(result, actionResult);

            _dispatcherMock.Verify();
        }
Esempio n. 2
0
        public async Task VerifyAssignmentExclusivity(Guid meansId)
        {
            var query = new BrowseAssignments
            {
                OfAuthenticationMeans = meansId,
                SortBy = new[] { $"{nameof(Assignment.ValidSince)} asc", $"{nameof(Assignment.ValidUntil)} asc" }
            };

            Assignment currentlyValid = null;
            int        recordsVisited;

            do
            {
                recordsVisited = 0;
                var resultsPage = await _assignmentsRepository.BrowseAsync(query);

                foreach (var assignment in resultsPage.Items)
                {
                    if (currentlyValid != null)
                    {
                        if (currentlyValid.ValidUntil == null)
                        {
                            throw new BaristaException(
                                      "invalid_means_assignment_status",

                                      $"The means with ID '{meansId}' cannot have more than one active assignment. " +
                                      $"The assignment with ID '{currentlyValid.Id}' becomes permanently valid at '{currentlyValid.ValidSince}', " +
                                      $"and the next assignment with ID '{assignment.Id}' becomes valid at '{assignment.ValidSince}'."
                                      );
                        }
                        else if (currentlyValid.ValidUntil > assignment.ValidSince)
                        {
                            throw new BaristaException(
                                      "invalid_means_assignment_status",

                                      $"The means with ID '{meansId}' cannot have more than one active assignment. " +
                                      $"The assignment with ID '{currentlyValid.Id}' is valid from '{currentlyValid.ValidSince}' until '{currentlyValid.ValidUntil}'" +
                                      $"and the next assignment with ID '{assignment.Id}' becomes valid at '{assignment.ValidSince}'."
                                      );
                        }
                    }

                    currentlyValid = assignment;
                    recordsVisited++;
                }

                query.CurrentPage++;
            } while (recordsVisited > 0);
        }
Esempio n. 3
0
 public async Task <IPagedResult <AssignmentDto> > HandleAsync(BrowseAssignments query)
 {
     return(_mapper.Map <IPagedResult <AssignmentDto> >(await _repository.BrowseAsync(query)));
 }
Esempio n. 4
0
 public async Task <IPagedResult <AssignmentDto> > BrowseAssignments([FromQuery] BrowseAssignments query)
 {
     return(await QueryAsync(query));
 }