async Task <User> BuildUserAsync(IEntity entity)
{
var user = await _platoUserStore.GetByIdAsync(entity.CreatedUserId);
if (user == null)
{
return(null);
}
// Ensure we check against the IP address being used at the time of the post
user.IpV4Address = entity.IpV4Address;
user.IpV6Address = entity.IpV6Address;
return(user);
}
public override async Task <IViewProviderResult> BuildDisplayAsync(UserIndex userIndex, IViewProviderContext context)
{
// Get user
var user = await _platoUserStore.GetByIdAsync(userIndex.Id);
if (user == null)
{
return(await BuildIndexAsync(userIndex, context));
}
// Get index view model from context
var indexViewModel = context.Controller.HttpContext.Items[typeof(EntityIndexViewModel <Question>)] as EntityIndexViewModel <Question>;
if (indexViewModel == null)
{
throw new Exception($"A view model of type {typeof(EntityIndexViewModel<Question>).ToString()} has not been registered on the HttpContext!");
}
// Build feature entities model
var featureEntityMetrics = new FeatureEntityCounts()
{
Features = await _featureEntityCountService
.ConfigureQuery(q =>
{
q.CreatedUserId.Equals(user.Id);
q.HideSpam.True();
q.HideHidden.True();
q.HideDeleted.True();
q.HidePrivate.True();
})
.GetResultsAsync()
};
// Build view model
var userDisplayViewModel = new UserDisplayViewModel <Question>()
{
User = user,
IndexViewModel = indexViewModel,
Counts = featureEntityMetrics
};
// Build view
return(Views(
View <UserDisplayViewModel>("User.Index.Header", model => userDisplayViewModel).Zone("header"),
View <UserDisplayViewModel <Question> >("User.Index.Content", model => userDisplayViewModel).Zone("content"),
View <UserDisplayViewModel>("User.Entities.Display.Sidebar", model => userDisplayViewModel).Zone("content-right")
));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(ProfilePage profile, IViewProviderContext context)
{
var user = await _platoUserStore.GetByIdAsync(profile.Id);
if (user == null)
{
return(await BuildIndexAsync(profile, context));
}
return(Views(
View <User>("Home.Display.Header", model => user).Zone("header"),
View <User>("Home.Display.Tools", model => user).Zone("tools"),
View <User>("Home.Display.Content", model => user).Zone("content").Order(int.MinValue + 100),
View <User>("Home.Display.Sidebar", model => user).Zone("sidebar")
));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(Profile profile,
IViewProviderContext context)
{
var user = await _platoUserStore.GetByIdAsync(profile.Id);
if (user == null)
{
return(await BuildIndexAsync(profile, context));
}
var badges = await _badgeEntriesStore.SelectByUserIdAsync(user.Id);
var viewModel = new ProfileDisplayViewModel()
{
User = user,
Badges = badges
};
return(Views(
View <ProfileDisplayViewModel>("Profile.Display.Content", model => viewModel).Zone("content").Order(0)
));
}
async Task <IEnumerable <User> > GetPostedUsers()
{
var usersJson = "";
foreach (var key in _request.Form.Keys)
{
if (key.Equals("users"))
{
usersJson = _request.Form[key];
}
}
// Build users to effect
List <User> users = null;
if (!String.IsNullOrEmpty(usersJson))
{
var items = JsonConvert.DeserializeObject <IEnumerable <UserApiResult> >(usersJson);
foreach (var item in items)
{
if (item.Id > 0)
{
if (users == null)
{
users = new List <User>();
}
var user = await _userStore.GetByIdAsync(item.Id);
if (user != null)
{
users.Add(user);
}
}
}
}
return(users);
}
public override async Task <IViewProviderResult> BuildDisplayAsync(Profile discuss, IViewProviderContext context)
{
var user = await _platoUserStore.GetByIdAsync(discuss.Id);
if (user == null)
{
return(await BuildIndexAsync(discuss, context));
}
var followType = FollowTypes.User;
var isFollowing = false;
var currentUser = await _contextFacade.GetAuthenticatedUserAsync();
if (currentUser != null)
{
var existingFollow = await _followStore.SelectByNameThingIdAndCreatedUserId(
followType.Name,
user.Id,
currentUser.Id);
if (existingFollow != null)
{
isFollowing = true;
}
}
return(Views(
View <FollowViewModel>("Follow.Display.Tools", model =>
{
model.FollowType = followType;
model.ThingId = user.Id;
model.IsFollowing = isFollowing;
return model;
}).Zone("tools").Order(1)
));
}
public async Task <IActionResult> Index(EntityIndexOptions opts, PagerOptions pager)
{
// Default options
if (opts == null)
{
opts = new EntityIndexOptions();
}
// Default pager
if (pager == null)
{
pager = new PagerOptions();
}
// Get user
var user = await _platoUserStore.GetByIdAsync(opts.CreatedByUserId);
// Ensure user exists
if (user == null)
{
return(NotFound());
}
// Get default options
var defaultViewOptions = new EntityIndexOptions();
var defaultPagerOptions = new PagerOptions();
// Add non default route data for pagination purposes
if (opts.Search != defaultViewOptions.Search)
{
this.RouteData.Values.Add("opts.search", opts.Search);
}
if (opts.Sort != defaultViewOptions.Sort)
{
this.RouteData.Values.Add("opts.sort", opts.Sort);
}
if (opts.Order != defaultViewOptions.Order)
{
this.RouteData.Values.Add("opts.order", opts.Order);
}
if (opts.Filter != defaultViewOptions.Filter)
{
this.RouteData.Values.Add("opts.filter", opts.Filter);
}
if (pager.Page != defaultPagerOptions.Page)
{
this.RouteData.Values.Add("pager.page", pager.Page);
}
if (pager.Size != defaultPagerOptions.Size)
{
this.RouteData.Values.Add("pager.size", pager.Size);
}
// Build view model
var viewModel = await GetIndexViewModelAsync(opts, pager);
// Add view model to context
HttpContext.Items[typeof(EntityIndexViewModel <Article>)] = viewModel;
// If we have a pager.page querystring value return paged results
if (int.TryParse(HttpContext.Request.Query["pager.page"], out var page))
{
if (page > 0)
{
return(View("GetArticles", viewModel));
}
}
// Build page title
_pageTitleBuilder
.AddSegment(S["Users"])
.AddSegment(S[user.DisplayName])
.AddSegment(S["Articles"]);
// Build breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Users"], users => users
.Action("Index", "Home", "Plato.Users")
.LocalNav()
).Add(S[user.DisplayName], name => name
.Action("Display", "Home", "Plato.Users", new RouteValueDictionary()
{
["opts.id"] = user.Id,
["opts.alias"] = user.Alias
})
.LocalNav()
).Add(S["Articles"]);
});
//// Return view
return(View((LayoutViewModel)await _userViewProvider.ProvideDisplayAsync(new UserIndex()
{
Id = user.Id
}, this)));
}
public override async Task <IViewProviderResult> BuildEditAsync(User user, IViewProviderContext updater)
{
//var details = user.GetOrCreate<UserDetail>();
User isVerifiedBy = null;
User isSpamBy = null;
User isBannedBy = null;
User isStaffBy = null;
if (user.IsVerified && user.IsVerifiedUpdatedUserId > 0)
{
isVerifiedBy = await _userStore.GetByIdAsync(user.IsVerifiedUpdatedUserId);
}
if (user.IsSpam && user.IsSpamUpdatedUserId > 0)
{
isSpamBy = await _userStore.GetByIdAsync(user.IsSpamUpdatedUserId);
}
if (user.IsBanned && user.IsBannedUpdatedUserId > 0)
{
isBannedBy = await _userStore.GetByIdAsync(user.IsBannedUpdatedUserId);
}
if (user.IsStaff && user.IsStaffUpdatedUserId > 0)
{
isStaffBy = await _userStore.GetByIdAsync(user.IsStaffUpdatedUserId);
}
var viewModel = new EditUserViewModel()
{
Id = user.Id,
DisplayName = user.DisplayName,
UserName = user.UserName,
Email = user.Email,
Avatar = user.Avatar,
Css = user.Css,
Location = user.Location,
Url = user.Url,
Biography = user.Biography,
Signature = user.Signature,
SignatureHtml = user.SignatureHtml,
SignatureHtmlName = BySignatureHtmlName,
CreatedDate = user.CreatedDate,
LastLoginDate = user.LastLoginDate,
IsNewUser = user.Id == 0,
UserType = user.UserType,
RoleNames = user.RoleNames,
DisplayPasswordFields = user.Id == 0,
EmailConfirmed = user.EmailConfirmed,
IsSpam = user.IsSpam,
IsSpamUpdatedUser = isSpamBy != null ? new SimpleUser(isSpamBy) : null,
IsSpamUpdatedDate = user.IsSpamUpdatedDate,
IsVerified = user.IsVerified,
IsVerifiedUpdatedUser = isVerifiedBy != null ? new SimpleUser(isVerifiedBy) : null,
IsVerifiedUpdatedDate = user.IsVerifiedUpdatedDate,
IsStaff = user.IsStaff,
IsStaffUpdatedUser = isStaffBy != null ? new SimpleUser(isStaffBy) : null,
IsStaffUpdatedDate = user.IsStaffUpdatedDate,
IsBanned = user.IsBanned,
IsBannedUpdatedUser = isBannedBy != null ? new SimpleUser(isBannedBy) : null,
IsBannedUpdatedDate = user.IsBannedUpdatedDate
};
return(Views(
View <EditUserViewModel>("Admin.Edit.Header", model => viewModel).Zone("header"),
View <EditUserViewModel>("Admin.Edit.Meta", model => viewModel).Zone("meta"),
View <EditUserViewModel>("Admin.Edit.Content", model => viewModel).Zone("content"),
View <EditUserViewModel>("Admin.Edit.Sidebar", model => viewModel).Zone("sidebar"),
View <EditUserViewModel>("Admin.Edit.Footer", model => viewModel).Zone("footer"),
View <EditUserViewModel>("Admin.Edit.Actions", model => viewModel).Zone("actions")
));
}
async Task <TEntity> BuildContributorsAsync(TEntity entity)
{
// We always need a contributor to add
if (entity.ModifiedUserId <= 0)
{
return(entity);
}
// Get user modifying entity
var user = await _platoUserStore.GetByIdAsync(entity.ModifiedUserId);
// We always need a contributor to add
if (user == null)
{
return(entity);
}
// Get entity details to update
var details = entity.GetOrCreate <ArticleDetails>();
// No need to add the contributor more than once
var exists = false;
foreach (var contributor in details.Contributors)
{
if (contributor.Id == user.Id)
{
// Indicate contributor already exists
exists = true;
// Update contributor details as they may change
contributor.Id = user.Id;
contributor.UserName = user.UserName;
contributor.DisplayName = user.DisplayName;
contributor.Alias = user.Alias;
contributor.PhotoColor = user.PhotoColor;
contributor.PhotoUrl = user.PhotoUrl;
contributor.Signature = "";
contributor.SignatureHtml = "";
// update contribution data
contributor.ContributionCount += 1;
contributor.ContributionDate = DateTimeOffset.UtcNow;
}
}
// If the contributor does not exist add them
if (!exists)
{
details.Contributors.Add(new EntityContributor()
{
Id = user.Id,
UserName = user.UserName,
DisplayName = user.DisplayName,
Alias = user.Alias,
PhotoColor = user.PhotoColor,
PhotoUrl = user.PhotoUrl,
Signature = "",
SignatureHtml = "",
ContributionCount = 1,
ContributionDate = DateTimeOffset.UtcNow
});
}
// Add updated data to entity
entity.AddOrUpdate <ArticleDetails>(details);
// Return updated entity
return(entity);
}
public override async Task <IViewProviderResult> BuildDisplayAsync(ProfilePage profile, IViewProviderContext context)
{
// Get user
var user = await _platoUserStore.GetByIdAsync(profile.Id);
// Ensure user exists
if (user == null)
{
return(await BuildIndexAsync(profile, context));
}
var indexOptions = new EntityIndexOptions()
{
CreatedByUserId = user.Id
};
var featureEntityMetrics = new FeatureEntityCounts()
{
Features = await _featureEntityCountService
.ConfigureQuery(async q =>
{
// Hide private?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewPrivateEntities))
{
q.HidePrivate.True();
}
// Hide hidden?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewHiddenEntities))
{
q.HideHidden.True();
}
// Hide spam?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewSpamEntities))
{
q.HideSpam.True();
}
// Hide deleted?
if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
Permissions.ViewDeletedEntities))
{
q.HideDeleted.True();
}
})
.GetResultsAsync(indexOptions)
};
var viewModel = new UserDisplayViewModel <Entity>()
{
User = user,
Counts = featureEntityMetrics,
IndexViewModel = new EntityIndexViewModel <Entity>()
{
Options = indexOptions,
Pager = new PagerOptions()
{
Page = 1,
Size = 10,
Enabled = false
}
}
};
// Return view
return(Views(
View <UserDisplayViewModel <Entity> >("Profile.Entities.Display.Content", model => viewModel)
.Zone("content")
.Order(int.MaxValue - 100)
));
}
public async Task <IActionResult> CreatePost(EditModeratorViewModel viewModel)
{
// Build users to effect
var users = new List <User>();
if (!String.IsNullOrEmpty(viewModel.Users))
{
var items = JsonConvert.DeserializeObject <IEnumerable <UserApiResult> >(viewModel.Users);
foreach (var item in items)
{
if (item.Id > 0)
{
var user = await _userStore.GetByIdAsync(item.Id);
if (user != null)
{
users.Add(user);
}
}
}
}
var userId = 0;
foreach (var user in users)
{
userId = user.Id;
}
var moderator = new Moderator()
{
UserId = userId
};
// Validate model state within all involved view providers
if (await _viewProvider.IsModelStateValidAsync(moderator, this))
{
// Get composed type from all involved view providers
var model = await _viewProvider.ComposeModelAsync(moderator, this);
// Create moderator
var result = await _moderatorStore.CreateAsync(model);
if (result != null)
{
// Update moderator within various view providers
await _viewProvider.ProvideUpdateAsync(result, this);
// Everything was OK
_alerter.Success(T["Moderator Created Successfully!"]);
// Redirect to topic
return(RedirectToAction(nameof(Index), new { Id = 0 }));
}
}
else
{
_alerter.Danger(T["You must specify at least 1 user!"]);
}
return(await Create());
//if (users.Count > 0)
//{
// // Compose moderator from all involved view providers
// // This ensures the claims are always populated
// var composedModerator = await _viewProvider.GetComposedType(this);
// var isValid = false;
// //// Update each user
// //foreach (var user in users)
// //{
// // composedModerator.UserId = user.Id;
// // // Validate model state within all view providers
// // if (await _viewProvider.IsModelStateValid(composedModerator, this))
// // {
// // // Create moderator
// // var result = await _moderatorStore.CreateAsync(composedModerator);
// // if (result != null)
// // {
// // // Update moderator within various view providers
// // await _viewProvider.ProvideUpdateAsync(result, this);
// // isValid = true;
// // }
// // }
// //}
// //if (isValid)
// //{
// // // Everything was OK
// // _alerter.Success(T["Moderator Created Successfully!"]);
// // // Redirect to topic
// // return RedirectToAction(nameof(Index), new {Id = 0});
// //}
// // if we reach this point some view model validation
// // failed within a view provider, display model state errors
// foreach (var modelState in ViewData.ModelState.Values)
// {
// foreach (var error in modelState.Errors)
// {
// _alerter.Danger(T[error.ErrorMessage]);
// }
// }
// return await Create();
//}
//else
//{
// _alerter.Danger(T["You must specify at least 1 user!"]);
//}
//return await Create();
}
// -----------------
// Display User
// -----------------
public async Task <IActionResult> Display(DisplayUserOptions opts)
{
// Ensure we have permission
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.ViewProfiles))
{
return(Unauthorized());
}
// Get user to display
var user = opts.Id > 0
? await _platoUserStore.GetByIdAsync(opts.Id)
: await _contextFacade.GetAuthenticatedUserAsync();
if (user == null)
{
return(NotFound());
}
// Ensure we have permission to view unconfirmed accounts
if (!user.EmailConfirmed)
{
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.ViewUnconfirmedUsers))
{
return(Unauthorized());
}
}
// Ensure we have permission to view users flagged as SPAM
if (user.IsSpam)
{
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.ViewSpamUsers))
{
return(Unauthorized());
}
}
// Ensure we have permission to view banned users
if (user.IsBanned)
{
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.ViewBannedUsers))
{
return(Unauthorized());
}
}
// Return Url for authentication & canonical url purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Users",
["controller"] = "Home",
["action"] = "Display",
["opts.id"] = user != null ? user.Id.ToString() : "",
["opts.alias"] = user != null ? user.Alias : ""
});;
// Build page title
_pageTitleBuilder.AddSegment(S[user.DisplayName], int.MaxValue);
// Build breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Users"], discuss => discuss
.Action("Index", "Home", "Plato.Users")
.LocalNav()
).Add(S[user.DisplayName]);
});
// Add user to context
HttpContext.Items[typeof(User)] = user;
// Build view model
var viewModel = new ProfilePage()
{
Id = user.Id
};
// Return view
return(View((LayoutViewModel)await _viewProvider.ProvideDisplayAsync(viewModel, this)));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(EntityUserIndex userIndex, IViewProviderContext context)
{
var user = await _platoUserStore.GetByIdAsync(userIndex.Id);
if (user == null)
{
return(await BuildIndexAsync(userIndex, context));
}
var indexViewModel = context.Controller.HttpContext.Items[typeof(EntityIndexViewModel <Entity>)] as EntityIndexViewModel <Entity>;
if (indexViewModel == null)
{
throw new Exception($"A view model of type {typeof(EntityIndexViewModel<Entity>).ToString()} has not been registered on the HttpContext!");
}
var featureEntityMetrics = new FeatureEntityCounts()
{
Features = await _featureEntityCountService
.ConfigureQuery(q =>
{
q.CreatedUserId.Equals(user.Id);
q.HideSpam.True();
q.HideHidden.True();
q.HideDeleted.True();
q.HidePrivate.True();
//// Hide private?
//if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
// Permissions.ViewPrivateEntities))
//{
// q.HidePrivate.True();
//}
//// Hide hidden?
//if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
// Permissions.ViewHiddenEntities))
//{
// q.HideHidden.True();
//}
//// Hide spam?
//if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
// Permissions.ViewSpamEntities))
//{
// q.HideSpam.True();
//}
//// Hide deleted?
//if (!await _authorizationService.AuthorizeAsync(context.Controller.HttpContext.User,
// Permissions.ViewDeletedEntities))
//{
// q.HideDeleted.True();
//}
})
.GetResultsAsync()
};
var userDisplayViewModel = new UserDisplayViewModel <Entity>()
{
User = user,
IndexViewModel = indexViewModel,
Counts = featureEntityMetrics
};
return(Views(
View <UserDisplayViewModel>("User.Index.Header", model => userDisplayViewModel).Zone("header"),
View <UserDisplayViewModel <Entity> >("User.Index.Content", model => userDisplayViewModel).Zone("content"),
View <UserDisplayViewModel>("User.Entities.Display.Sidebar", model => userDisplayViewModel).Zone("sidebar")
));
}
