public async Task <Unit> HandleAsync(UpdateInternalUserRole message)
{
var user = await repository.GetByUserId(message.UserId);
var adminClaim = new Claim(ClaimTypes.Role, UserRole.Administrator.ToString().ToLowerInvariant());
var internalClaim = new Claim(ClaimTypes.Role, UserRole.Internal.ToString().ToLowerInvariant());
var readOnlyClaim = new Claim(ClaimTypes.Role, UserRole.ReadOnly.ToString().ToLowerInvariant());
var userClaims = await userManager.GetClaimsAsync(user.UserId);
if (message.Role == UserRole.Administrator)
{
await AddClaimToUser(userClaims, adminClaim, user);
await AddClaimToUser(userClaims, internalClaim, user);
await RemoveClaim(userClaims, readOnlyClaim, user);
}
if (message.Role == UserRole.Internal)
{
await AddClaimToUser(userClaims, internalClaim, user);
await RemoveClaim(userClaims, adminClaim, user);
await RemoveClaim(userClaims, readOnlyClaim, user);
}
if (message.Role == UserRole.ReadOnly)
{
await AddClaimToUser(userClaims, readOnlyClaim, user);
await RemoveClaim(userClaims, internalClaim, user);
await RemoveClaim(userClaims, adminClaim, user);
}
return(Unit.Value);
}
public async Task <FinanceReportData[]> HandleAsync(GetFinanceReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var report = await financeReportRepository.GetFinanceReport(message.From, message.To, user.CompetentAuthority);
return(report.Select(f => mapper.Map <FinanceReportData>(f)).ToArray());
}
public async Task <ImportStatsData[]> HandleAsync(GetImportStatsReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var report = await importStatsRepository.GetImportStats(message.From, message.To, user.CompetentAuthority);
return(report.Select(p => mapper.Map <ImportStatsData>(p)).ToArray());
}
public async Task <ComplianceData[]> HandleAsync(GetComplianceReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
return
((await
repository.GetComplianceReport(message.DateType, message.From, message.To, message.TextFieldType,
message.OperatorType, message.TextSearch, user.CompetentAuthority)).ToArray());
}
public async Task <IEnumerable <ExportNotificationOwnerDisplay> > HandleAsync(GetExportNotificationOwnerDisplays message)
{
var currentUser = await internalUserRepository.GetByUserId(userContext.UserId);
var result = (await exportOwnerDisplayRepository
.GetInternalUnsubmittedByCompetentAuthority(currentUser.CompetentAuthority));
return(result.Select(x => mapper.Map <ExportNotificationOwnerDisplay>(x)).ToArray());
}
public GetImportNotificationCommentsUsersHandlerTests()
{
this.repo = A.Fake <IImportNotificationCommentRepository>();
this.internalUserRepository = A.Fake <IInternalUserRepository>();
A.CallTo(() => repo.GetUsers(A <Guid> .Ignored, A <NotificationShipmentsCommentsType> .Ignored)).Returns(this.GetFakeUsers());
A.CallTo(() => internalUserRepository.GetByUserId(A <Guid> .Ignored)).Returns(GetFakeInternalUser());
this.message = A.Fake <GetImportNotificationCommentsUsers>();
this.handler = new GetImportNotificationCommentsUsersHandler(this.repo, this.internalUserRepository);
}
public async Task <FinancialGuaranteesData[]> HandleAsync(GetFinancialGuaranteesReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
return((await financialGuaranteesRepository.GetBlanketBonds(
user.CompetentAuthority,
message.FinancialGuaranteeReferenceNumber,
message.ExporterName,
message.ImporterName,
message.ProducerName)).ToArray());
}
public async Task <List <LocalAreaData> > HandleAsync(GetLocalAreasByUserCa message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
return(await iwsContext.LocalAreas.OrderBy(x => x.Name).Where(x => x.CompetentAuthorityId == (int)user.CompetentAuthority)
.Select(p => new LocalAreaData()
{
Id = p.Id, Name = p.Name, CompetentAuthorityId = p.CompetentAuthorityId
})
.ToListAsync());
}
public InternalComment Map(ImportNotificationComment source)
{
var user = Task.Run(() => internalUserRepository.GetByUserId(source.UserId)).Result.User;
return(new InternalComment()
{
Comment = source.Comment,
DateAdded = source.DateAdded.UtcDateTime,
NotificationId = source.NotificationId,
ShipmentNumber = source.ShipmentNumber,
Username = user.FullName,
CommentId = source.Id
});
}
public async Task <Tuple <UKCompetentAuthority, CompetentAuthorityData> > HandleAsync(GetInternalUserCompetentAuthority message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var userAuthority = user.CompetentAuthority;
var countryId = await countryRepository.GetUnitedKingdomId();
var lookupAuthority = await competentAuthorityRepository.GetCompetentAuthorities(countryId);
return(new Tuple <UKCompetentAuthority, CompetentAuthorityData>(userAuthority,
mapper.Map <CompetentAuthorityData>(
lookupAuthority.Single(ca => ca.Code == AuthorityCodes[userAuthority]))));
}
public async Task <NotificationCommentsUsersData> HandleAsync(GetNotificationCommentsUsers message)
{
var users = await this.repository.GetUsers(message.NotificationId, message.Type);
NotificationCommentsUsersData returnData = new NotificationCommentsUsersData();
foreach (string userId in users)
{
var user = Task.Run(() => internalUserRepository.GetByUserId(userId)).Result.User.FullName;
returnData.Users.Add(userId, user);
}
return(returnData);
}
public async Task <AdvancedSearchResult> HandleAsync(NotificaitonsAdvancedSearch message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var exportResults =
await repository.SearchExportNotificationsByCriteria(message.Criteria, user.CompetentAuthority);
var importResults =
await repository.SearchImportNotificationsByCriteria(message.Criteria, user.CompetentAuthority);
return(new AdvancedSearchResult
{
ExportResults = exportResults,
ImportResults = importResults
});
}
public async Task <IEnumerable <NotificationAttentionSummaryTableData> > HandleAsync(GetNotificationAttentionSummary message)
{
var internalUser = await internalUserRepository.GetByUserId(userContext.UserId);
var summaryData = await attentionSummaryRepository.GetByCompetentAuthority(internalUser.CompetentAuthority);
var result = new List <NotificationAttentionSummaryTableData>();
foreach (var summary in summaryData)
{
var data = await GetTableDataFromSummary(summary);
result.Add(data);
}
return(result.OrderBy(x => x.DecisionRequiredDate).ToArray());
}
public GetProducerReportHandlerTests()
{
userId = Guid.NewGuid();
var userContext = A.Fake <IUserContext>();
repository = A.Fake <IProducerRepository>();
internalUserRepo = A.Fake <IInternalUserRepository>();
A.CallTo(() => userContext.UserId).Returns(userId);
A.CallTo(() => internalUserRepo.GetByUserId(userId))
.Returns(new TestableInternalUser()
{
UserId = userId.ToString(),
CompetentAuthority = competentAuthority
});
handler = new GetProducerReportHandler(repository, userContext, internalUserRepo);
}
public async Task <Guid> HandleAsync(CreateImportNotification message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var notification = new ImportNotification(message.NotificationType, user.CompetentAuthority, message.Number);
await importNotificationRepository.Add(notification);
await context.SaveChangesAsync();
var assessment = await assessmentRepository.GetByNotification(notification.Id);
assessment.Receive(message.ReceivedDate);
interimStatusRepository.Add(new InterimStatus(notification.Id, message.IsInterim));
await context.SaveChangesAsync();
return(notification.Id);
}
public async Task <Unit> HandleAsync(UpdateInternalUserStatus message)
{
var user = await repository.GetByUserId(message.UserId);
if (message.Status == InternalUserStatus.Approved && user.Status == InternalUserStatus.Inactive)
{
user.Activate();
await context.SaveChangesAsync();
await userManager.SetLockoutEndDateAsync(user.UserId, SystemTime.UtcNow.AddDays(-1));
}
if (message.Status == InternalUserStatus.Inactive && user.Status == InternalUserStatus.Approved)
{
user.Deactivate();
await context.SaveChangesAsync();
await userManager.SetLockoutEnabledAsync(user.UserId, true);
await userManager.SetLockoutEndDateAsync(user.UserId, DateTimeOffset.MaxValue);
}
return(Unit.Value);
}
public async Task GetProducerReportHandler_HandleAsync_CallsInternalUserRepo()
{
await handler.HandleAsync(GetRequest());
A.CallTo(() => internalUserRepo.GetByUserId(A <Guid> .Ignored)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <FreedomOfInformationData[]> HandleAsync(GetFreedomOfInformationReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
return((await repository.Get(message.From, message.To, user.CompetentAuthority, message.DateType, message.SearchField, message.ComparisonType, message.SearchText)).ToArray());
}
public async Task <ExportMovementsData> HandleAsync(GetExportMovementsReport message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
return(await repository.Get(message.From, message.To, user.CompetentAuthority, message.OrganisationFilter, message.OrganisationName));
}
public async Task <UKCompetentAuthority> HandleAsync(GetUserCompetentAuthority message)
{
return((await internalUserRepository.GetByUserId(userContext.UserId)).CompetentAuthority);
}
