/// <summary>
/// Enable users account in Umbraco, allowing them to log into the backend
/// </summary>
/// <param name="model">User data</param>
public void EnableUser(UmbracoUserModel model)
{
var user = _userService.GetUserById(model.UserId);
user.IsApproved = true;
_userService.Save(user);
}
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);
}
/// <summary>
/// Post request to umbraco web service to unlock the users account
/// </summary>
/// <param name="model">UmbracoUserModel - UserId</param>
public void EnableUser(UmbracoUserModel model)
{
var response = PostMessage("PostEnableUser", model);
if (response.IsSuccessStatusCode)
{
return;
}
var ex = response.Content.ReadAsAsync <Exception>().Result;
throw ex;
}
/// <summary>
/// Post request to Umbraco web service to create a new user
/// </summary>
/// <param name="model">UmbracoUserModel - UserName, FullName and EmailAddress</param>
public UmbracoUserModel CreateNewUser(UmbracoUserModel model)
{
var response = PostMessage("PostCreateUser", model);
if (!response.IsSuccessStatusCode)
{
return(null);
}
model = response.Content.ReadAsAsync <UmbracoUserModel>().Result;
return(model);
}
public HttpResponseMessage PostNewUsers(UmbracoUserModel model)
{
try
{
_userAdminService.CreateUmbracoUser(model);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// Email the admin team to inform them of the new account so they can setup permissions
/// </summary>
/// <param name="model">UmbracoUserModel - FullName, UserName and EmailAddress</param>
public void CreateNewUserEmail(UmbracoUserModel model)
{
var subject = string.Format("ESCC website - new web author account created for {0}", model.FullName);
var body = new StringBuilder();
body.AppendLine("<p>Hello Web Staff,</p>");
body.AppendFormatLine("<p>A new web author account has been created for {0}:</P>", model.FullName);
body.AppendFormatLine("<p>Username: {0}<br/>Email address: {1}</p>", model.UserName, model.EmailAddress);
body.AppendLine("<p>You can now go to the User Access Manager to set up the pages that this web author will be responsible for.</p>");
var emailTo = ConfigurationManager.AppSettings["EmailTo"];
SmtpSendEmail(emailTo, subject, body.ToString());
}
/// <summary>
/// Retrieve user info for provided user ID
/// </summary>
/// <param name="id">User Id to search for</param>
/// <returns>User details</returns>
public UmbracoUserModel LookupUserById(int id)
{
var user = _userService.GetUserById(id);
var model = new UmbracoUserModel
{
UserName = user.Username,
FullName = user.Name,
EmailAddress = user.Email,
UserId = user.Id,
UserLocked = !user.IsApproved,
IsWebAuthor = (user.UserType.Alias == _webAuthorUserType)
};
return(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));
}
/// <summary>
/// Given a valid model, Create a new user and email the admin team
/// </summary>
/// <param name="model">UmbracoUserModel - UserName, FullName, EmailAddress</param>
/// <returns>success bool - all operations complete without error</returns>
public UmbracoUserModel CreateUser(UmbracoUserModel model)
{
try
{
var newUser = _umbracoService.CreateNewUser(model);
_emailService.CreateNewUserEmail(newUser);
return(newUser);
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
}
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));
}
/// <summary>
/// Get a list of Umbraco users of the required type
/// </summary>
/// <param name="usertypeAlias">Type of Umbraco user required</param>
/// <param name="excludeUsers">List of users to exclude from the returned set</param>
/// <returns>List of Umbraco Users of the required type, excluding those in the excluded users list</returns>
private IList <UmbracoUserModel> LookupUmbracoUser(string usertypeAlias, int[] excludeUsers)
{
var userList = new List <UmbracoUserModel>();
var excludeList = new List <UmbracoUserModel>();
if (excludeUsers != null)
{
foreach (var user in excludeUsers)
{
var u = LookupUserById(user);
if (u != null)
{
excludeList.Add(u);
}
}
}
int totalRecords;
// Get the User Type
var userType = _userService.GetUserTypeByAlias(usertypeAlias);
// Get all users of the required Type
var users = _userService.GetAll(0, int.MaxValue, out totalRecords).Where(t => t.UserType.Id == userType.Id);
foreach (var user in users)
{
var ed = new UmbracoUserModel
{
UserId = user.Id,
UserName = user.Username,
FullName = user.Name,
EmailAddress = user.Email,
IsWebAuthor = (usertypeAlias == "author"),
UserLocked = !user.IsApproved
};
userList.Add(ed);
}
// return all users except those in the excludeUsers array.
return(userList.Except(excludeList).OrderBy(o => o.FullName).ToList());
}
/// <summary>
/// Create a new user using the information provided. Then grant access to the necessary admin sections
/// </summary>
/// <param name="model">New user information</param>
/// <returns>Updated User Model containing new User Id</returns>
public UmbracoUserModel CreateUmbracoUser(UmbracoUserModel model)
{
var user = _userService.CreateWithIdentity(model.UserName, model.EmailAddress, Guid.NewGuid().ToString(),
_webAuthorUserType);
user.Name = model.FullName;
// Set Content Start Node to the Home page.
var home = _contentService.GetRootContent().FirstOrDefault(x => x.ContentType.Alias == _homeContentTypeAlias);
user.StartContentId = home.Id;
// Give user access to Content and Media sections
user.AddAllowedSection("content");
user.AddAllowedSection("media");
_userService.Save(user);
model.UserId = user.Id;
return(model);
}
/// <summary>
/// Locks / unlock the users umbraco account
/// </summary>
/// <param name="model">UmbracoUserModel - UserId</param>
/// <returns>success bool - all operations complete without error</returns>
public bool ToggleLock(UmbracoUserModel model)
{
try
{
if (model.UserLocked)
{
_umbracoService.EnableUser(model);
}
else
{
_umbracoService.DisableUser(model);
}
return(true);
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
}
/// <summary>
/// Get a list of expiring pages, collated by User
/// </summary>
/// <param name="noOfDaysFrom">
/// How many days to look forward
/// </param>
/// <returns>
/// List Users with expiring pages they are responsible for
/// </returns>
public IList <UserPagesModel> GetExpiringNodesByUser(int noOfDaysFrom)
{
// Get all content at the root
var rootnodes = _contentService.GetRootContent();
// Create a list to store expiring content
List <IContent> expiringNodes = new List <IContent>();
// for each content node at the root
foreach (var node in rootnodes)
{
// if the node is expiring within the declared period, add it to the list
if (node.ExpireDate > DateTime.Now && node.ExpireDate < DateTime.Now.AddDays(noOfDaysFrom))
{
expiringNodes.Add(node);
}
// get the root nodes children that are expiring within the declared period.
var descendants = node.Descendants().Where(nn => nn.ExpireDate > DateTime.Now && nn.ExpireDate < DateTime.Now.AddDays(noOfDaysFrom)).OrderBy(nn => nn.ExpireDate);
foreach (var child in descendants)
{
// add each one to the list
expiringNodes.Add(child);
}
}
// once done, order by expire date.
expiringNodes.OrderBy(nn => nn.ExpireDate);
// For each page:
IList <UserPagesModel> userPages = new List <UserPagesModel>();
// Create a WebStaff record. Use -1 as an Id as there won't be a valid Umbraco user with that value.
var webStaff = new UserPagesModel();
var webstaffUser = new UmbracoUserModel
{
UserId = -1,
UserName = "******",
FullName = "Web Staff",
EmailAddress = "*****@*****.**"
};
webStaff.User = webstaffUser;
userPages.Add(webStaff);
var helper = new UmbracoHelper(UmbracoContext.Current);
foreach (var expiringNode in expiringNodes)
{
// this should not happen, but just in case...
if (expiringNode.ExpireDate == null)
{
continue;
}
var userPage = new UserPageModel
{
PageId = expiringNode.Id,
PageName = expiringNode.Name,
PagePath = expiringNode.Path,
PageUrl = helper.NiceUrl(expiringNode.Id),
ExpiryDate = (DateTime)expiringNode.ExpireDate
};
// Get Web Authors with permission
// if no permissions at all, then there will be only one element which will contain a "-"
// If only the default permission then there will only be one element which will contain "F" (Browse Node)
var perms =
_contentService.GetPermissionsForEntity(expiringNode)
.Where(
x =>
x.AssignedPermissions.Count() > 1 ||
(x.AssignedPermissions[0] != "-" && x.AssignedPermissions[0] != "F"));
var nodeAuthors = perms as IList <EntityPermission> ?? perms.ToList();
// if no Web Authors, add this page to the WebStaff list
if (!nodeAuthors.Any())
{
userPages.Where(p => p.User.UserId == -1).ForEach(u => u.Pages.Add(userPage));
continue;
}
// if all Authors of a page are disabled, add page to the webStaff list
List <EntityPermission> disabledUsers = new List <EntityPermission>();
foreach (var user in nodeAuthors)
{
var tempUser = _userService.GetUserById(user.UserId);
if (!tempUser.IsApproved)
{
disabledUsers.Add(user);
}
}
if (disabledUsers.Count == nodeAuthors.Count)
{
userPages.Where(p => p.User.UserId == -1).ForEach(u => u.Pages.Add(userPage));
continue;
}
// Add the current page to each user that has edit rights
foreach (var author in nodeAuthors)
{
var user = userPages.FirstOrDefault(f => f.User.UserId == author.UserId);
// Create a User record if one does not yet exist
if (user == null)
{
var pUser = _userService.GetUserById(author.UserId);
// Check that this author is not Disabled / Locked Out
// If they are, end this loop and move onto the next author
if (!pUser.IsApproved)
{
continue;
}
var p = new UmbracoUserModel
{
UserId = author.UserId,
UserName = pUser.Username,
FullName = pUser.Name,
EmailAddress = pUser.Email
};
user = new UserPagesModel {
User = p
};
userPages.Add(user);
}
// Assign the current page (outer loop) to this author
userPages.Where(p => p.User.UserId == user.User.UserId).ForEach(u => u.Pages.Add(userPage));
}
}
// Return a list of users to email, along with the page details
return(userPages);
}
