예제 #1
0
        public async Task <Either <ActionResult, UserInvite> > InviteUser(string email, string roleId)
        {
            return(await _userService
                   .CheckCanManageAllUsers()
                   .OnSuccess(() => ValidateUserDoesNotExist(email))
                   .OnSuccess <ActionResult, Unit, UserInvite>(async() =>
            {
                var role = await _usersAndRolesDbContext.Roles
                           .AsQueryable()
                           .FirstOrDefaultAsync(r => r.Id == roleId);

                if (role == null)
                {
                    return ValidationActionResult(InvalidUserRole);
                }

                return await _userInviteRepository.Create(
                    email: email.ToLower(),
                    roleId: roleId,
                    createdById: _userService.GetUserId());
            })
                   .OnSuccess(invite =>
            {
                return _emailTemplateService
                .SendInviteEmail(email)
                .OnSuccess(() => invite);
            }));
        }
        private async Task <Either <ActionResult, PreReleaseUserViewModel> > InvitePreReleaseUser(Release release,
                                                                                                  string email)
        {
            var user = await _userRepository.FindByEmail(email);

            if (user == null)
            {
                return(await CreateUserReleaseInvite(release, email)
                       .OnSuccessDo(() => _userInviteRepository.Create(
                                        email: email,
                                        role: Role.PrereleaseUser,
                                        createdById: _userService.GetUserId()))
                       .OnSuccess(_ => new PreReleaseUserViewModel(email)));
            }

            return(await CreateExistingUserReleaseInvite(release, email, user)
                   .OnSuccess(_ => new PreReleaseUserViewModel(email)));
        }
예제 #3
0
        private async Task <Either <ActionResult, Unit> > CreateNewUserContributorInvite(List <Guid> releaseIds,
                                                                                         string email, string publicationTitle)
        {
            if (await _userReleaseInviteRepository.UserHasInvites(
                    releaseIds: releaseIds,
                    email: email,
                    role: Contributor))
            {
                // if the user already has UserReleaseInvites,
                // we assume they also have a UserInvite outstanding
                return(ValidationActionResult(UserAlreadyHasReleaseRoleInvites));
            }

            var emailResult = await SendContributorInviteEmail(
                publicationTitle : publicationTitle,
                releaseIds : releaseIds,
                email : email);

            if (emailResult.IsLeft)
            {
                return(emailResult);
            }

            await _userInviteRepository.Create(
                email : email,
                role : Role.Analyst,
                createdById : _userService.GetUserId());

            await _userReleaseInviteRepository.CreateManyIfNotExists(
                releaseIds : releaseIds,
                email : email,
                releaseRole : Contributor,
                emailSent : true,
                createdById : _userService.GetUserId());

            return(Unit.Instance);
        }