Example #1
0
        public async Task <IActionResult> Register([FromBody] RegisterViewModel newUser)
        {
            if (this.ModelState.IsValid)
            {
                IUserManager userManager = this.HttpContext.RequestServices.GetService(typeof(IUserManager)) as IUserManager;
                if (userManager == null)
                {
                    throw new Exception("User Manager object not configured.");
                }

                SpaDatasource.Entitites.User user = new SpaDatasource.Entitites.User
                {
                    Login    = newUser.Login,
                    Email    = newUser.Email,
                    FullName = newUser.FullName,
                    Status   = SpaDatasource.SystemRoles.Customer
                };

                try
                {
                    SpaDatasource.Entitites.User u = await userManager.FindByNameAsync(newUser.Login);

                    if (u != null)
                    {
                        // alrady exists
                        ApiErrorResult apiResultExistingUser = new ApiErrorResult
                        {
                            Messages = new List <string> ()
                            {
                                "Пользователь с таким именем уже существует."
                            }
                        };

                        return(new JsonResult(apiResultExistingUser)
                        {
                            StatusCode = 409
                        });
                    }

                    await userManager.CreateAsync(user, newUser.Password);

                    return(Ok());
                }
                catch (Exception ex)
                {
                    this.ModelState.AddModelError(string.Empty, ex.Message);
                }
            }

            ApiErrorResult apiResultError = new ApiErrorResult
            {
                Messages = ModelState.Keys.SelectMany(key => this.ModelState[key].Errors).Select(x => x.ErrorMessage).ToList <string>()
            };

            return(new JsonResult(apiResultError)
            {
                StatusCode = 500
            });
        }
        public ProfileViewModel GetProfile()
        {
            ProfileViewModel profile = null;

            try
            {
                Claim subClaim = this.User.Claims.Where(o => o.Type == "sub").FirstOrDefault();
                if (subClaim != null)
                {
                    int id = int.Parse(subClaim.Value);

                    _SpaDatasource.Open();
                    SpaDatasource.Entitites.User u = _SpaDatasource.FindUserById(id);

                    if (u != null)
                    {
                        profile = new ProfileViewModel
                        {
                            Id           = u.Id,
                            FullName     = u.FullName,
                            Login        = u.Login,
                            Status       = u.Status,
                            EmailAddress = u.Email,
                            Country      = u.Country,
                            City         = u.City,
                            Zip          = u.Zip,
                            Address      = u.Address
                        };
                    }
                }
            }
            finally
            {
                _SpaDatasource.Close();
            }

            return(profile);
        }
        public override async Task HandleTokenRequest(HandleTokenRequestContext context)
        {
            // Извлекаем из списка сервисов наш менеджер пользователей
            IUserManager userManager = context.HttpContext.RequestServices.GetService(typeof(IUserManager)) as IUserManager;

            if (userManager == null)
            {
                throw new Exception("User Manager object not configured.");
            }

            // Будем обрабатывать только запросы типа: grant_type=password
            // Запросы типа grant_type=refresh_token будут автоматически обрабатываться ASOS
            if (context.Request.IsPasswordGrantType())
            {
                // Ищем пользователя в БД
                SpaDatasource.Entitites.User user = await userManager.FindByNameAsync(context.Request.Username);

                if (user == null)
                {
                    // Нет пользователя, вернем ошибку
                    context.Reject(
                        error: OpenIdConnectConstants.Errors.InvalidGrant,
                        description: "Invalid credentials.");
                    return;
                }

                // Проверим что пароль задан правильно
                if (!await userManager.CheckPasswordAsync(user, context.Request.Password))
                {
                    // Пароль неверный - вернем ошибку
                    context.Reject(
                        error: OpenIdConnectConstants.Errors.InvalidGrant,
                        description: "Invalid credentials.");

                    return;
                }

                var identity = new ClaimsIdentity(context.Scheme.Name,
                                                  OpenIdConnectConstants.Claims.Name,
                                                  OpenIdConnectConstants.Claims.Role);

                // subject claimвсегад включается как в Calim Identity так и в
                // access tokens, даже если это не указано явно.
                // subject - это уникальный идентификатор пользователя
                Claim c = new Claim(OpenIdConnectConstants.Claims.Subject, user.Id.ToString());
                identity.AddClaim(c);

                // Создаем новый билет аутенфикации
                var ticket = new AuthenticationTicket(
                    new ClaimsPrincipal(identity),
                    new AuthenticationProperties(),
                    context.Scheme.Name);

                // Устанавлием области (scopes)
                // Это обьязательный минимум
                ticket.SetScopes(
                    OpenIdConnectConstants.Scopes.OpenId,
                    OpenIdConnectConstants.Scopes.OfflineAccess,
                    OpenIdConnectConstants.Scopes.Profile);

                // Возвращаем билет аутенфикации, на основе которого будут сгенерированы два токена
                // access token и refresh token
                context.Validate(ticket);
            }

            return;
        }