Ejemplo n.º 1
0
        public async Task <IActionResult> Index(ushort page = 1)
        {
            var totalPages = Math.Ceiling(await _userManager.Users.LongCountAsync() / (decimal)Constants.ItemsPerPageUserAdmin);

            page = page >= 1 && page <= totalPages ? page : (ushort)1;

            var users = _userManager.Users.OrderBy(user => user.UserName).Skip(Constants.ItemsPerPageUserAdmin * (page - 1)).Take(Constants.ItemsPerPageUserAdmin).AsEnumerable()
                        .Select(Mapper.MapToModel).ToArray();

            foreach (var user in users)
            {
                user.Role = Utilities.FromRole((await _userManager.GetRolesAsync(await _userManager.FindByIdAsync(user.UserId.ToString()))).FirstOrDefault());
            }

            ViewData["Page"]          = page;
            ViewData["TotalPages"]    = totalPages;
            ViewData["DeletionRoute"] = Url.Action("Delete", new { userId = Guid.Empty }).Replace(Guid.Empty.ToString(), string.Empty);

            return(View(users));
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> Add(UserModel userModel)
        {
            if (ModelState.IsValid)
            {
                if (await _userManager.FindByEmailAsync(userModel.Email) != null)
                {
                    return(Json(new
                    {
                        success = false,
                        messages = new[] { ValidationMessages.EmailAlreadyInUse }
                    }));
                }

                if (await _userManager.FindByNameAsync(userModel.Username) != null)
                {
                    return(Json(new
                    {
                        success = false,
                        messages = new[] { ValidationMessages.UsernameAlreadyInUse }
                    }));
                }

                var user = Mapper.MapToEntity(userModel);

                await using var transaction = await _context.Database.BeginTransactionAsync();

                if (await _parameterManager.GetValue <bool>(ParameterTypes.EmailSenderEnabled))
                {
                    var userResult = string.IsNullOrWhiteSpace(userModel.Password) ? await _userManager.CreateAsync(user) : await _userManager.CreateAsync(user, userModel.Password);

                    if (userResult.Succeeded)
                    {
                        if (Utilities.ToRole(userModel.Role) is var resultingRole && resultingRole != null)
                        {
                            var roleResult = await _userManager.AddToRoleAsync(user, resultingRole);

                            if (roleResult.Succeeded)
                            {
                                TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedEmailSent };

                                await transaction.CommitAsync();
                                await SendAccountCreationEmail(user);

                                return(Json(new
                                {
                                    success = true,
                                    destination = Url.Action("Index")
                                }));
                            }
                        }
                        else
                        {
                            TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedEmailSent };

                            await transaction.CommitAsync();
                            await SendAccountCreationEmail(user);

                            return(Json(new
                            {
                                success = true,
                                destination = Url.Action("Index")
                            }));
                        }
                    }

                    ModelState.AddModelError("SomethingWrong", OtherMessages.SomethingWrong);
                }
                else
                {
                    user.EmailConfirmed = true;

                    if (!string.IsNullOrWhiteSpace(userModel.Password))
                    {
                        var userResult = await _userManager.CreateAsync(user, userModel.Password);

                        if (userResult.Succeeded)
                        {
                            if (Utilities.ToRole(userModel.Role) is var resultingRole && resultingRole != null)
                            {
                                var roleResult = await _userManager.AddToRoleAsync(user, resultingRole);

                                if (roleResult.Succeeded)
                                {
                                    TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedSuccessfully };

                                    await transaction.CommitAsync();

                                    return(Json(new
                                    {
                                        success = true,
                                        destination = Url.Action("Index")
                                    }));
                                }
                            }
                            else
                            {
                                TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedSuccessfully };

                                await transaction.CommitAsync();

                                return(Json(new
                                {
                                    success = true,
                                    destination = Url.Action("Index")
                                }));
                            }
                        }

                        ModelState.AddModelError("SomethingWrong", OtherMessages.SomethingWrong);
                    }