public override async Task <IViewProviderResult> BuildEditAsync(CategoryAdmin categoryBase, IViewProviderContext updater)
{
var defaultIcons = new DefaultIcons();
EditCategoryViewModel editCategoryViewModel = null;
if (categoryBase.Id == 0)
{
editCategoryViewModel = new EditCategoryViewModel()
{
IconPrefix = defaultIcons.Prefix,
ChannelIcons = defaultIcons,
IsNewCategory = true,
ParentId = categoryBase.ParentId,
AvailableChannels = await GetAvailableChannels()
};
}
else
{
editCategoryViewModel = new EditCategoryViewModel()
{
Id = categoryBase.Id,
ParentId = categoryBase.ParentId,
Name = categoryBase.Name,
Description = categoryBase.Description,
ForeColor = categoryBase.ForeColor,
BackColor = categoryBase.BackColor,
IconCss = categoryBase.IconCss,
IconPrefix = defaultIcons.Prefix,
ChannelIcons = defaultIcons,
AvailableChannels = await GetAvailableChannels()
};
}
return(Views(
View <EditCategoryViewModel>("Admin.Edit.Header", model => editCategoryViewModel).Zone("header").Order(1),
View <EditCategoryViewModel>("Admin.Edit.Content", model => editCategoryViewModel).Zone("content").Order(1),
View <EditCategoryViewModel>("Admin.Edit.Actions", model => editCategoryViewModel).Zone("actions").Order(1),
View <EditCategoryViewModel>("Admin.Edit.Footer", model => editCategoryViewModel).Zone("footer").Order(1)
));
}
public override Task <IViewProviderResult> BuildUpdateAsync(UserIndex model, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override Task <IViewProviderResult> BuildDisplayAsync(Category indexViewModel, IViewProviderContext updater)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override Task <IViewProviderResult> BuildDisplayAsync(EditSignatureViewModel viewModel, IViewProviderContext updater)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(EditSignatureViewModel viewModel, IViewProviderContext context)
{
var user = await _platoUserStore.GetByIdAsync(viewModel.Id);
if (user == null)
{
return(await BuildIndexAsync(viewModel, context));
}
var model = new EditSignatureViewModel();;
if (!await context.Updater.TryUpdateModelAsync(model))
{
return(await BuildEditAsync(viewModel, context));
}
if (context.Updater.ModelState.IsValid)
{
//user.Signature = model.Signature;
//// Update user
//var result = await _platoUserManager.UpdateAsync(user);
//foreach (var error in result.Errors)
//{
// context.Updater.ModelState.AddModelError(string.Empty, error.Description);
//}
}
return(await BuildEditAsync(viewModel, context));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(Doc entity, IViewProviderContext context)
{
if (!context.Updater.ModelState.IsValid)
{
return(await BuildIndexAsync(entity, context));
}
// Execute UpdateModel within registered spam operators
await _spamOperatorManager.UpdateModelAsync(SpamOperations.Doc, entity);
// Return view
return(await BuildIndexAsync(entity, context));
}
public override async Task <IViewProviderResult> BuildEditAsync(PlatoSiteSettings settings, IViewProviderContext context)
{
var viewModel = await GetModel();
return(Views(
View <PlatoSiteSettingsViewModel>("Admin.Edit.Header", model => viewModel).Zone("header").Order(1),
View <PlatoSiteSettingsViewModel>("Admin.Edit.Tools", model => viewModel).Zone("tools").Order(1),
View <PlatoSiteSettingsViewModel>("Admin.Edit.Content", model => viewModel).Zone("content").Order(1)
));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(Article article, IViewProviderContext context)
{
return(await BuildEditAsync(article, context));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(Article article, IViewProviderContext context)
{
var viewModel = context.Controller.HttpContext.Items[typeof(EntityViewModel <Article, Comment>)] as EntityViewModel <Article, Comment>;
if (viewModel == null)
{
throw new Exception($"A view model of type {typeof(EntityViewModel<Article, Comment>).ToString()} has not been registered on the HttpContext!");
}
// Increment entity views
await _viewIncrementer
.Contextulize(context.Controller.HttpContext)
.IncrementAsync(article);
return(Views(
View <Article>("Home.Display.Header", model => article).Zone("header"),
View <Article>("Home.Display.Tools", model => article).Zone("header-right"),
View <Article>("Home.Display.Sidebar", model => article).Zone("content-right"),
View <EntityViewModel <Article, Comment> >("Home.Display.Content", model => viewModel).Zone("content"),
View <EditEntityReplyViewModel>("Home.Display.Footer", model => new EditEntityReplyViewModel()
{
EntityId = article.Id,
EditorHtmlName = EditorHtmlName
}).Zone("resize-content"),
View <EntityViewModel <Article, Comment> >("Home.Display.Actions", model => viewModel)
.Zone("resize-actions-right")
.Order(int.MaxValue)
));
}
public override async Task <IViewProviderResult> BuildIndexAsync(Category category, IViewProviderContext context)
{
// Get category Id
var categoryId = 0;
if (category != null)
{
categoryId = category.Id;
}
// Get follow type
var followType = categoryId == 0
? FollowTypes.AllCategories
: FollowTypes.Category;
// Get permission
var permission = categoryId == 0
? Follow.Permissions.FollowArticleCategories
: Follow.Permissions.FollowArticleCategory;
// Get thingId if available
var thingId = 0;
if (categoryId > 0)
{
var existingCategory = await _categoryStore.GetByIdAsync(categoryId);
if (existingCategory != null)
{
thingId = existingCategory.Id;
}
}
// Are we already following?
var isFollowing = false;
var currentUser = await _contextFacade.GetAuthenticatedUserAsync();
if (currentUser != null)
{
var existingFollow = await _followStore.SelectByNameThingIdAndCreatedUserId(
followType.Name,
thingId,
currentUser.Id);
if (existingFollow != null)
{
isFollowing = true;
}
}
return(Views(
View <FollowViewModel>("Follow.Display.Tools", model =>
{
model.FollowType = followType;
model.ThingId = thingId;
model.IsFollowing = isFollowing;
model.Permission = permission;
return model;
}).Zone("tools").Order(-4)
));
}
public override async Task <IViewProviderResult> BuildEditAsync(CategoryAdmin category, IViewProviderContext updater)
{
var selectedRoles = await _categoryManager.GetRolesAsync(category);
return(Views(
View <EditUserRolesViewModel>("Issues.Edit.CategoryRoles", model =>
{
model.SelectedRoles = selectedRoles;
model.HtmlName = HtmlName;
return model;
}).Order(2)
));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(Profile 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 override Task <IViewProviderResult> BuildEditAsync(Profile model, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public abstract Task <IViewProviderResult> BuildUpdateAsync(TModel viewModel, IViewProviderContext context);
public override Task <IViewProviderResult> BuildDisplayAsync(Doc entity, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildDisplayAsync(Idea idea, IViewProviderContext updater)
{
// Override breadcrumb configuration within base controller
IEnumerable <CategoryAdmin> parents = null;
if (idea.CategoryId > 0)
{
parents = await _categoryStore.GetParentsByIdAsync(idea.CategoryId);
}
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Ideas"], home => home
.Action("Index", "Home", "Plato.Ideas")
.LocalNav()
);
if (parents != null)
{
builder.Add(S["Categories"], channels => channels
.Action("Index", "Home", "Plato.Ideas.Categories", new RouteValueDictionary()
{
["opts.categoryId"] = null,
["opts.alias"] = null
})
.LocalNav()
);
foreach (var parent in parents)
{
builder.Add(S[parent.Name], channel => channel
.Action("Index", "Home", "Plato.Ideas.Categories", new RouteValueDictionary
{
["opts.categoryId"] = parent.Id,
["opts.alias"] = parent.Alias,
})
.LocalNav()
);
}
}
builder.Add(S[idea.Title]);
});
return(default(IViewProviderResult));
}
public override Task <IViewProviderResult> BuildEditAsync(Doc entity, IViewProviderContext updater)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildEditAsync(Idea idea, IViewProviderContext updater)
{
// Get feature
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Ideas.Categories");
// Ensure we found the feature
if (feature == null)
{
return(default(IViewProviderResult));
}
// Override breadcrumb configuration within base controller
IEnumerable <CategoryAdmin> parents = null;
if (idea.CategoryId > 0)
{
parents = await _categoryStore.GetParentsByIdAsync(idea.CategoryId);
}
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Ideas"], home => home
.Action("Index", "Home", "Plato.Ideas")
.LocalNav()
);
if (parents != null)
{
builder.Add(S["Categories"], categories => categories
.Action("Index", "Home", "Plato.Ideas.Categories", new RouteValueDictionary()
{
["opts.categoryId"] = null,
["opts.alias"] = null
})
.LocalNav()
);
foreach (var parent in parents)
{
builder.Add(S[parent.Name], category => category
.Action("Index", "Home", "Plato.Ideas.Categories", new RouteValueDictionary
{
["opts.categoryId"] = parent.Id,
["opts.alias"] = parent.Alias,
})
.LocalNav()
);
}
}
// Ensure we have a title
if (!String.IsNullOrEmpty(idea.Title))
{
builder.Add(S[idea.Title], t => t
.Action("Display", "Home", "Plato.Ideas", new RouteValueDictionary
{
["opts.id"] = idea.Id,
["opts.alias"] = idea.Alias,
})
.LocalNav()
);
}
builder.Add(S[idea.Id > 0 ? "Edit Idea" : "New Idea"]);
});
var viewModel = new CategoryDropDownViewModel()
{
Options = new CategoryIndexOptions()
{
FeatureId = feature.Id
},
HtmlName = CategoryHtmlName,
SelectedCategories = await GetCategoryIdsByEntityIdAsync(idea)
};
return(Views(
View <CategoryDropDownViewModel>("Ideas.Categories.Edit.Sidebar", model => viewModel).Zone("sidebar").Order(1)
));
}
public override Task <IViewProviderResult> BuildDisplayAsync(PlatoSiteSettings settings, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(Idea idea, IViewProviderContext context)
{
// Ensure entity exists before attempting to update
var entity = await _entityStore.GetByIdAsync(idea.Id);
if (entity == null)
{
return(await BuildIndexAsync(idea, context));
}
// Validate model
if (await ValidateModelAsync(idea, context.Updater))
{
// Get selected categories
var categoriesToAdd = GetCategoriesToAdd();
if (categoriesToAdd != null)
{
// Build categories to remove
var categoriesToRemove = new List <int>();
foreach (var categoryId in await GetCategoryIdsByEntityIdAsync(idea))
{
if (!categoriesToAdd.Contains(categoryId))
{
categoriesToRemove.Add(categoryId);
}
}
// Remove categories
foreach (var categoryId in categoriesToRemove)
{
var entityCategory = await _entityCategoryStore.GetByEntityIdAndCategoryIdAsync(idea.Id, categoryId);
if (entityCategory != null)
{
await _entityCategoryManager.DeleteAsync(entityCategory);
}
}
// Get current user
var user = await _contextFacade.GetAuthenticatedUserAsync();
// Add new entity category relationships
foreach (var categoryId in categoriesToAdd)
{
// Ensure relationship does not already exist
var entityCategory = await _entityCategoryStore.GetByEntityIdAndCategoryIdAsync(idea.Id, categoryId);
if (entityCategory == null)
{
// Add relationship
await _entityCategoryManager.CreateAsync(new EntityCategory()
{
EntityId = idea.Id,
CategoryId = categoryId,
CreatedUserId = user?.Id ?? 0,
ModifiedUserId = user?.Id ?? 0,
});
}
}
// Update added category meta data
foreach (var id in categoriesToAdd)
{
await _categoryDetailsUpdater.UpdateAsync(id);
}
// Update removed category meta data
foreach (var id in categoriesToRemove)
{
await _categoryDetailsUpdater.UpdateAsync(id);
}
}
}
return(await BuildEditAsync(idea, context));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(PlatoSiteSettings settings, IViewProviderContext context)
{
var model = new PlatoSiteSettingsViewModel();
// Validate model
if (!await context.Updater.TryUpdateModelAsync(model))
{
return(await BuildEditAsync(settings, context));
}
// Update settings
if (context.Updater.ModelState.IsValid)
{
// Create the model
settings = new PlatoSiteSettings()
{
DemoUrl = model.DemoUrl
};
// Persist the settings
var result = await _demoSettingsStore.SaveAsync(settings);
if (result != null)
{
// Recycle shell context to ensure changes take effect
_platoHost.RecycleShellContext(_shellSettings);
}
}
return(await BuildEditAsync(settings, context));
}
public override async Task <IViewProviderResult> BuildIndexAsync(Idea viewModel, IViewProviderContext updater)
{
// Ensure we explicitly set the featureId
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Ideas.Categories");
if (feature == null)
{
return(default(IViewProviderResult));
}
var categoryIndexViewModel = new CategoryIndexViewModel()
{
Options = new CategoryIndexOptions()
{
FeatureId = feature.Id
}
};
return(Views(
View <CategoryIndexViewModel>("Ideas.Categories.Sidebar", model => categoryIndexViewModel).Zone("sidebar")
.Order(1)
));
}
public override async Task <IViewProviderResult> BuildEditAsync(EditSignatureViewModel viewModel, IViewProviderContext updater)
{
// Ensures we persist the message between post backs
var signature = viewModel.Signature;
if (_request.Method == "POST")
{
foreach (string key in _request.Form.Keys)
{
if (key == viewModel.EditorHtmlName)
{
signature = _request.Form[key];
}
}
viewModel.Signature = signature;
}
var user = await _platoUserStore.GetByIdAsync(viewModel.Id);
if (user == null)
{
return(await BuildIndexAsync(viewModel, updater));
}
return(Views(
View <User>("Home.Edit.Header", model => user).Zone("header"),
View <User>("Home.Edit.Sidebar", model => user).Zone("sidebar"),
View <User>("Home.Edit.Tools", model => user).Zone("tools"),
View <EditSignatureViewModel>("Home.EditSignature.Content", model => viewModel).Zone("content"),
View <User>("Home.Edit.Footer", model => user).Zone("footer")
));
}
public override Task <IViewProviderResult> BuildDisplayAsync(ThemeAdmin model, IViewProviderContext updater)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override Task <IViewProviderResult> BuildEditAsync(UserIndex userIndex, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildEditAsync(ThemeAdmin model, IViewProviderContext updater)
{
// We are adding a new theme
if (String.IsNullOrEmpty(model.ThemeId))
{
var createViewModel = new CreateThemeViewModel()
{
AvailableThemes = GetAvailableThemes()
};
return(Views(
View <CreateThemeViewModel>("Admin.Create.Header", viewModel => createViewModel).Zone("header").Order(1),
View <CreateThemeViewModel>("Admin.Create.Content", viewModel => createViewModel).Zone("content").Order(1),
View <CreateThemeViewModel>("Admin.Create.Footer", viewModel => createViewModel).Zone("footer").Order(1)
));
}
var file = _siteThemeFileManager.GetFile(model.ThemeId, model.Path);
// We are editing an existing theme
var editViewModel = new EditThemeViewModel()
{
ThemeId = model.ThemeId,
Path = model.Path,
File = file,
FileContents = await _siteThemeFileManager.ReadFileAsync(file),
Files = !string.IsNullOrEmpty(model.Path)
? _siteThemeFileManager.GetFiles(model.ThemeId, model.Path)
: _siteThemeFileManager.GetFiles(model.ThemeId)
};
return(Views(
View <EditThemeViewModel>("Admin.Edit.Header", viewModel => editViewModel).Zone("header").Order(1),
View <EditThemeViewModel>("Admin.Edit.Content", viewModel => editViewModel).Zone("content").Order(1)
));
}
public override async Task <IViewProviderResult> BuildIndexAsync(Category categoryAdmin, IViewProviderContext context)
{
// Ensure we explicitly set the featureId
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Issues.Categories");
if (feature == null)
{
return(default(IViewProviderResult));
}
Category existingCategory = null;
if (categoryAdmin?.Id > 0)
{
existingCategory = await _categoryStore.GetByIdAsync(categoryAdmin.Id);
}
// Get topic index view model from context
var viewModel = context.Controller.HttpContext.Items[typeof(EntityIndexViewModel <Issue>)] as EntityIndexViewModel <Issue>;
if (viewModel == null)
{
throw new Exception($"A view model of type {typeof(EntityIndexViewModel<Issue>).ToString()} has not been registered on the HttpContext!");
}
// channel filter options
var channelViewOpts = new CategoryIndexOptions
{
CategoryId = existingCategory?.Id ?? 0,
FeatureId = feature.Id
};
var indexViewModel = new CategoryIndexViewModel()
{
Options = channelViewOpts,
EntityIndexOptions = viewModel?.Options,
Pager = viewModel?.Pager
};
return(Views(
View <CategoryBase>("Home.Index.Header", model => existingCategory).Zone("header").Order(1),
View <CategoryBase>("Home.Index.Tools", model => existingCategory).Zone("tools").Order(1),
View <CategoryIndexViewModel>("Home.Index.Content", model => indexViewModel).Zone("content").Order(1),
View <CategoryIndexViewModel>("Issues.Categories.Sidebar", model => indexViewModel).Zone("sidebar").Order(1)
));
}
public override Task <IViewProviderResult> BuildUpdateAsync(ThemeAdmin theme, IViewProviderContext context)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override Task <IViewProviderResult> BuildUpdateAsync(Category category, IViewProviderContext updater)
{
return(Task.FromResult(default(IViewProviderResult)));
}
public override async Task <IViewProviderResult> BuildIndexAsync(CategoryAdmin categoryBase, IViewProviderContext updater)
{
var feature = await _featureFacade.GetFeatureByIdAsync("Plato.Ideas.Categories");
if (feature == null)
{
throw new Exception($"No feature could be found for the Id 'Plato.Ideas.Categories'");
}
var viewModel = new CategoryIndexViewModel()
{
Options = new CategoryIndexOptions()
{
FeatureId = feature.Id,
CategoryId = categoryBase?.Id ?? 0
}
};
return(Views(
View <CategoryBase>("Admin.Index.Header", model => categoryBase).Zone("header").Order(1),
View <CategoryIndexViewModel>("Admin.Index.Tools", model => viewModel).Zone("tools").Order(1),
View <CategoryIndexViewModel>("Admin.Index.Content", model => viewModel).Zone("content").Order(1)
));
}
