public IList <UmbracoUserModel> LookupUsers(FindUserModel model)
{
if (!model.IsValidRequest)
{
return(null);
}
try
{
if (model.IsEmailRequest)
{
var modelList = _umbracoService.GetAllUsersByEmail(model.EmailAddress);
return(modelList);
}
if (model.IsUserRequest)
{
var modelList = _umbracoService.GetAllUsersByUsername(model.UserName);
return(modelList);
}
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
return(null);
}
/// <summary>
/// Get permissions for supplied user
/// </summary>
/// <param name="model">user details</param>
/// <returns>List of pages</returns>
public IList <PermissionsModel> CheckUserPermissions(FindUserModel model)
{
try
{
var user = _userControlService.LookupUsers(model);
if (user.IsNullOrEmpty())
{
return(null);
}
//var modelList = _databaseService.CheckUserPermissions(user.First().UserId);
//var permissionsModels = modelList as IList<PermissionsModel> ?? modelList.ToList();
var permissionsModels = _umbracoService.CheckUserPermissions(user.First().UserId);
return(permissionsModels);
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
}
public void UmbracoUserControlTestSetup()
{
passWordResetModel = new PasswordResetModel();
passWordResetModelOut = new PasswordResetModel();
umbracoUserModel = new UmbracoUserModel();
umbracoUserModelListOut = new List <UmbracoUserModel>();
findUserModel = new FindUserModel();
contentTreeViewModel = new ContentTreeViewModel();
contentTreeViewModelListOut = new List <ContentTreeViewModel>();
permissionsModel = new PermissionsModel();
permissionsModelsListOut = new List <PermissionsModel>();
mockPermissionsControlService = new Mock <IPermissionsControlService>().Object;
mockEmailService = new Mock <IEmailService>().Object;
var userControlServiceMock = new Mock <IUserControlService>();
userControlServiceMock.Setup(x => x.LookupUserById(2))
.Returns(contentTreeViewModel);
mockUserControlService = userControlServiceMock.Object;
var umbracoServiceMock = new Mock <IUmbracoService>();
umbracoServiceMock.Setup(x => x.GetAllUsersByEmail("Email"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetAllUsersByUsername("Username"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetContentRoot())
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.GetContentChild(1))
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.SetContentPermissions(permissionsModel))
.Returns(true);
mockUmbracoService = umbracoServiceMock.Object;
var databaseServiceMock = new Mock <IDatabaseService>();
databaseServiceMock.Setup(x => x.GetResetDetails(passWordResetModel))
.Returns(passWordResetModelOut);
//databaseServiceMock.Setup(x => x.CheckUserPermissions(1))
// .Returns(permissionsModelsListOut);
mockDatabaseService = databaseServiceMock.Object;
timelimit = DateTime.Now;
//umbracoService = new UmbracoService();
//databaseService = new DatabaseService();
//emailService = new EmailService(mockDatabaseService);
//userControlService = new UserControlService(mockDatabaseService, mockUmbracoService, mockEmailService);
//permissionsControlService = new PermissionsControlService(mockDatabaseService, mockUmbracoService, mockUserControlService);
}
public JsonResult CheckDestinationUser(FindUserModel model)
{
if (_userControlService.LookupUsers(model).IsNullOrEmpty())
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
var user = _userControlService.LookupUsers(model).First();
return(Json(user, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Gets OAuth user by the specified user Id or Phone number asynchronous.
/// </summary>
/// <param name="model">The model contains the user Id or Phone number.</param>
/// <returns>A <see cref="Task{TResult}"/> represents the get operation. Task result contains the found user.</returns>
public async Task <OAuthUser> GetAsync(FindUserModel model)
{
TUser user;
if (model.Id != null)
{
user = await _userManager.FindByIdAsync(model.Id.ToString());
}
else
{
user = await _userManager.FindByNameAsync(model.PhoneNumber);
}
if (user == null)
{
throw new Exception("cannot find the user by id or phone number");
}
var userPrincipal = await _signInManager.CreateUserPrincipalAsync(user);
if (_userManager.SupportsUserEmail)
{
var email = await _userManager.GetEmailAsync(user);
if (!string.IsNullOrWhiteSpace(email))
{
userPrincipal.Identities.First().AddClaims(new[]
{
new Claim(JwtClaimTypes.Email, email),
new Claim(JwtClaimTypes.EmailVerified,
await _userManager.IsEmailConfirmedAsync(user) ? "true" : "false", ClaimValueTypes.Boolean)
});
}
}
if (_userManager.SupportsUserPhoneNumber)
{
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (!string.IsNullOrWhiteSpace(phoneNumber))
{
userPrincipal.Identities.First().AddClaims(new[]
{
new Claim(JwtClaimTypes.PhoneNumber, phoneNumber),
new Claim(JwtClaimTypes.PhoneNumberVerified,
await _userManager.IsPhoneNumberConfirmedAsync(user) ? "true" : "false", ClaimValueTypes.Boolean)
});
}
}
return(OAuthUser.FromUser(userPrincipal));
}
public ActionResult DisplayResults(FindUserModel model)
{
if (model == null)
{
return(RedirectToAction("Index", "Home"));
}
var pageIndex = model.Page ?? 1;
model.SearchResult = _userControlService.LookupUsers(model).ToPagedList(pageIndex, 10);
return(View("UserLookup", model));
}
public async Task <OAuthUser> Get([FromQuery] FindUserModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (model.Id == null && string.IsNullOrEmpty(model.PhoneNumber))
{
throw new ArgumentException("must provide user id or phone number. e.g. ?userId=111&phonenumber=phone");
}
return(await _service.GetAsync(model));
}
public ActionResult LookUpUser(FindUserModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index", "Home"));
}
// Either an email address or user name must be supplied
if (string.IsNullOrEmpty(model.EmailAddress) && string.IsNullOrEmpty(model.UserName))
{
return(RedirectToAction("Index", "Home"));
}
return(DisplayResults(model));
}
public ActionResult DisableUser(UmbracoUserModel model)
{
var success = _userControlService.ToggleLock(model);
if (success)
{
return(DisplayResults(new FindUserModel {
EmailAddress = model.EmailAddress
}));
}
var findUserModel = new FindUserModel {
EmailAddress = model.EmailAddress, UserName = model.UserName
};
return(LookUpUser(findUserModel));
}
public async Task <IActionResult> DeleteUserAsync([FromBody] FindUserModel model)
{
User user = await _userService.FindUserAsync(model.username);
var result = await _userService.DeleteUserAsync(user);
string Data_Created = "";
if (result.Succeeded)
{
Data_Created = "User deleted successfully.";
return(Ok(Json(Data_Created)));
}
return(BadRequest(result.Errors.Select(s => s.Description).ToString()));
}
public ActionResult CreateUser(UmbracoUserModel model)
{
if (!ModelState.IsValid)
{
return(View("CreateUser", model));
}
// Check that User does not already exist
FindUserModel find = new FindUserModel {
EmailAddress = model.EmailAddress, UserName = null
};
var user = _userControlService.LookupUsers(find);
if (user == null || user.Count > 0)
{
TempData["MsgKey"] = "EmailInUse";
return(View());
}
find.EmailAddress = null;
find.UserName = model.UserName;
user = _userControlService.LookupUsers(find);
if (user.Count > 0)
{
TempData["MsgKey"] = "LoginInUse";
return(View());
}
var newUser = _userControlService.CreateUser(model);
// Redmine #7903 - do not email user because no permissions have been setup yet
//return (newUser != null) ? RedirectToAction("InitiatePasswordReset", "Admin", newUser) : RedirectToAction("Index", "Home");
if (newUser == null)
{
return(RedirectToAction("Index", "Home"));
}
var findUser = new FindUserModel {
EmailAddress = newUser.EmailAddress
};
return(DisplayResults(findUser));
}
public ActionResult CheckUserPermissions(FindUserModel model)
{
try
{
IList <PermissionsModel> modelList = _permissionsControlService.CheckUserPermissions(model);
if (!modelList.IsNullOrEmpty())
{
return(PartialView("CheckUserPermissions", modelList));
}
TempData["MsgKey"] = "NoPageOrUser";
return(PartialView("ToolsError"));
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
TempData["MsgKey"] = string.Format("ErrorOccurred");
return(PartialView("ToolsError"));
}
}
public async Task <UserCoverModel> GetUserCover(ClaimsPrincipal claimsPrincipal, [Service] IUserPhotoResolver userResolver, FindUserModel criterias)
{
return(await userResolver.GetUserCover(claimsPrincipal, criterias));
}
public async Task <UserInfoModel> GetFullUserInfoAsync(ClaimsPrincipal claimsPrincipal, [Service] IUserResolver userResolver, FindUserModel criterias)
{
return(await userResolver.GetFullUserInfoAsync(claimsPrincipal, criterias));
}
public ActionResult FindUser(string r, string t, string q, int p = 1)
{
var model = new FindUserModel(r, t, q, p);
return(View(model));
}
public ActionResult FindUsers(FindUserModel find)
{
WJPUser curUser = profileDB.Users.Find(User.Identity.Name);
if (curUser == null)
return RedirectToAction("Error", "Home", new { message = "User database error!" });
checkRoles();
find.UserName = find.UserName.Trim().ToUpper();
if (find.UserName.Count() < 3)
return View(find);
List<WJPUser> res = new List<WJPUser>();
foreach (WJPUser user in profileDB.Users)
{
if (user.UserName.ToUpper().Contains(find.UserName) && user != curUser)
{
res.Add(user);
}
}
ViewBag.FoundList = res;
return View(find);
}
public async Task <UserInfoModel> GetFullUserInfoAsync(ClaimsPrincipal claimsPrincipal, FindUserModel criterias)
{
var currentUserId = GetCurrentUserId(claimsPrincipal);
var userId = currentUserId;
if (!string.IsNullOrEmpty(criterias.UserId))
{
userId = await _userManager.DecryptUserIdAsync(criterias.UserId);
}
var user = await _userService.FindFullByIdAsync(new IdRequestFilter <long>
{
Id = userId,
CanGetInactived = currentUserId == userId
});
if (user == null)
{
return(null);
}
var userInfo = new UserInfoModel
{
Address = user.Address,
BirthDate = user.BirthDate,
CountryCode = user.CountryCode,
CountryId = user.CountryId,
CountryName = user.CountryName,
Email = user.Email,
CreatedDate = user.CreatedDate,
Description = user.Description,
DisplayName = user.DisplayName,
Firstname = user.Firstname,
GenderId = user.GenderId,
GenderLabel = user.GenderLabel,
Lastname = user.Lastname,
PhoneNumber = user.PhoneNumber,
StatusId = user.StatusId,
StatusLabel = user.StatusLabel,
UpdatedDate = user.UpdatedDate,
CanEdit = userId == currentUserId,
};
userInfo.UserIdentityId = await _userManager.EncryptUserIdAsync(user.Id);
return(userInfo);
}
public async Task <IList <UserPhotoModel> > GetUserPhotos(ClaimsPrincipal claimsPrincipal, FindUserModel criterias)
{
var currentUserId = GetCurrentUserId(claimsPrincipal);
var userId = currentUserId;
if (criterias != null && !string.IsNullOrEmpty(criterias.UserId))
{
userId = await _userManager.DecryptUserIdAsync(criterias.UserId);
}
return(await GetUserPhotos(userId));
}
public async Task <UserCoverModel> GetUserCover(ClaimsPrincipal claimsPrincipal, FindUserModel criterias)
{
var currentUserId = GetCurrentUserId(claimsPrincipal);
var userId = currentUserId;
if (criterias != null && !string.IsNullOrEmpty(criterias.UserId))
{
userId = await _userManager.DecryptUserIdAsync(criterias.UserId);
}
var photo = GetUserPhoto(userId, UserPictureType.Cover);
return(new UserCoverModel
{
Code = photo.Code,
TypeId = photo.TypeId.ToString(),
Url = photo.Url
});
}
public async Task <UserViewModel> GetUserInfoAsync([FromBody] FindUserModel model)
{
return(Mapper.Map <User, UserViewModel>(await _userService.FindUserAsync(model.username)));
}
