public async Task UpdateAsync(AppUserViewModel userVm)
{
var user = await _userManager.FindByIdAsync(userVm.Id.ToString());
//Add new roles
var currentRoles = await _userManager.GetRolesAsync(user);
var result = await _userManager.AddToRolesAsync(user, userVm.Roles.Except(currentRoles).ToArray());
if (result.Succeeded)
{
//Remove current roles in db
string[] needRemoveRoles = currentRoles.Except(userVm.Roles).ToArray();
await RemoveRolesFromUser(user.Id.ToString(), needRemoveRoles);
//Update user detail
user.FullName = userVm.FullName;
user.Active = userVm.Active;
user.Email = userVm.Email;
user.PhoneNumber = userVm.PhoneNumber;
user.Avatar = userVm.Avatar;
user.Gender = userVm.Gender;
if (!string.IsNullOrEmpty(userVm.Birthday))
{
user.Birthday = DateTime.ParseExact(userVm.Birthday, "dd/MM/yyyy", CultureInfo.InvariantCulture);
}
else
{
user.Birthday = null;
}
await _userManager.UpdateAsync(user);
}
}
public ActionResult UserProfile()
{
var user = User.Identity.GetUserId();
AppUserViewModel appUserView = new AppUserViewModel()
{
Courses = mydatabase.CoursesUserManager.GetAllBind().Where(i => i.LinkedInUserId == user).ToList(),
EducationList = mydatabase.UserEducationManager.GetAllBind().Where(i => i.LinkedInUserId == user).ToList(),
Languages = mydatabase.LanguageUserManager.GetAllBind().Where(i => i.LinkedInUserId == user).ToList(),
Posts = mydatabase.PostsUserManager.GetAllBind().Where(i => i.OwnerId == user).ToList(),
Skills = mydatabase.SkillsUserManager.GetAllBind().Where(i => i.LinkedInUserId == user).ToList(),
User = UserManager.FindById(user),
Companies = mydatabase.CompanyUserManager.GetAllBind().Where(i => i.LinkedInUserId == user).ToList()
};
if (Request.IsAjaxRequest())
//بزار التعديل
{
//بزار التعديل
//return PartialView("_PartialProfilePagewithEdit", appUserView);
return(View("ProfilePageEdit", appUserView));
}
else
{
return(View("ProfilePageEdit", appUserView));
//return View(appUserView);
}
}
public ActionResult Create(AppUserViewModel model)
{
List <string> errors = new List <string>();
try
{
if (ModelState.IsValid)
{
if (model.Id == 0)
{
var dbModel = AutomapperConfig.Mapper.Map <AppUser>(model);
EncryptionService encsvc = new EncryptionService();
dbModel.Salt = encsvc.CreateSaltKey(10);
dbModel.Password = encsvc.CreatePasswordHash(model.Password, dbModel.Salt);
dbModel.IsActive = true;
dbModel.UserRoles.Add(new UserRole {
RoleId = model.RoleId
});
model.Id = db.AppUserRepo.Create(dbModel);
}
else
{
var oldmodel = db.AppUserRepo.GetById(model.Id);
if (oldmodel == null)
{
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(new { redirecturl = "/error/badrequest" }));
}
var role = db.UserRoleRepo.Table().Where(x => x.UserId == model.Id);
db.UserRoleRepo.DeleteRange(role);
var dbModel = AutomapperConfig.Mapper.Map <AppUser>(model);
EncryptionService encsvc = new EncryptionService();
oldmodel.UserName = model.UserName;
oldmodel.Password = encsvc.CreatePasswordHash(model.Password, dbModel.Salt);
oldmodel.EmployeeId = model.EmployeeId;
oldmodel.Photo = model.Photo;
oldmodel.UserRoles.Add(new UserRole {
RoleId = model.RoleId
});
oldmodel.IsActive = model.IsActive;
}
db.SaveChanges();
Response.StatusCode = (int)HttpStatusCode.OK;
TempData["Success"] = "User Successfully Saved";
return(RedirectToAction("Index"));
}
foreach (var item in ModelState.Where(x => x.Value.Errors.Any()))
{
errors.Add(item.Value.Errors.FirstOrDefault().ErrorMessage);
}
}
catch (Exception ex)
{
errors.Add(ex.GetExceptionMessages());
}
Response.StatusCode = (int)HttpStatusCode.SeeOther;
return(View(model));
}
public IActionResult Index(AppUserViewModel vm, string buttonValue)
{
bool retainEdit = false;
switch (buttonValue)
{
case "Save":
if (ModelState.IsValid)
{
int userId = _AppUserRepo.SaveAppUser(vm.EditAppUser);
_AppUserRepo.DeleteUserRoles(userId);
foreach (var role in vm.EditAppUser.Roles.Where(x => x.Active))
{
_AppUserRepo.SaveUserRole(userId, role.Id);
}
}
else
{
retainEdit = true;
}
break;
case "Delete":
_AppUserRepo.DeleteAppUser(vm.EditAppUser.UserId);
break;
}
PrepAppUser(vm, retainEdit);
return(View(vm));
}
public async Task <ActionResult> Create(AppUserViewModel model)
{
var userPath = string.Format("{0}/{1}", User_ByUserIdUri, GuidEncoder.Decode(model.UriKey));
var user = _mapper.Map <UserViewModel>(await _apiClient.GetAsync <UserDto>(userPath));
var path = string.Format("{0}{1}", HttpClientProvider.HttpClient.BaseAddress, BaseUri);
//model.SubjectId = GuidEncoder.Decode(model.UriKey).ToString();
model.CreatedDate = DateTime.UtcNow;
model.ModifiedDate = DateTime.UtcNow;
model.GenderId = GuidEncoder.Decode(model.GenderId).ToString();
model.CountryId = GuidEncoder.Decode(model.CountryId).ToString();
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
model.User = user;
await _apiClient.PostAsync(path, _mapper.Map <AppUserDto>(model));
return(RedirectToAction(nameof(Index)));
}
return(View());
}
catch (Exception ex)
{
var msgError = ex.Message;
return(View());
}
}
public async Task <IActionResult> Add([FromBody] AppUserViewModel appUserVm)
{
if (ModelState.IsValid)
{
try
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "USER", Operations.Create);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
AppUser appUser = _mapper.Map <AppUser>(appUserVm);
var result = await _userManager.CreateAsync(appUser, appUserVm.Password);
if (result.Succeeded)
{
var role = appUserVm.Roles.ToArray();
await _userManager.AddToRolesAsync(appUser, role);
return(new OkObjectResult(appUserVm));
}
}
catch (Exception ex)
{
return(new BadRequestObjectResult(ex.Message));
}
}
return(new BadRequestObjectResult(ModelState));
}
public async Task <IActionResult> SaveUserAsync(AppUserViewModel appUserViewModel)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
if (Request.Form.Files.Count() > 0)
{
var file = Request.Form.Files[0];
var imgPathPhysical = $@"{_hostingEnvironment.WebRootPath}\admin-side\images\user\{file.FileName}";
using (var fs = System.IO.File.Create(imgPathPhysical))
{
file.CopyTo(fs);
fs.Flush();
}
}
if (appUserViewModel.Id != new Guid())
{
var result = await _userService.UpdateUserAsync(appUserViewModel);
return(new OkObjectResult(result));
}
else
{
var result = await _userService.CreateUserAsync(appUserViewModel);
return(new OkObjectResult(result));
}
}
public async Task <bool> AddAsync(AppUserViewModel userViewModel)
{
//var user = new AppUser()
//{
// UserName = userViewModel.UserName,
// Avatar = userViewModel.Avatar,
// Email = userViewModel.Email,
// FullName = userViewModel.FullName,
// PhoneNumber = userViewModel.PhoneNumber,
// Status = userViewModel.Status
//};
// Hack: user mapper alternate contructor of AppUser
var user = Mapper.Map <AppUserViewModel, AppUser>(userViewModel);
var result = await _userManager.CreateAsync(user, userViewModel.Password);
if (result.Succeeded && userViewModel.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userViewModel.Roles);
}
}
return(true);
}
public async Task <IActionResult> RelationShip(string id, string action)
{
var user = await _userManager.GetUserAsync(User);
AppUserViewModel userVM = Mapper.Map <AppUser, AppUserViewModel>(user);
var profile = await _userService.GetById(id);
if (action == "AddFriend")
{
var query = await _relationshipService.AddFriendAsync(user.Id, id);
}
else if (action == "AcceptFriend")
{
await _relationshipService.AcceptFriendAsync(user.Id, id);
}
else if (action == "CancelRequest")
{
await _relationshipService.CancelRequestAsync(user.Id, id);
}
else if (action == "UnFriend")
{
await _relationshipService.UnFriendAsync(user.Id, id);
}
_relationshipService.Save();
var result = _relationshipService.GetByUser(userVM, id).Status;
return(new OkObjectResult(result));
//return RedirectToAction("Index", "Profile", new {/* routeValues, for example: */ email = profile.Email });
}
public async Task <IActionResult> SaveEntity(AppUserViewModel userVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
if (userVm.Id == null)
{
var isValid = await _userService.AddAsync(userVm);
if (isValid == false)
{
return(new OkObjectResult(new GenericResult(false, userVm)));
}
}
else
{
var isValid = await _userService.UpdateAsync(userVm);
if (isValid == false)
{
return(new OkObjectResult(new GenericResult(false, userVm)));
}
}
return(new OkObjectResult(new GenericResult(true, userVm)));
}
}
public frmUser(IUserService userService, IRoleService roleService)
{
_userService = userService;
_roleService = roleService;
_appUserViewModel = new AppUserViewModel();
InitializeComponent();
}
public async Task <IActionResult> Create([Bind("Email,Password,ConfirmPassword,PhoneNumber,ConfirmPhoneNumber,TwoFactorEnabled")] AppUserViewModel appUser)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = appUser.Email, Email = appUser.Email,
PhoneNumber = appUser.PhoneNumber, TwoFactorEnabled = appUser.TwoFactorEnabled
};
var result = await _userManager.CreateAsync(user, appUser.Password);
if (result.Succeeded)
{
//_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme
);
await _emailSender.SendEmailAsync(user.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
//return LocalRedirect(returnUrl);
}
//_context.Add(appUser);
//await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(appUser));
}
public async Task <IActionResult> Login([FromBody] AppUserViewModel user)
{
if (!TryValidateModel(ModelState))
{
return(BadRequest(ModelState));
}
var appUser = await _userManager.FindByEmailAsync(user.Email);
if (appUser == null)
{
return(BadRequest(ModelState));
}
var userVerified = await _userManager.CheckPasswordAsync(appUser, user.Password);
if (!userVerified)
{
return(BadRequest(ModelState));
}
var identity = new ClaimsIdentity(
new GenericIdentity(appUser.Email, "Token"),
new[] {
new Claim("id", appUser.Id),
new Claim("rol", "api_access")
});
var token = _jwtService.GenerateJwt(user.Email, identity);
return(Ok(new { token }));
}
public async Task <IActionResult> Register([FromBody] AppUserViewModel user)
{
var appUser = new AppUser()
{
Email = user.Email,
UserName = user.Email
};
var userExists = await _userManager.FindByEmailAsync(user.Email);
if (userExists != null)
{
return(BadRequest(new { error = "User Already exists" }));
}
var result = await _userManager.CreateAsync(appUser, user.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
_applicationContext.Users.Add(appUser);
await _applicationContext.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult> Edit(AppUserViewModel model)
{
model.AppUserId = GuidEncoder.Decode(model.UriKey).ToString();
model.SubjectId = GuidEncoder.Decode(model.SubjectId).ToString();
try
{
var path = string.Format("{0}", BaseUri);
// TODO: Add update logic here
if (ModelState.IsValid)
{
await _apiClient.PutAsync(path, _mapper.Map <AppUserDto>(model));
return(RedirectToAction(nameof(Index)));
}
await PopulateViewBagsAsync();
return(View());
}
catch (Exception ex)
{
var errMsg = ex.Message;
return(View());
}
}
public async Task <IActionResult> ChangePassword(AppUserViewModel userVm)
{
var newpass = userVm.Password;
var model = await _userService.ChangePassword(userVm, newpass);
return(new OkObjectResult(model));
}
public void UserDetails_ShouldReturn_ViewAndDetailInfo()
{
// Arrange
string userId = "asd1";
var userDto = new AppUserDto {
Id = userId
};
mockAdminService.Setup(u => u.GetUserById(userId)).Returns(userDto);
AdminController controller = new AdminController(new DeliveryMessage(), mockAdminService.Object,
mockInvoicesService.Object);
AppUserViewModel userViewModel = null;
try
{
// Act
result = controller.UserDetails(userId) as ViewResult;
userViewModel = (AppUserViewModel)result.Model;
}
catch (Exception ex)
{
errorMessage = ex.Message + " | " + ex.StackTrace;
}
// Assert
Assert.IsTrue(result.ViewName == "UserDetails", errorMessage);
Assert.IsNotNull(userViewModel, errorMessage);
}
public async Task <bool> AddAsync(AppUserViewModel userVM)
{
//_appDbContext.ExecuteQuery
AppUser user = new AppUser()
{
FullName = userVM.FullName,
UserName = userVM.UserName,
Email = userVM.Email,
PhoneNumber = userVM.PhoneNumber,
DateCreated = DateTime.Now,
Status = userVM.Status
};
var rs = await _userManager.CreateAsync(user, userVM.PasswordHash);
var listRoles = userVM.Roles.ToList();
if (rs.Succeeded)
{
foreach (var item in listRoles)
{
var a = await _userManager.AddToRoleAsync(user, item);
}
return(true);
}
else
{
return(false);
}
}
public async Task <bool> AddAsync(AppUserViewModel userVm)
{
var user = new AppUser()
{
UserName = userVm.UserName,
Avatar = userVm.Avatar,
Email = userVm.Email,
FullName = userVm.FullName,
BirthDay = DateTime.Parse(userVm.BirthDay),
DateCreated = DateTime.Now,
PhoneNumber = userVm.PhoneNumber
};
var result = await _userManager.CreateAsync(user, userVm.Password);
if (result.Succeeded && userVm.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userVm.Roles);
}
}
return(true);
}
public async Task <bool> AddAsync(AppUserViewModel userViewModel)
{
var user = new AppUser()
{
UserName = userViewModel.UserName,
Avatar = userViewModel.Avatar,
Email = userViewModel.Email,
FullName = userViewModel.FullName,
DateCreated = DateTime.Now,
PhoneNumber = userViewModel.PhoneNumber,
Status = userViewModel.Status,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userViewModel.Password);
if (result.Succeeded && userViewModel.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userViewModel.Roles);
}
}
return(true);
}
public IActionResult Index()
{
var vm = new AppUserViewModel();
PrepAppUser(vm, false);
return(View(vm));
}
public async Task UpdateAsync(AppUserViewModel userVm)
{
var user = await _userManager.FindByIdAsync(userVm.Id.ToString());
//Remove current roles in db
var currentRoles = await _userManager.GetRolesAsync(user);
var result = await _userManager.AddToRolesAsync(user,
userVm.Roles.Except(currentRoles).ToArray());
if (result.Succeeded)
{
string[] needRemoveRoles = currentRoles.Except(userVm.Roles).ToArray();
await _userManager.RemoveFromRolesAsync(user, needRemoveRoles);
//Update user detail
user.FullName = userVm.FullName;
user.Status = userVm.Status;
user.BirthDay = DateTime.ParseExact(userVm.BirthDay.ToString(), "dd/MM/yyyy", provider);
user.Address = userVm.Address;
user.PhoneNumber = userVm.PhoneNumber;
user.DateModified = DateTime.Now;
await _userManager.UpdateAsync(user);
}
}
public async Task UpdateAsync(AppUserViewModel userVm)
{
var user = await _userManager.FindByIdAsync(userVm.Id.ToString());
//Remove current roles in db
var currentRoles = await _userManager.GetRolesAsync(user);
var result = await _userManager.AddToRolesAsync(user,
userVm.Roles.Except(currentRoles).ToArray());
if (result.Succeeded)
{
string[] needRemoveRoles = currentRoles.Except(userVm.Roles).ToArray();
await _userManager.RemoveFromRolesAsync(user, needRemoveRoles);
//Update user detail
user.FullName = userVm.FullName;
user.Status = userVm.Status;
user.Email = userVm.Email;
user.PhoneNumber = userVm.PhoneNumber;
user.ModifiedDate = DateTime.Now;
user.DateOfBirth = user.DateOfBirth;
await _userManager.UpdateAsync(user);
}
}
public async Task <IActionResult> Login(AppUserViewModel user)
{
ViewData["Layout"] = "_UnAuthLayout";
if (ModelState.IsValid)
{
bool isValid = true;
try
{
var appUser = _accountService.Login(user.UserName, user.Password);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, appUser.UserName),
new Claim("FullName", $"{appUser.FirstName} {appUser.LastName}"),
new Claim(ClaimTypes.Role, appUser.Role.Name)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity), new AuthenticationProperties());
}
catch (ValidationException)
{
isValid = false;
ModelState.AddModelError("GlobalErrorMessage", INVALID_LOGIN);
}
if (isValid)
{
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public async Task <AppUser> PrepareAdminAppUserEntity(AppUserViewModel appUserViewModel = null, AppUser appUser = null)
{
if (appUserViewModel == null)
{
throw new ArgumentNullException(nameof(appUserViewModel));
}
if (appUser == null)
{
throw new ArgumentNullException(nameof(appUser));
}
if (appUserViewModel.ProfilePictureFile != null)
{
var pictureFileExtension = Path.GetExtension(appUserViewModel.ProfilePictureFile.FileName);
string pictureName = $"{Guid.NewGuid()}{pictureFileExtension}";
var path = Path.Combine(Directory.GetCurrentDirectory(), $"wwwroot/img/{pictureName}");
using (var stream = new FileStream(path, FileMode.Create))
await appUserViewModel.ProfilePictureFile.CopyToAsync(stream);
appUser.Picture = pictureName;
}
appUser.Name = appUserViewModel.Name;
appUser.Surname = appUserViewModel.Surname;
appUser.Email = appUserViewModel.Email;
return(appUser);
}
public RelationShipViewModel GetByUser(AppUserViewModel user_one, string user_two_id)
{
var user_two = _userManager.FindByIdAsync(user_two_id).Result;
var relationship = new Relationship()
{
User_one_id = user_one.Id,
User_two_id = user_two.Id,
Action_user_id = user_one.Id
};
var query = _relationshipRepository.FindSingle(x => x.User_one_id == relationship.User_one_id && x.User_two_id == relationship.User_two_id);
if (query != null)
{
// gui thong tin request
return(Mapper.Map <Relationship, RelationShipViewModel>(query));
}
var query2 = _relationshipRepository.FindSingle(x => x.User_one_id == relationship.User_two_id && x.User_two_id == relationship.User_one_id);
if (query2 != null)
{
// gui thong tin request
return(Mapper.Map <Relationship, RelationShipViewModel>(query2));
}
return(null);
}
public ActionResult UserProfile(string userid)
{
AppUserViewModel appUserView = new AppUserViewModel()
{
Courses = mydatabase.CoursesUserManager.GetAllBind().Where(i => i.LinkedInUserId == userid).ToList(),
EducationList = mydatabase.UserEducationManager.GetAllBind().Where(i => i.LinkedInUserId == userid).ToList(),
Languages = mydatabase.LanguageUserManager.GetAllBind().Where(i => i.LinkedInUserId == userid).ToList(),
Posts = mydatabase.PostsUserManager.GetAllBind().Where(i => i.OwnerId == userid).ToList(),
Skills = mydatabase.SkillsUserManager.GetAllBind().Where(i => i.LinkedInUserId == userid).ToList(),
User = UserManager.FindById(userid),
Companies = mydatabase.CompanyUserManager.GetAllBind().Where(i => i.LinkedInUserId == userid).ToList()
};
if (Request.IsAjaxRequest())
{
if (userid == User.Identity.GetUserId())
{
return(PartialView("_PartialProfilePagewithEdit", appUserView));
}
else
{
return(PartialView("_PartialProfilePage", appUserView));
}
//من غير زرار التعديل
}
else
{
return(View(appUserView));
}
}
public async Task <bool> AddAsync(AppUserViewModel userVm)
{
var user = new AppUser()
{
UserName = userVm.UserName,
Avatar = userVm.Avatar,
Email = userVm.Email,
FullName = userVm.FullName,
CreatedDate = DateTime.Now,
PhoneNumber = userVm.PhoneNumber,
Status = userVm.Status
};
var result = await _userManager.CreateAsync(user, userVm.Password);
if (result.Succeeded && userVm.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userVm.Roles);
}
_unitOfWork.Commit();
}
return(true);
}
public async Task <IActionResult> SaveEntity(AppUserViewModel userVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
if (userVm.Id == null)
{
var announcement = new AnnouncementViewModel()
{
Content = $"User {userVm.UserName} has been created",
DateCreated = DateTime.Now,
Status = Status.Active,
Title = "User created",
UserId = User.GetUserId(),
DateModified = DateTime.Now,
Id = Guid.NewGuid().ToString()
};
await _userService.AddAsync(userVm);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
else
{
userVm.DateModified = DateTime.Now;
await _userService.UpdateAsync(userVm);
}
_userService.SaveChanges();
return(new OkObjectResult(userVm));
}
public async Task <bool> AddAsync(AppUserViewModel userVm)
{
var user = new AppUser()
{
UserName = userVm.UserName,
Avatar = userVm.Avatar,
Email = userVm.Email,
FullName = userVm.FullName,
DateCreated = DateTime.Now,
PhoneNumber = userVm.PhoneNumber,
UserCreated = userVm.UserCreated,
UserModified = userVm.UserModified,
Active = userVm.Active
};
if (!string.IsNullOrEmpty(userVm.Birthday))
{
user.Birthday = DateTime.ParseExact(userVm.Birthday, "dd/MM/yyyy", CultureInfo.InvariantCulture);
}
var result = await _userManager.CreateAsync(user, userVm.Password);
if (result.Succeeded && userVm.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userVm.Roles);
}
}
return(true);
}