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)); }