public async Task <List <User> > GetAllAsync() { return(await _userRepository .AsReadOnly() .Include(_ => _.Countries) .ProjectTo <User>() .ToListAsync()); }
public async virtual Task <List <TModel> > GetAllAsync() { var list = new List <TModel>(); //ProjectTo would also load all child objects await GetAllEntities(_entityRepository.AsReadOnly()) .ForEachAsync(e => list.Add(Mapper.Map <TModel>(e))); return(list); }
public async Task <bool> ValidateCredentials(string username, string password) { var user = await _entityRepository .AsReadOnly() .SingleOrDefaultAsync(s => s.UserName == username); if (user != null) { return((String.IsNullOrEmpty(user.PasswordSalt) || String.IsNullOrEmpty(user.PasswordHash)) ? false : CryptographyService.PasswordValidation(user.PasswordHash, user.PasswordSalt, password)); } else { return(false); } }
public async Task <List <Role> > GetAllAsync() { return(await _roleRepository .AsReadOnly() .ProjectTo <Role>() .ToListAsync()); }
private async Task AdditionalValidationAsync(UserBase model) { var role = await _roleRepository .AsReadOnly() .SingleOrDefaultAsync(_ => _.Id == model.RoleId.Value); //if (role == null || role.ParentRoleId.HasValue != model.ParentUserId.HasValue) //{ // throw new InvalidModelException(); // TODO: Add error //} }
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(string subjectId) { return(await GetAllEntities(_entityRepository.AsReadOnly()) .Where(s => s.SubjectId == subjectId) .ProjectTo <PersistedGrant>() .ToListAsync()); }
public async Task <bool> SendEmailAsync(string emailAddress, EmailTemplateType templateType, IDictionary <string, string> placeholders = null, IList <string> ccEmails = null, IList <EmailAttachment> attachments = null) { var template = await _emailTemplateRepository.AsReadOnly().FirstOrDefaultAsync(_ => _.Type == templateType); if (template == null) { return(false); } var subject = template.Subject; var body = template.Body; if (placeholders != null) { subject = ""; // template.Subject.ReplacePlaceholders(placeholders); body = ""; // template.Body.ReplacePlaceholders(placeholders); } var sent = await _emailSender.SendEmailAsync(emailAddress, subject, body, ccEmails, attachments); return(sent); }
public async Task <AuthenticationInfo> AuthenticateAsync(AuthenticationModel model) { model.RejectInvalid(); var user = await _userRepository.AsReadOnly().Include(_ => _.Role).SingleOrDefaultAsync(_ => _.UserName == model.UserName); user.RejectNotFound(); var passwordHash = _cryptographyService.CreateHash(model.Password, user.PasswordSalt); if (passwordHash != user.PasswordHash) { throw new InvalidModelException(); } TokenData tokenData = null; try { tokenData = Mapper.Map <Entities.User, TokenData>(user); } catch (Exception ex) { user.RejectInvalid(); } var tokenTask = _tokenProvider.CreateTokenAsync(tokenData); var refreshTokenTask = _tokenProvider.CreateRefreshTokenAsync(tokenData); return(new AuthenticationInfo() { UserName = user.UserName, DisplayName = user.DisplayName, Token = await tokenTask, RefreshToken = await refreshTokenTask }); }
public async Task <IEnumerable <Country> > GetAllActiveAsync() { var countryIds = await _userCountryRepository.AsReadOnly().Where(_ => _.UserId == _currentUser.Id).Select(_ => _.CountryId).ToListAsync(); var query = _countriesRepository.AsReadOnly() .Where(_ => _.IsActive == true); //if (!_currentUser.IsInAnyRole(new string[] { Entities.Role.DivisionalFD_NAME, Entities.Role.Administrator_NAME })) //{ // query = query.Where(_ => countryIds.Contains(_.Id)); //} var result = await query .ProjectTo <Country>() .ToListAsync(); return(result); }
public async virtual Task <List <TModel> > GetAllAsync() { return(await GetAllEntities(_entityRepository.AsReadOnly()) .ProjectTo <TModel>() .ToListAsync()); }