public async Task <Result <Unit> > Handle(UpdateAttendedStatusAndNotesOnParticipantsCommand request, CancellationToken cancellationToken)
{
var invitation = await _invitationRepository.GetByIdAsync(request.InvitationId);
var currentUserAzureOid = _currentUserProvider.GetCurrentUserOid();
var participants = invitation.Participants.Where(p =>
p.SortKey == 0 &&
p.Organization == Organization.Contractor &&
p.AzureOid == currentUserAzureOid).ToList();
if (!participants.Any() || participants.Any(p => p.FunctionalRoleCode != null))
{
var functionalRole = invitation.Participants
.Single(p => p.SortKey == 0 &&
p.FunctionalRoleCode != null &&
p.Type == IpoParticipantType.FunctionalRole);
await UpdateAsPersonInFunctionalRoleAsync(invitation, functionalRole.FunctionalRoleCode, request.Participants);
}
else
{
UpdateParticipantStatusesAndNotes(invitation, request.Participants);
}
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <Unit>(Unit.Value));
}
private async Task <InvitationDto> ConvertToInvitationDtoAsync(Invitation invitation, GeneralMeeting meeting, Person createdBy)
{
var canEdit = meeting != null &&
(meeting.Participants.Any(p => p.Person.Id == _currentUserProvider.GetCurrentUserOid()) ||
meeting.Organizer.Id == _currentUserProvider.GetCurrentUserOid());
var currentUserIsCreator = createdBy.Id == invitation.CreatedById;
var canDelete = invitation.Status == IpoStatus.Canceled && currentUserIsCreator;
var canCancel = invitation.Status is IpoStatus.Completed or IpoStatus.Planned &&
(currentUserIsCreator ||
await CurrentUserIsAmongParticipantsAsync(invitation.Participants.Where(p => p.SortKey == 0).ToList()));
var invitationResult = new InvitationDto(
invitation.ProjectName,
invitation.Title,
invitation.Description,
invitation.Location,
invitation.Type,
invitation.Status,
ConvertToPersonDto(invitation.CreatedById).Result,
invitation.StartTimeUtc,
invitation.EndTimeUtc,
canEdit,
invitation.RowVersion.ConvertToString(),
canCancel,
canDelete)
{
Participants = await ConvertToParticipantDtoAsync(invitation.Participants, invitation.Status),
McPkgScope = ConvertToMcPkgDto(invitation.McPkgs),
CommPkgScope = ConvertToCommPkgDto(invitation.CommPkgs)
};
AddParticipantTypeAndOutlookResponseToParticipants(meeting, invitationResult);
return(invitationResult);
}
public void Clear(
[FromHeader(Name = CurrentPlantMiddleware.PlantHeader)]
[Required]
[StringLength(PlantEntityBase.PlantLengthMax, MinimumLength = PlantEntityBase.PlantLengthMin)]
string plant)
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
_plantCache.Clear(currentUserOid);
_permissionCache.ClearAll(plant, currentUserOid);
}
public async Task <Result <int> > Handle(CreateInvitationCommand request, CancellationToken cancellationToken)
{
var transaction = await _unitOfWork.BeginTransaction(cancellationToken);
var meetingParticipants = new List <BuilderParticipant>();
var mcPkgs = new List <McPkg>();
var commPkgs = new List <CommPkg>();
if (request.CommPkgScope.Count > 0)
{
commPkgs = await GetCommPkgsToAddAsync(request.CommPkgScope, request.ProjectName);
}
if (request.McPkgScope.Count > 0)
{
mcPkgs = await GetMcPkgsToAddAsync(request.McPkgScope, request.ProjectName);
}
var invitation = new Invitation(
_plantProvider.Plant,
request.ProjectName,
request.Title,
request.Description,
request.Type,
request.StartTime,
request.EndTime,
request.Location,
mcPkgs,
commPkgs);
_invitationRepository.Add(invitation);
meetingParticipants = await AddParticipantsAsync(invitation, meetingParticipants, request.Participants.ToList());
await _unitOfWork.SaveChangesAsync(cancellationToken);
try
{
invitation.MeetingId = await CreateOutlookMeeting(request, meetingParticipants, invitation);
await _unitOfWork.SaveChangesAsync(cancellationToken);
_unitOfWork.Commit();
return(new SuccessResult <int>(invitation.Id));
}
catch (Exception e)
{
await transaction.RollbackAsync(cancellationToken);
throw new Exception($"Error: User with oid {_currentUserProvider.GetCurrentUserOid()} could not create outlook meeting for invitation {invitation.Id}.", e);
}
}
public async Task <bool> ExistsWithSameTitleForPersonInProjectAsync(string title, string projectName,
CancellationToken token)
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
return(await(from s in _context.QuerySet <SavedFilter>()
join p in _context.QuerySet <Person>() on EF.Property <int>(s, "PersonId") equals p.Id
join pr in _context.QuerySet <Project>() on s.ProjectId equals pr.Id
where pr.Name == projectName &&
p.Oid == currentUserOid &&
s.Title == title
select s).AnyAsync(token));
}
private async Task SetAuditDataAsync()
{
var addedEntries = ChangeTracker
.Entries <ICreationAuditable>()
.Where(x => x.State == EntityState.Added)
.ToList();
var modifiedEntries = ChangeTracker
.Entries <IModificationAuditable>()
.Where(x => x.State == EntityState.Modified)
.ToList();
if (addedEntries.Any() || modifiedEntries.Any())
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
var currentUser = await Persons.SingleOrDefaultAsync(p => p.Oid == currentUserOid);
foreach (var entry in addedEntries)
{
entry.Entity.SetCreated(currentUser);
}
foreach (var entry in modifiedEntries)
{
entry.Entity.SetModified(currentUser);
}
}
}
private static void SeedCurrentUserAsPerson(IPOContext dbContext, ICurrentUserProvider userProvider)
{
var personRepository = new PersonRepository(dbContext);
personRepository.Add(new Person(userProvider.GetCurrentUserOid(), "Siri", "Seed", "ss", "*****@*****.**"));
dbContext.SaveChangesAsync().Wait();
}
public async Task <Result <List <SavedFilterDto> > > Handle(GetSavedFiltersInProjectQuery request,
CancellationToken cancellationToken)
{
var project = await(from p in _context.QuerySet <Project>()
where p.Name == request.ProjectName
select p).SingleOrDefaultAsync(cancellationToken);
if (project == null)
{
return(new SuccessResult <List <SavedFilterDto> >(new List <SavedFilterDto>()));
}
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
var person = await(from p in _context.QuerySet <Person>().Include(p => p.SavedFilters)
where p.Oid == currentUserOid
select p).SingleAsync(cancellationToken);
var savedFilterDtos = person.SavedFilters.Where(sf => sf.ProjectId == project.Id)
.Select(savedFilter => new SavedFilterDto(
savedFilter.Id,
savedFilter.Title,
savedFilter.Criteria,
savedFilter.DefaultFilter,
savedFilter.CreatedAtUtc,
savedFilter.RowVersion.ConvertToString())).ToList();
return(new SuccessResult <List <SavedFilterDto> >(savedFilterDtos));
}
public async Task <Result <int> > Handle(CreateSavedFilterCommand request, CancellationToken cancellationToken)
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
var person = await _personRepository.GetWithSavedFiltersByOidAsync(currentUserOid);
var project = await _projectRepository.GetProjectOnlyByNameAsync(request.ProjectName);
if (request.DefaultFilter)
{
var currentDefaultFilter = person.GetDefaultFilter(project.Id);
if (currentDefaultFilter != null)
{
currentDefaultFilter.DefaultFilter = false;
}
}
var savedFilter = new SavedFilter(_plantProvider.Plant, project, request.Title, request.Criteria)
{
DefaultFilter = request.DefaultFilter
};
person.AddSavedFilter(savedFilter);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <int>(savedFilter.Id));
}
public async Task <Result <string> > Handle(UpdateSavedFilterCommand request, CancellationToken cancellationToken)
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
var person = await _personRepository.GetWithSavedFiltersByOidAsync(currentUserOid);
var savedFilter = person.SavedFilters.Single(sf => sf.Id == request.SavedFilterId);
if (request.DefaultFilter == true)
{
var currentDefaultFilter = person.GetDefaultFilter(savedFilter.ProjectName);
if (currentDefaultFilter != null)
{
currentDefaultFilter.DefaultFilter = false;
}
}
savedFilter.Title = request.Title;
savedFilter.Criteria = request.Criteria;
if (request.DefaultFilter.HasValue)
{
savedFilter.DefaultFilter = request.DefaultFilter.Value;
}
savedFilter.SetRowVersion(request.RowVersion);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(savedFilter.RowVersion.ConvertToString()));
}
public async Task <Result <string> > Handle(UnCompletePunchOutCommand request, CancellationToken cancellationToken)
{
var invitation = await _invitationRepository.GetByIdAsync(request.InvitationId);
var currentUserAzureOid = _currentUserProvider.GetCurrentUserOid();
var hasAdminPrivilege = await InvitationHelper.HasIpoAdminPrivilege(_permissionCache, _plantProvider, _currentUserProvider);
var participant = invitation.Participants.SingleOrDefault(p =>
p.SortKey == 0 &&
p.Organization == Organization.Contractor &&
(p.AzureOid == currentUserAzureOid || hasAdminPrivilege));
if (participant == null || participant.FunctionalRoleCode != null)
{
var functionalRole = invitation.Participants
.SingleOrDefault(p => p.SortKey == 0 &&
p.FunctionalRoleCode != null &&
p.Type == IpoParticipantType.FunctionalRole);
invitation.UnCompleteIpo(functionalRole, request.ParticipantRowVersion);
}
else
{
invitation.UnCompleteIpo(participant, request.ParticipantRowVersion);
}
invitation.SetRowVersion(request.InvitationRowVersion);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(invitation.RowVersion.ConvertToString()));
}
public async Task <Result <string> > Handle(AcceptPunchOutCommand request, CancellationToken cancellationToken)
{
var invitation = await _invitationRepository.GetByIdAsync(request.InvitationId);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
var participant = invitation.Participants.SingleOrDefault(p =>
p.SortKey == 1 &&
p.Organization == Organization.ConstructionCompany &&
p.AzureOid == currentUser.Oid);
var acceptedAtUtc = DateTime.UtcNow;
if (participant == null || participant.FunctionalRoleCode != null)
{
var functionalRole = invitation.Participants
.SingleOrDefault(p => p.SortKey == 1 &&
p.FunctionalRoleCode != null &&
p.Type == IpoParticipantType.FunctionalRole);
invitation.AcceptIpo(functionalRole, request.ParticipantRowVersion, currentUser, acceptedAtUtc);
}
else
{
invitation.AcceptIpo(participant, request.ParticipantRowVersion, currentUser, acceptedAtUtc);
}
UpdateNotesOnParticipants(invitation, request.Participants);
invitation.SetRowVersion(request.InvitationRowVersion);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(invitation.RowVersion.ConvertToString()));
}
private static Person EnsureCurrentUserIsSeeded(PreservationContext dbContext, ICurrentUserProvider userProvider)
{
var personRepository = new PersonRepository(dbContext);
var person = personRepository.GetByOidAsync(userProvider.GetCurrentUserOid()).Result ??
SeedCurrentUserAsPerson(dbContext, userProvider);
return(person);
}
private static Person SeedCurrentUserAsPerson(PreservationContext dbContext, ICurrentUserProvider userProvider)
{
var personRepository = new PersonRepository(dbContext);
var person = new Person(userProvider.GetCurrentUserOid(), "Siri", "Seed");
personRepository.Add(person);
dbContext.SaveChangesAsync().Wait();
return(person);
}
public async Task <Result <OutstandingIposResultDto> > Handle(GetOutstandingIposForCurrentPersonQuery request,
CancellationToken cancellationToken)
{
try
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
//We could have filtered based on project access, however
//the scenario that a person should lose access to a single project
//in a plant after being added to the invitation is (according to the client)
//so unlikely that we do not need to take it into consideration
var nonCancelledInvitations = await(from i in _context.QuerySet <Invitation>()
.Include(ss => ss.Participants)
where !i.AcceptedAtUtc.HasValue
where i.Status != IpoStatus.Canceled
select i).ToListAsync(cancellationToken);
var currentUsersOutstandingInvitations = new List <Invitation>();
foreach (var invitation in nonCancelledInvitations)
{
var currentUsersFunctionalRoleCodes =
await _meApiService.GetFunctionalRoleCodesAsync(_plantProvider.Plant);
if (UserWasInvitedAsPersonParticipant(invitation, currentUserOid))
{
currentUsersOutstandingInvitations.Add(invitation);
}
else if (UserWasInvitedAsPersonInFunctionalRole(invitation, currentUsersFunctionalRoleCodes))
{
currentUsersOutstandingInvitations.Add(invitation);
}
}
var outstandingIposResultDto = new OutstandingIposResultDto(
currentUsersOutstandingInvitations.Select(invitation =>
{
var organization = invitation.CompletedAtUtc.HasValue ?
Organization.ConstructionCompany : Organization.Contractor;
return(new OutstandingIpoDetailsDto
{
InvitationId = invitation.Id,
Description = invitation.Description,
Organization = organization
});
}));
return(new SuccessResult <OutstandingIposResultDto>(outstandingIposResultDto));
}
catch (Exception)
{
return(new SuccessResult <OutstandingIposResultDto>(new OutstandingIposResultDto(
new List <OutstandingIpoDetailsDto>())));
}
}
public async Task <Result <string> > Handle(CloseActionCommand request, CancellationToken cancellationToken)
{
var tag = await _projectRepository.GetTagByTagIdAsync(request.TagId);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
var action = tag.CloseAction(request.ActionId, currentUser, TimeService.UtcNow, request.RowVersion);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(action.RowVersion.ConvertToString()));
}
public async Task <Result <Unit> > Handle(PreserveCommand request, CancellationToken cancellationToken)
{
var tag = await _projectRepository.GetTagByTagIdAsync(request.TagId);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
tag.Preserve(currentUser, request.RequirementId);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <Unit>(Unit.Value));
}
public async Task <Result <string> > Handle(SignPunchOutCommand request, CancellationToken cancellationToken)
{
var invitation = await _invitationRepository.GetByIdAsync(request.InvitationId);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
var participant = invitation.Participants.Single(p => p.Id == request.ParticipantId);
invitation.SignIpo(participant, currentUser, request.ParticipantRowVersion);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(participant.RowVersion.ConvertToString()));
}
public async Task <bool> HasPermissionToEditParticipantAsync(int id, int invitationId, CancellationToken cancellationToken)
{
if (await InvitationHelper.HasIpoAdminPrivilege(_permissionCache, _plantProvider, _currentUserProvider))
{
return(true);
}
var invitation = await(from i in _context.QuerySet <Invitation>()
where i.Id == invitationId
select i).SingleAsync(cancellationToken);
switch (invitation.Status)
{
case IpoStatus.Planned when await CurrentUserIsValidCompleterParticipantAsync(invitationId, cancellationToken):
case IpoStatus.Completed when await CurrentUserIsValidAccepterParticipantAsync(invitationId, cancellationToken):
return(true);
}
var participant = await(from p in _context.QuerySet <Participant>()
where EF.Property <int>(p, "InvitationId") == invitationId &&
p.Id == id
select p).SingleAsync(cancellationToken);
if (participant.SignedAtUtc != null)
{
return(false);
}
if (participant.FunctionalRoleCode == null &&
participant.AzureOid == _currentUserProvider.GetCurrentUserOid())
{
return(true);
}
var person = await _personApiService.GetPersonInFunctionalRoleAsync(
_plantProvider.Plant,
_currentUserProvider.GetCurrentUserOid().ToString(),
participant.FunctionalRoleCode);
return(person != null);
}
public async Task <Result <string> > Handle(CancelPunchOutCommand request, CancellationToken cancellationToken)
{
var invitation = await _invitationRepository.GetByIdAsync(request.InvitationId);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
invitation.CancelIpo(currentUser);
invitation.SetRowVersion(request.RowVersion);
await CancelFusionMeetingAsync(invitation.MeetingId);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <string>(invitation.RowVersion.ConvertToString()));
}
public async Task <Result <Unit> > Handle(BulkPreserveCommand request, CancellationToken cancellationToken)
{
var tags = await _projectRepository.GetTagsByTagIdsAsync(request.TagIds);
var currentUser = await _personRepository.GetByOidAsync(_currentUserProvider.GetCurrentUserOid());
foreach (var tag in tags)
{
tag.BulkPreserve(currentUser);
}
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <Unit>(Unit.Value));
}
public async Task EnsureValidProjectAsync <TRequest>(TRequest request) where TRequest : IBaseRequest
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var plant = _plantProvider.Plant;
var userOid = _currentUserProvider.GetCurrentUserOid();
if (request is IProjectRequest projectRequest && !await _permissionCache.IsAValidProjectAsync(plant, userOid, projectRequest.ProjectName))
{
throw new InValidProjectException($"Project '{projectRequest.ProjectName}' is not a valid project in '{plant}'");
}
}
public async Task <Result <Unit> > Handle(DeleteSavedFilterCommand request, CancellationToken cancellationToken)
{
var currentUserOid = _currentUserProvider.GetCurrentUserOid();
var person = await _personRepository.GetWithSavedFiltersByOidAsync(currentUserOid);
var savedFilter = person.SavedFilters.Single(sf => sf.Id == request.SavedFilterId);
savedFilter.SetRowVersion(request.RowVersion);
person.RemoveSavedFilter(savedFilter);
_personRepository.RemoveSavedFilter(savedFilter);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(new SuccessResult <Unit>(Unit.Value));
}
public async Task <bool> ValidateAsync <TRequest>(TRequest request) where TRequest : IBaseRequest
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userOid = _currentUserProvider.GetCurrentUserOid();
if (request is IProjectRequest projectRequest && !_projectAccessChecker.HasCurrentUserAccessToProject(projectRequest.ProjectName))
{
_logger.LogWarning($"Current user {userOid} doesn't have have access to project {projectRequest.ProjectName}");
return(false);
}
if (request is ITagCommandRequest tagCommandRequest)
{
if (!await HasCurrentUserAccessToProjectAsync(tagCommandRequest.TagId, userOid))
{
return(false);
}
if (!await HasCurrentUserAccessToContentAsync(tagCommandRequest))
{
_logger.LogWarning($"Current user {userOid} doesn't have access to content {tagCommandRequest.TagId}");
return(false);
}
}
if (request is ITagQueryRequest tagQueryRequest)
{
if (!await HasCurrentUserAccessToProjectAsync(tagQueryRequest.TagId, userOid))
{
return(false);
}
}
if (request is ICrossPlantQueryRequest)
{
if (!IsUserCrossPlantUser(userOid))
{
return(false);
}
}
return(true);
}
public async Task <bool> ValidateAsync <TRequest>(TRequest request) where TRequest : IBaseRequest
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userOid = _currentUserProvider.GetCurrentUserOid();
if (request is IProjectRequest projectRequest && !_projectAccessChecker.HasCurrentUserAccessToProject(projectRequest.ProjectName))
{
_logger.LogWarning($"Current user {userOid} don't have access to project {projectRequest.ProjectName}");
return(false);
}
if (request is IPurchaseOrderCommandRequest poCommandRequest)
{
var projectName = ""; // todo await _poHelper.GetProjectNameAsync(poCommandRequest.PurchaseOrderId);
var accessToProject = _projectAccessChecker.HasCurrentUserAccessToProject(projectName);
if (!accessToProject)
{
_logger.LogWarning($"Current user {userOid} don't have access to project {projectName}");
}
var accessToContent = await HasCurrentUserAccessToContentAsync(poCommandRequest);
if (!accessToContent)
{
_logger.LogWarning($"Current user {userOid} don't have access to content {poCommandRequest.PurchaseOrderId}");
}
return(accessToProject && accessToContent);
}
if (request is IPurchaseOrderQueryRequest poQueryRequest)
{
var projectName = ""; // todo await _poHelper.GetProjectNameAsync(poQueryRequest.PurchaseOrderId);
if (!_projectAccessChecker.HasCurrentUserAccessToProject(projectName))
{
_logger.LogWarning($"Current user {userOid} don't have access to project {projectName}");
return(false);
}
}
return(true);
}
public async Task <bool> ValidateAsync <TRequest>(TRequest request) where TRequest : IBaseRequest
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userOid = _currentUserProvider.GetCurrentUserOid();
if (request is IProjectRequest projectRequest &&
!_projectAccessChecker.HasCurrentUserAccessToProject(projectRequest.ProjectName))
{
_logger.LogWarning($"Current user {userOid} don't have access to project {projectRequest.ProjectName}");
return(false);
}
if (request is IInvitationCommandRequest invitationCommandRequest)
{
if (!await HasCurrentUserAccessToProjectAsync(invitationCommandRequest.InvitationId, userOid))
{
return(false);
}
}
if (request is IInvitationQueryRequest invitationQueryRequest)
{
if (!await HasCurrentUserAccessToProjectAsync(invitationQueryRequest.InvitationId, userOid))
{
return(false);
}
}
return(true);
}
public static async Task <bool> HasIpoAdminPrivilege(
IPermissionCache permissionCache,
IPlantProvider plantProvider,
ICurrentUserProvider currentUserProvider)
{
var permissions = await permissionCache.GetPermissionsForUserAsync(plantProvider.Plant, currentUserProvider.GetCurrentUserOid());
return(permissions != null && permissions.Contains("IPO/ADMIN"));
}
public bool HasCurrentUserAccessToCrossPlant()
{
_logger.LogInformation($"Allowed CrossPlantUserOids: '{_attachmentOptions.CurrentValue}'");
return(_attachmentOptions.CurrentValue.CrossPlantUserOids()
.Contains(_currentUserProvider.GetCurrentUserOid()));
}
public async Task <bool> HasCurrentUserAccessToPlantAsync(string plantId)
{
var userOid = _currentUserProvider.GetCurrentUserOid();
return(await HasUserAccessToPlantAsync(plantId, userOid));
}
