public async Task FirstDBInitializationAsync()
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
await worker.FirstDBInitializationAsync();
}
}
public UserInfo Get(Guid userId)
{
UserInfo result = null;
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
var user = worker.UserManager.Users.Where(u => u.Id == userId).First();
List <Guid> roles = new List <Guid>();
foreach (var item in user.Roles)
{
roles.Add(item.RoleId);
}
result = new UserInfo
{
Id = user.Id,
Name = user.UserName,
PhoneNumber = user.PhoneNumber,
ProfileId = user.UserProfileId,
Roles = roles
};
}
}
catch (InvalidOperationException ioex)
{
}
catch (Exception ex)
{
}
return(result);
}
public IEnumerable <UserInfo> GetAll()
{
IEnumerable <UserInfo> result = null;
List <UserMapper> userMapper;
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
userMapper =
(from u in worker.UserManager.Users.Include(u => u.Roles)
from r in u.Roles
select new UserMapper
{
Id = u.Id,
Name = u.UserName,
PhoneNumber = u.PhoneNumber,
ProfileId = u.UserProfileId,
RoleId = r.RoleId
})
.AsNoTracking()
.ToList();
}
result = Mapping(userMapper);
}
catch (Exception ex)
{
}
return(result);
}
public async Task <IEnumerable <string> > AuthorizationAsync(string userName)
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
ApplicationUser user = await worker.UserManager.FindByNameAsync(userName);
return(await worker.UserManager.GetRolesAsync(user.Id));
}
}
private async Task <Guid> UpdateProfileAsync(IDBWorker worker, UserProfileIn profile)
{
UserProfile entity = null;
entity = worker.UserProfileRepository.GetById(profile.Id);
entity.Surname = profile.Surname;
entity.FirstName = profile.FirstName;
entity.Patronymic = profile.Patronymic;
worker.UserProfileRepository.Update(entity);
await worker.SaveAsync();
return(entity.Id);
}
public async Task <ResultRequest> RemoveAsync(Guid userId)
{
ResultRequest resultRequest = new ResultRequest {
Type = ResultRequestType.Success, Message = ""
};
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
var user = await worker.UserManager.FindByIdAsync(userId);
var profile = worker.UserProfileRepository.Remove(user.UserProfile);
var result = await worker.UserManager.DeleteAsync(user);
await worker.SaveAsync();
if (!result.Succeeded)
{
resultRequest = new ResultRequest {
Type = ResultRequestType.Error, Message = string.Join(",", result.Errors)
};
}
}
}
catch (InvalidOperationException ioex)
{
resultRequest = new ResultRequest {
Type = ResultRequestType.Error, Message = ioex.Message
};
}
catch (Exception ex)
{
resultRequest = new ResultRequest {
Type = ResultRequestType.Error, Message = ex.Message
};
}
return(resultRequest);
}
public async Task <UserProfileOut> GetAsync(Guid userProfileId)
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
UserProfileOut result = new UserProfileOut();
if (!userProfileId.Equals(Guid.Empty))
{
UserProfileMapper profile = await worker.UserProfileRepository.FindByIdAsync(userProfileId);
result = new UserProfileOut
{
Id = profile.Id,
FirstName = profile.FirstName,
Patronymic = profile.Patronymic,
Surname = profile.Surname
};
}
return(result);
}
}
public async Task <AuthenticationOut> AuthenticationAsync(AuthenticationInfo info)
{
AuthenticationOut result = new AuthenticationOut();
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
ApplicationUser user = await worker.UserManager.FindByNameAsync(info.UserName);
if (user != null)
{
bool isCheckSuccess = await worker.UserManager.CheckPasswordAsync(user, info.Password);
if (isCheckSuccess)
{
result.UserId = user.Id;
result.Result.Type = ResultRequestType.Success;
}
else
{
result.Result.Type = ResultRequestType.Error;
result.Result.Message = "Не верный логин или пароль";
}
}
else
{
result.Result.Type = ResultRequestType.Error;
result.Result.Message = "Выберите, пожалуйста, пользователя.";
}
}
}
catch (Exception ex)
{
}
return(result);
}
public async Task SaveAsync(UserProfileIn model)
{
UserProfile entity;
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
if (worker.UserProfileRepository.IsExist(model.Id))
{
entity = worker.UserProfileRepository.GetById(model.Id);
entity.FirstName = model.FirstName;
entity.Patronymic = model.Patronymic;
entity.Surname = model.Surname;
worker.UserProfileRepository.Update(entity);
await worker.SaveAsync();
}
}
}
catch (Exception ex)
{
}
}
public async Task <UserManagerOut> SaveAsync(UserManagerIn model)
{
//UserManagerOut result = new UserManagerOut { Result = new ResultRequest { Type = ResultRequestType.Error } };
ApplicationUser userEntity = null;
UserManagerOut result = new UserManagerOut();
try
{
using (IDBWorker worker = kernel.Get <IDBWorker>())
{
if (model.Id.Equals(Guid.Empty))
{
UserProfile profileEntity = worker.UserProfileRepository.Add(new UserProfile
{
Surname = model.Profile.Surname,
FirstName = model.Profile.FirstName,
Patronymic = model.Profile.Patronymic,
IsRemove = false,
IsNecessaryChangePassword = false
});
userEntity = new ApplicationUser
{
Id = Guid.NewGuid(),
UserName = Person.FIO(profileEntity.Surname, profileEntity.FirstName, profileEntity.Patronymic),
UserProfile = profileEntity
};
await worker.UserManager.CreateAsync(userEntity, model.Password);
result.UserId = userEntity.Id;
result.ProfileId = profileEntity.Id;
}
else
{
userEntity = await worker.UserManager.FindByIdAsync(model.Id);
userEntity.UserName = Person.FIO(model.Profile.Surname, model.Profile.FirstName, model.Profile.Patronymic);
result.UserId = userEntity.Id;
result.ProfileId = await UpdateProfileAsync(worker, model.Profile);
if (!string.IsNullOrWhiteSpace(model.Password))
{
await worker.UserManager.RemovePasswordAsync(userEntity.Id);
await worker.UserManager.AddPasswordAsync(userEntity.Id, model.Password);
}
await worker.SaveAsync();
}
var oldRoles = await worker.UserManager.GetRolesAsync(userEntity.Id);
await worker.UserManager.RemoveFromRolesAsync(userEntity.Id, oldRoles.ToArray());
var newRoles = model.Roles.Select(r => r.Name).ToArray();
await worker.UserManager.AddToRolesAsync(userEntity.Id, newRoles);
}
}
catch (InvalidOperationException ioex)
{
}
catch (Exception ex)
{
}
return(result);
}
