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));
}
