public async Task <ResponseModel <LoginModel> > Login(string userName, string password, string uri, bool isPersistent = false, bool lockoutOnFailure = false) { var result = await _signInManager.PasswordSignInAsync(userName, password, isPersistent, lockoutOnFailure); var responseModel = new ResponseModel <LoginModel>(result.Succeeded); if (!result.Succeeded) { responseModel.AddError(AppErrors.PasswordOrUserIncorrect); return(responseModel); } var user = await _accountRepository.Get(userName); var loginModel = new LoginModel(user.Email); responseModel.Data = loginModel; if (!await _accountRepository.IsEmailConfirmedAsync(userName)) { responseModel.Success = false; responseModel.AddError(AppErrors.EmailNotConfirmed); return(responseModel); } var token = BuildToken(user.UserName, user.Email); responseModel.Data.AddToken(token); return(responseModel); }
public async Task <ResponseModel <LoginModel> > ResetPassword(string email, string password, string confirmPassword, string token) { var user = await _accountRepository.GetByEmail(email); var loginModel = new LoginModel(email); var response = new ResponseModel <LoginModel>(loginModel); if (user == null) { response.AddError(AppErrors.PasswordOrUserIncorrect); return(response); } var result = await _accountRepository.ResetPassword(user, token, password); if (!result.Succeeded) { foreach (var error in result.Errors) { response.AddError(new ErrorResponseModel(error.Code, error.Description)); } return(response); } await _emailClientSender.SendConfirmationResetPassword(user.Email, new SendResetPasswordModel(user.UserName)); response.Success = true; return(response); }
public async Task <ResponseModel <LoginModel> > GetPasswordResetToken(string email) { var user = await _accountRepository.GetByEmail(email); var loginModel = new LoginModel(email); var response = new ResponseModel <LoginModel>(loginModel); if (user == null) { response.AddError(AppErrors.PasswordOrUserIncorrect); return(response); } var token = await _accountRepository.GeneratePasswordResetTokenAsync(user); var api = "/ConfirmationRegisterMail"; var webAppUrl = "https://cienciaargentina.com"; var url = $"www.MATIASCODEAESTO={user.Email}&token={token}"; url = url.Replace("+", "%2B"); await _emailClientSender.SendGetPasswordResetToken(email, new SendGetPasswordResetTokenModel(user.UserName, url)); return(response); }
public async Task <ResponseModel <AccountModelApi <int> > > GetUserByEmailAsync(String email) { var accByEmail = await this._redisCachingService.GetItemAsync <AccountModelBussines <int> >( RedisCachingKeysUtil.GET_ACCOUNT_BY_EMAIL_KEY + email ); if (accByEmail == null) { accByEmail = await this._accountRepository.GetByEmailAsync(email); await this._redisCachingService.PutItemAsync <AccountModelBussines <int> >( RedisCachingKeysUtil.GET_ACCOUNT_BY_EMAIL_KEY + email, accByEmail, new DistributedCacheEntryOptions() { AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(3), SlidingExpiration = TimeSpan.FromDays(1) } ); } ResponseModel <AccountModelApi <int> > resp = new ResponseModel <AccountModelApi <int> >( AutoMapperConfig.Mapper.Map <AccountModelApi <int> >(accByEmail) ); if (accByEmail == null) { resp.AddError(new Error($"Item with email {email} not found.")); } return(resp); }
public async Task <ResponseModel <AuthTokenResponseModel> > GetTokenResponseAsync(LoginModelApi loginApiModel) { var accountApiModel = await accountService.GetByEmailAsync(loginApiModel.Email); var respModel = new ResponseModel <AuthTokenResponseModel>(); if (accountApiModel == null || !await accountService.VerifyUserAsync(loginApiModel)) { respModel.AddError(new Error($"Email or password is incorrect...")); return(respModel); } var claims = GenerateClaims(accountApiModel); var jwt = new JwtSecurityToken( issuer: this.authJWToptions.Value.Issuer, audience: this.authJWToptions.Value.Audience, notBefore: DateTime.UtcNow, claims: claims.Claims, expires: DateTime.UtcNow.Add(TimeSpan.FromDays(this.authJWToptions.Value.Lifetime)), signingCredentials: new SigningCredentials(this.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256)); var tokenRespModel = new AuthTokenResponseModel() { Token = new JwtSecurityTokenHandler().WriteToken(jwt), UserId = Convert.ToInt32(claims.Name) }; respModel.Item = tokenRespModel; return(respModel); }
public async Task <ResponseModel <ICollection <AccountModelApi <int> > > > GetAllAsync() { var allAccs = await this._redisCachingService.GetItemAsync <ICollection <AccountModelBussines <int> > >( RedisCachingKeysUtil.GET_ALL_ACCOUNTS_KEY ); if (allAccs == null) { allAccs = await this._accountRepository.GetAllAsync(); await this._redisCachingService.PutItemAsync <ICollection <AccountModelBussines <int> > >( RedisCachingKeysUtil.GET_ALL_ACCOUNTS_KEY, allAccs, new DistributedCacheEntryOptions() { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(3) } ); } ResponseModel <ICollection <AccountModelApi <int> > > resp = new ResponseModel <ICollection <AccountModelApi <int> > >( AutoMapperConfig.Mapper.Map <ICollection <AccountModelApi <int> > >(allAccs) ); if (allAccs == null) { resp.AddError(new Error($"Db error.")); } return(resp); }
public async Task <ResponseModel <List <ImportFile> > > SearchTemplates(List <string> headerNames) { var retResp = new ResponseModel <List <ImportFile> >(); try { var resp = await httpClient.PostAsJsonAsync("api/Templates/Search", headerNames); if (resp.IsSuccessStatusCode) { return(await resp.Content.ReadFromJsonAsync <ResponseModel <List <ImportFile> > >()); } retResp.AddError("The request was not successful."); } catch (Exception) { retResp.AddError("There was an error that occured while trying to save ."); } return(retResp); }
private ResponseModel SetOfError(IdentityResult res) { var response = new ResponseModel(); foreach (IdentityError err in res.Errors) { response.AddError(err.Code, err.Description); } return(response); }
public async Task <ActionResult> GetUserByID(string id) { var user = await _userManager.FindByIdAsync(id); if (user != null) { return(Ok(user)); } var response = new ResponseModel(); response.AddError(ErrorConstant.NoContentCode, ErrorConstant.NoContentMess); return(Ok(response)); }
public async Task <ResponseModel <LoginModel> > SendConfirmationRegisterMail(string email, string uri) { var user = await _accountRepository.GetByEmail(email); var loginModel = new LoginModel(email); var response = new ResponseModel <LoginModel>(loginModel); if (user != null) { return(await SendEmailConfirmationAsync(user, uri)); } response.AddError(AppErrors.PasswordOrUserIncorrect); return(response); }
public async Task <ResponseModel <LoginModel> > ForgotUsername(string email) { var user = await _accountRepository.GetByEmail(email); var responseModel = new ResponseModel <LoginModel>(user != null); if (!responseModel.Success) { responseModel.AddError(AppErrors.PasswordOrUserIncorrect); return(responseModel); } await _emailClientSender.SendForgotUser(user.Email, new SendForgotUserModel(user.UserName)); return(responseModel); }
public ResponseModel <UserModelApi> SignUp(UserModelApi model) { var response = new ResponseModel <UserModelApi>(); var res = _service.Create(model); if (res != null) { response.Item = res; } else { response.AddError("User wtih this e-mail and login already exists"); } return(response); }
public ResponseModel <UserModelApi> SignIn(UserModelApi model) { var response = new ResponseModel <UserModelApi>(); var res = _service.VerifyUser(model.Email, model.Password); if (res != null) { response.Item = res; FormsAuthentication.SetAuthCookie(model.Email, true); } else { response.AddError("User wtih this e-mail and login abscent"); } return(response); }
public async Task <ResponseModel <SharedFolderModelApi <int> > > ShareFolder(SharedFolderModelApi <int> sharingModel) { var acc = await this._accountRepository.GetByEmailAsync(sharingModel.AccountEmail); var resp = new ResponseModel <SharedFolderModelApi <int> >(); if (acc == null) { resp.AddError(new Error($"This user not exists")); return(resp); } await this._redisCachingService.RemoveItemAsync(RedisCachingKeysUtil.GET_SHARED_FOLDERS_BY_USER_ID + acc.Id); var folder = await this._storedFolderRepository.GetByIdAsync(sharingModel.StoredFolderId); await NotifyAboutSharing(folder.Title, acc.Id); resp.Item = AutoMapperConfig.Mapper.Map <SharedFolderModelApi <int> >(await CreateSharing(sharingModel, acc)); return(resp); }
public async Task <ResponseModel <LoginModel> > SendEmailConfirmationAsync(ApplicationUser user, string uri) { var responseModel = new ResponseModel <LoginModel>(new LoginModel(user.Email)); if (await _accountRepository.IsEmailConfirmedAsync(user)) { responseModel.AddError(AppErrors.EmailIsConfirmed); return(responseModel); } var tokenConfirmation = await _accountRepository.GenerateEmailConfirmationTokenAsync(user); var api = "/ConfirmationRegisterMail"; var webAppUrl = "https://cienciaargentina.com"; var url = $"{webAppUrl}{api}/ConfirmationRegisterMail?email={user.Email}&token={tokenConfirmation}"; url = url.Replace("+", "%2B"); var sendConfirmationModel = new SendConfirmationAccountModel(user.UserName, "", url); await _emailClientSender.SendConfirmationAccountEmail(user.Email, sendConfirmationModel); responseModel.Success = true; return(responseModel); }
public async Task <ResponseModel <AccountModelApi <int> > > RegisterUserAsync(AccountModelApi <int> model) { var registeredUser = await this._accountRepository.CreateAsync( AutoMapperConfig.Mapper.Map <AccountModelBussines <int> >(model) ); ResponseModel <AccountModelApi <int> > resp = new ResponseModel <AccountModelApi <int> >( AutoMapperConfig.Mapper.Map <AccountModelApi <int> >(registeredUser) ); if (registeredUser == null) { resp.AddError(new Error($"User with {model.Email} alredy exists.")); return(resp); } await this._redisCachingService.RemoveItemAsync(RedisCachingKeysUtil.GET_ACCOUNT_BY_EMAIL_KEY); await this._accountSubscriptionService.SubscribeUserByIdDefaultAsync(registeredUser.Id); //ToDo : make crypto return(resp); }
public async Task <ResponseModel <LoginModel> > Add(ApplicationUser user, string password, string uri) { var result = await _accountRepository.Add(user, password); var loginModel = new LoginModel(user.Email); var response = new ResponseModel <LoginModel>(loginModel, result.Succeeded); if (!result.Succeeded) { foreach (var error in result.Errors) { response.AddError(new ErrorResponseModel(error.Code, error.Description)); } return(response); } var token = BuildToken(user.UserName, user.Email); response.Data.AddToken(token); await SendEmailConfirmationAsync(user, uri); return(response); }