public static ApplicationUserExtended ToCoreModel(this ApplicationUser applicationUser, AccountEntity dbEntity, IPermissionScopeService scopeService)
{
var retVal = new ApplicationUserExtended();
retVal = new ApplicationUserExtended();
retVal.InjectFrom(applicationUser);
retVal.InjectFrom(dbEntity);
retVal.UserState = EnumUtility.SafeParse<Core.Security.AccountState>( dbEntity.AccountState, Core.Security.AccountState.Approved);
retVal.Roles = dbEntity.RoleAssignments.Select(x => x.Role.ToCoreModel(scopeService)).ToArray();
retVal.Permissions = retVal.Roles.SelectMany(x => x.Permissions).SelectMany(x=> x.GetPermissionWithScopeCombinationNames()).Distinct().ToArray();
retVal.ApiAccounts = dbEntity.ApiAccounts.Select(x => x.ToCoreModel()).ToArray();
return retVal;
}
public static void Patch(this AccountEntity source, AccountEntity target)
{
var patchInjection = new PatchInjection<AccountEntity>(x => x.UserType, x => x.AccountState, x => x.MemberId,
x => x.StoreId, x => x.IsAdministrator);
target.InjectFrom(patchInjection, source);
if (!source.ApiAccounts.IsNullCollection())
{
source.ApiAccounts.Patch(target.ApiAccounts, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
}
if (!source.RoleAssignments.IsNullCollection())
{
source.RoleAssignments.Patch(target.RoleAssignments, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
}
}
public async Task<SecurityResult> CreateAsync(ApplicationUserExtended user)
{
IdentityResult result = null;
if (user != null)
{
var dbUser = user.ToDataModel();
if (string.IsNullOrEmpty(user.Password))
{
result = await _userManager.CreateAsync(dbUser);
}
else
{
result = await _userManager.CreateAsync(dbUser, user.Password);
}
if (result.Succeeded)
{
using (var repository = _platformRepository())
{
var account = new AccountEntity
{
Id = dbUser.Id,
UserName = user.UserName,
MemberId = user.MemberId,
AccountState = AccountState.Approved,
RegisterType = (RegisterType)user.UserType,
StoreId = user.StoreId
};
if (user.Roles != null)
{
foreach (var role in user.Roles)
{
account.RoleAssignments.Add(new RoleAssignmentEntity { RoleId = role.Id, AccountId = account.Id });
}
}
repository.Add(account);
repository.UnitOfWork.Commit();
}
}
}
return result == null ? null : result.ToCoreModel();
}
public static AccountEntity ToDataModel(this ApplicationUserExtended user)
{
var retVal = new AccountEntity();
retVal.InjectFrom(user);
retVal.AccountState = user.UserState.ToString();
if(user.Roles != null)
{
retVal.RoleAssignments = new ObservableCollection<RoleAssignmentEntity>(user.Roles.Select(x => x.ToAssignmentDataModel()));
}
if(user.ApiAccounts != null)
{
retVal.ApiAccounts = new ObservableCollection<ApiAccountEntity>(user.ApiAccounts.Select(x => x.ToDataModel()));
}
return retVal;
}
public async Task<IHttpActionResult> CreateAsync(ApplicationUserExtended user)
{
var dbUser = new ApplicationUser();
dbUser.InjectFrom(user);
IdentityResult result;
if (!string.IsNullOrEmpty(user.Password))
{
result = await UserManager.CreateAsync(dbUser, user.Password);
}
else
{
result = await UserManager.CreateAsync(dbUser);
}
if (result.Succeeded)
{
using (var repository = _platformRepository())
{
var account = new AccountEntity()
{
Id = user.Id,
UserName = user.UserName,
MemberId = user.MemberId,
AccountState = AccountState.Approved,
RegisterType = (RegisterType)user.UserType,
StoreId = user.StoreId
};
if (user.Roles != null)
{
foreach (var role in user.Roles)
{
account.RoleAssignments.Add(new RoleAssignmentEntity { RoleId = role.Id, AccountId = account.Id });
}
}
repository.Add(account);
repository.UnitOfWork.Commit();
}
return Ok();
}
else
{
return BadRequest(String.Join(" ", result.Errors));
}
}
public async Task<IHttpActionResult> Register(ApplicationUserExtended user)
{
if (user == null)
{
return BadRequest();
}
var dbUser = new ApplicationUser();
dbUser.InjectFrom(user);
foreach (var login in user.Logins)
{
var userLogin = dbUser.Logins.FirstOrDefault(l => l.LoginProvider == login.LoginProvider);
if (userLogin != null)
{
userLogin.ProviderKey = login.ProviderKey;
}
else
{
dbUser.Logins.Add(new Microsoft.AspNet.Identity.EntityFramework.IdentityUserLogin
{
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
UserId = dbUser.Id
});
}
}
IdentityResult result = null;
if (string.IsNullOrEmpty(user.Password))
{
result = await UserManager.CreateAsync(dbUser);
}
else
{
result = await UserManager.CreateAsync(dbUser, user.Password);
}
if (result.Succeeded)
{
using (var repository = _platformRepository())
{
var account = new AccountEntity
{
Id = user.Id,
UserName = user.UserName,
MemberId = user.MemberId,
AccountState = AccountState.Approved,
RegisterType = (RegisterType)user.UserType,
StoreId = user.StoreId,
};
repository.Add(account);
repository.UnitOfWork.Commit();
}
}
return Ok(result);
}
