public Task <TUser> FindByIdAsync(long userId) { //if (long.IsNullOrEmpty(userId)) //{ // throw new ArgumentException("Null or empty argument: userId"); //} TUser result = IdentityUserRepository.GetByUserID(userId) as TUser; if (result != null) { return(Task.FromResult <TUser>(result)); } return(Task.FromResult <TUser>(null)); }
public Task <TUser> FindByNameAsync(string userName) { if (string.IsNullOrEmpty(userName)) { throw new ArgumentException("Null or empty argument: userName"); } TUser result = IdentityUserRepository.GetByUserName(userName) as TUser; // Should I throw if > 1 user? if (result != null) { return(Task.FromResult <TUser>(result)); } return(Task.FromResult <TUser>(null)); }
public Task CreateAsync(TUser user) { if (user == null) { throw new ArgumentNullException("user"); } TUser result = IdentityUserRepository.Add(user) as TUser; if (result != null) { return(Task.FromResult <TUser>(result)); } return(Task.FromResult <TUser>(null)); //return Task.FromResult<object>(null); }
private static void Init() { var builder = new ContainerBuilder(); var keyRing = new IdentityDataProtectorKeyRing(); var protector = new CustomPersonalDataProtector(keyRing); var userRepository = new IdentityUserRepository(null); var protectedUserRepository = new IdentityProtectedUserRepository(userRepository, protector); builder.RegisterInstance(protectedUserRepository).As <IIdentityUserRepository <ApplicationUser> >(); _container = builder.Build(); FluentMapper.Initialize(config => { config.AddMap(new ApplicationUserMap()); config.AddMap(new UserRoleMap()); config.AddMap(new UserClaimMap()); }); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { var allowedOrigin = context.OwinContext.Get <string>("ou:clientAllowedOrigin"); if (allowedOrigin == null) { allowedOrigin = "*"; } //context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); using (IdentityUserRepository _identityUserRepository = new IdentityUserRepository()) { IdentityUser user = await _identityUserRepository.FindUser(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName)); identity.AddClaim(new Claim(ClaimTypes.Role, "user")); identity.AddClaim(new Claim("sub", context.UserName)); var props = new AuthenticationProperties(new Dictionary <string, string> { { "ou:client_id", (context.ClientId == null) ? string.Empty : context.ClientId }, { "userName", context.UserName } }); var ticket = new AuthenticationTicket(identity, props); context.Validated(ticket); }
public UnitOfWork(ApplicationDbContext db) { _db = db; Banner = new BannerRepository(_db); Menu = new MenuRepository(_db); Article = new ArticleRepository(_db); Category = new CategoryRepository(_db); Service = new ServiceRepository(_db); ServiceDetail = new ServiceDetailRepository(_db); Columnist = new ColumnistRepository(_db); RolePermission = new RolePermissionRepository(_db); Permissions = new PermissionRepository(_db); IdentityUser = new IdentityUserRepository(_db); IdentityRole = new IdentityRoleRepository(_db); IdentityUserRole = new IdentityUserRoleRepository(_db); District = new DistrictRepository(_db); Location = new LocationRepository(_db); Parcel = new ParcelRepository(_db); Province = new ProvinceRepository(_db); Status = new StatusRepository(_db); }
public static void Init(TestContext context) { var builder = new ContainerBuilder(); var configBuilder = new ConfigurationBuilder().AddJsonFile($"settings.json", optional: false); var configurationRoot = configBuilder.Build(); //circular dependency var userRepository = new IdentityUserRepository(configurationRoot); var roleRepository = new IdentityRoleRepository(configurationRoot); builder.RegisterInstance(userRepository).As <IIdentityUserRepository <ApplicationUser> >(); builder.RegisterInstance(roleRepository).As <IIdentityRoleRepository <IdentityRole> >(); _container = builder.Build(); FluentMapper.Initialize(config => { config.AddMap(new ApplicationUserMap()); config.AddMap(new UserRoleMap()); config.AddMap(new UserClaimMap()); }); }
// private DbContextOptions<RalDbContext> _options; public RalUnitOfWork(RalDbContext dbContext) { _dbContext = dbContext; BusinessPartners = new BusinessPartnerRepository(dbContext); Company = new CompanyRepository(dbContext); Employees = new EmployeesRepository(dbContext); Quotations = new DocumentRepository <QuotationEntity, QuotationHeaderEntity>(dbContext); Orders = new DocumentRepository <OrderEntity, OrderHeaderEntity>(dbContext); DeliveryNotes = new DocumentRepository <DeliveryNoteEntity, DeliveryNoteHeaderEntity>(dbContext); Invoices = new DocumentRepository <InvoiceEntity, InvoiceHeaderEntity>(dbContext); CreditNotes = new DocumentRepository <CreditNoteEntity, CreditNoteHeaderEntity>(dbContext); DownPaymentRequests = new DocumentRepository <DownPaymentRequest, DownPaymentRequestHeader>(dbContext); Salesmen = new SalesmanRepository(dbContext); ProductGroups = new ProductGroupRepository(dbContext); Products = new ProductRepository(dbContext); RefreshTokens = new AuthenticationRepository(dbContext); IdentityUsers = new IdentityUserRepository(dbContext); UserLocations = new UserLocationRepository(dbContext); LeadUsersData = new LeadUserDataRepository(dbContext); EmployeeTimeClocks = new EmployeeTimeClockRepository(dbContext); Activities = new ActivityRepository(dbContext); Attachments = new AttachmentRepository(dbContext); }
public async Task <AppUserDto> GetAsync(Guid userId) { var userE = await IdentityUserRepository.GetAsync(userId); return(ObjectMapper.Map <Volo.Abp.Identity.IdentityUser, AppUserDto>(userE)); }
public virtual async Task UpdateUserAsync(IdentityUser user, string providerName) { await IdentityOptions.SetAsync(); var externalUser = await GetUserInfoAsync(user); NormalizeExternalLoginUserInfo(externalUser, user.UserName); if (!externalUser.Name.IsNullOrWhiteSpace()) { user.Name = externalUser.Name; } if (!externalUser.Surname.IsNullOrWhiteSpace()) { user.Surname = externalUser.Surname; } if (user.PhoneNumber != externalUser.PhoneNumber) { if (!externalUser.PhoneNumber.IsNullOrWhiteSpace()) { await UserManager.SetPhoneNumberAsync(user, externalUser.PhoneNumber); user.SetPhoneNumberConfirmed(externalUser.PhoneNumberConfirmed == true); } } else { if (!user.PhoneNumber.IsNullOrWhiteSpace() && user.PhoneNumberConfirmed == false && externalUser.PhoneNumberConfirmed == true) { user.SetPhoneNumberConfirmed(true); } } if (!string.Equals(user.Email, externalUser.Email, StringComparison.OrdinalIgnoreCase)) { (await UserManager.SetEmailAsync(user, externalUser.Email)).CheckErrors(); user.SetEmailConfirmed(externalUser.EmailConfirmed ?? false); } if (externalUser.TwoFactorEnabled != null) { (await UserManager.SetTwoFactorEnabledAsync(user, externalUser.TwoFactorEnabled.Value)).CheckErrors(); } await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.Logins); var userLogin = user.Logins.FirstOrDefault(l => l.LoginProvider == providerName); if (userLogin != null) { if (userLogin.ProviderKey != externalUser.ProviderKey) { (await UserManager.RemoveLoginAsync(user, providerName, userLogin.ProviderKey)).CheckErrors(); (await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors(); } } else { (await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors(); } user.IsExternal = true; (await UserManager.UpdateAsync(user)).CheckErrors(); }
public Task <bool> HasPasswordAsync(TUser user) { var hasPassword = !string.IsNullOrEmpty(IdentityUserRepository.GetPasswordHash(user.Id)); return(Task.FromResult <bool>(Boolean.Parse(hasPassword.ToString()))); }
public Task <string> GetPasswordHashAsync(TUser user) { string passwordHash = IdentityUserRepository.GetPasswordHash(user.Id); return(Task.FromResult <string>(passwordHash)); }
public async Task <AppUserDto> GetByUsername(string username) { var userE = await IdentityUserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName(username)); return(ObjectMapper.Map <Volo.Abp.Identity.IdentityUser, AppUserDto>(userE)); }
public AccountController() { _identityUserRepository = new IdentityUserRepository(); }
public async Task <bool> IsUsernameAvailable(string username) { return((await IdentityUserRepository.FindByNormalizedUserNameAsync(LookupNormalizer.NormalizeName(username))) == null); }
public virtual async Task RemoveFromOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou) { await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, CancellationTokenProvider.Token); user.RemoveOrganizationUnit(ou.Id); }
public virtual async Task RemoveFromOrganizationUnitAsync(Guid userId, Guid ouId) { var user = await IdentityUserRepository.GetAsync(userId, cancellationToken : CancellationToken); user.RemoveOrganizationUnit(ouId); }
public virtual async Task <bool> IsInOrganizationUnitAsync(IdentityUser user, OrganizationUnit ou) { await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, CancellationTokenProvider.Token); return(user.IsInOrganizationUnit(ou.Id)); }
public virtual async Task <bool> IsInOrganizationUnitAsync(Guid userId, Guid ouId) { var user = await IdentityUserRepository.GetAsync(userId, cancellationToken : CancellationToken); return(user.IsInOrganizationUnit(ouId)); }