Beispiel #1
0
            public async Task <CreateUserVm> Handle(CreateUserCommand request, CancellationToken cancellationToken)
            {
                var vm = new CreateUserVm();

                var user = await _userManager.FindByNameAsync(request.UserName);

                if (user == null)
                {
                    var created = await _userManager.CreateUserAsync(request.UserName, request.Password, request.Email);

                    if (created)
                    {
                        var addedUser = await _userManager.FindByNameAsync(request.UserName);

                        vm.Token    = _jwtGenerator.CreateToken(addedUser);
                        vm.Username = addedUser.UserName;

                        return(vm);
                    }

                    vm.Error = "Passwords did not match!";
                    return(vm);
                }

                vm.Error = "The user already exists!";
                return(vm);
            }
Beispiel #2
0
        public async Task <Unit> Handle(SeedSampleDataCommand request, CancellationToken cancellationToken)
        {
            var names = Enum.GetNames(typeof(ApplicationUserType));

            foreach (var roleName in names)
            {
                var roleExist = await _userRoleManagerService.RoleExistsAsync(roleName);

                if (!roleExist)
                {
                    await _userRoleManagerService.CreateUserRoleAsync(roleName);
                }
            }

            var entity = new ApplicationUser(
                "demouser@demo",
                "Demo",
                "Spa",
                "1234567890"
                );

            var userExist = await _userManagerService.UserExistsAsync(entity.Email);

            if (!userExist)
            {
                await _userManagerService.CreateUserAsync(entity, ApplicationUserType.Admin, "Pass@word1");
            }

            return(Unit.Value);
        }
Beispiel #3
0
        public async Task <IActionResult> Register([Bind("FirstName,LastName,Email,Password")] RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var registerResult = await userManagerService.CreateUserAsync(model.Email, model.Password);

                if (registerResult.RegisterResult.Succeeded &&
                    registerResult.ConfirmEmailResult.Succeeded)
                {
                    var signinResult = await signinManagerService.SigninAsync(model.Email, model.Password);

                    if (signinResult.Succeeded)
                    {
                        return(RedirectToAction("Index", "Home"));
                    }
                }
            }

            return(View());
        }
Beispiel #4
0
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
        {
            var result = new ApiResponse <Empty>();

            if (!ModelState.IsValid)
            {
                result.AddError(ModelState);
                return(Ok(result));
            }

            var createResult = await userManagerService.CreateUserAsync(model.Email, model.Password);

            if (createResult.RegisterResult.Succeeded)
            {
                return(Ok(result));
            }

            result.AddError(createResult.RegisterResult.Errors);

            return(Ok(result));
        }
        public async Task <IServiceReponse <bool> > Register(UserDto registration, UserType userType = UserType.Employee)
        {
            return(await HandleApiOperationAsync(async() =>
            {
                if (await _userManager.UserExistsAsync(registration.Email))
                {
                    throw await _helper.GetExceptionAsync(ErrorConstants.UserAccountExists);
                }

                if (!await _userManager.RolesExistAsync(registration.Roles ?? new List <string>()))
                {
                    throw await _helper.GetExceptionAsync(ErrorConstants.RoleNotExist);
                }

                var user = registration.MapTo <User>();

                user.UserType = userType;
                user.IsActive = true;

                var password = _passwordGenerator.Generate();

                if (!await _userManager.CreateUserAsync(user, password, registration.Roles ?? new List <string>()))
                {
                    throw await _helper.GetExceptionAsync(ErrorConstants.UserAccountRegistrationFailed);
                }

                await _messagingFactory.GetEmailManager().SendAsync(
                    "Business Mobility",
                    user.Email,
                    "Welcome to Business!",
                    $"<div> username: {user.Email } </div> <div> password: {password} </div>",
                    true
                    );

                return new ServiceResponse <bool>(true);
            }));
        }
        public async Task <Unit> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
        {
            var applicationUser = new ApplicationUser(
                request.Email,
                request.FirstName,
                request.LastName,
                request.PersonalId
                );

            var userExist = await _userManagerService.UserExistsAsync(applicationUser.Email);

            if (userExist)
            {
                throw new DomainException("Customer exists");
            }

            var identityResult = await _userManagerService.CreateUserAsync(applicationUser, ApplicationUserType.Admin, request.Password);

            if (!identityResult.Result.Succeeded)
            {
                throw new DomainException(string.Join(", ", identityResult.Result.Errors));
            }

            var customer = new Customer(
                Guid.NewGuid(),
                request.gender,
                request.birthDate,
                applicationUser.Id
                );

            _context.Add(customer);

            await SaveAndPublish(customer, cancellationToken);

            return(Unit.Value);
        }
Beispiel #7
0
 public async Task <Result> Handle(RegistrationCommand request, CancellationToken cancellationToken)
 {
     return(await _userManagerService.CreateUserAsync(request.Name, request.Email, request.Password));
 }
Beispiel #8
0
        public async Task <UserRegisterResult> Register(UserInfo userInfo)
        {
            var userRegisterResult = await _userManagerService.CreateUserAsync(userInfo);

            return(userRegisterResult);
        }