552 lines
20 KiB
Plaintext
552 lines
20 KiB
Plaintext
@using System.Diagnostics.CodeAnalysis
|
|
@namespace Oqtane.UI
|
|
@inject AuthenticationStateProvider AuthenticationStateProvider
|
|
@inject SiteState SiteState
|
|
@inject NavigationManager NavigationManager
|
|
@inject INavigationInterception NavigationInterception
|
|
@inject ISyncService SyncService
|
|
@inject ISiteService SiteService
|
|
@inject IPageService PageService
|
|
@inject IUserService UserService
|
|
@inject IModuleService ModuleService
|
|
@inject ILogService LogService
|
|
@implements IHandleAfterRender
|
|
|
|
@DynamicComponent
|
|
|
|
@code {
|
|
private string _absoluteUri;
|
|
private bool _navigationInterceptionEnabled;
|
|
private PageState _pagestate;
|
|
|
|
[Parameter]
|
|
public string Runtime { get; set; }
|
|
|
|
[Parameter]
|
|
public string RenderMode { get; set; }
|
|
|
|
[CascadingParameter]
|
|
PageState PageState { get; set; }
|
|
|
|
[Parameter]
|
|
public Action<PageState> OnStateChange { get; set; }
|
|
|
|
private RenderFragment DynamicComponent { get; set; }
|
|
|
|
protected override void OnInitialized()
|
|
{
|
|
_absoluteUri = NavigationManager.Uri;
|
|
NavigationManager.LocationChanged += LocationChanged;
|
|
|
|
DynamicComponent = builder =>
|
|
{
|
|
if (PageState != null)
|
|
{
|
|
builder.OpenComponent(0, Type.GetType(Constants.PageComponent));
|
|
builder.CloseComponent();
|
|
}
|
|
};
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
NavigationManager.LocationChanged -= LocationChanged;
|
|
}
|
|
|
|
protected override async Task OnParametersSetAsync()
|
|
{
|
|
if (PageState == null)
|
|
{
|
|
await Refresh();
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("ReSharper", "StringIndexOfIsCultureSpecific.1")]
|
|
private async Task Refresh()
|
|
{
|
|
Site site;
|
|
List<Page> pages;
|
|
Page page;
|
|
User user = null;
|
|
List<Module> modules;
|
|
var moduleid = -1;
|
|
var action = Constants.DefaultAction;
|
|
var urlparameters = string.Empty;
|
|
var editmode = false;
|
|
var refresh = UI.Refresh.None;
|
|
var lastsyncdate = DateTime.UtcNow.AddHours(-1);
|
|
var runtime = (Shared.Runtime)Enum.Parse(typeof(Shared.Runtime), Runtime);
|
|
|
|
Uri uri = new Uri(_absoluteUri);
|
|
|
|
// get path
|
|
var path = uri.LocalPath.Substring(1);
|
|
|
|
// parse querystring
|
|
var querystring = ParseQueryString(uri.Query);
|
|
|
|
// reload the client application if there is a forced reload or the user navigated to a site with a different alias
|
|
if (querystring.ContainsKey("reload") || (!path.ToLower().StartsWith(SiteState.Alias.Path.ToLower()) && !string.IsNullOrEmpty(SiteState.Alias.Path)))
|
|
{
|
|
NavigationManager.NavigateTo(_absoluteUri.Replace("?reload", ""), true);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// the refresh parameter is used to refresh the PageState
|
|
if (querystring.ContainsKey("refresh"))
|
|
{
|
|
refresh = UI.Refresh.Site;
|
|
}
|
|
}
|
|
|
|
if (PageState != null)
|
|
{
|
|
editmode = PageState.EditMode;
|
|
lastsyncdate = PageState.LastSyncDate;
|
|
}
|
|
|
|
// process any sync events
|
|
var sync = await SyncService.GetSyncAsync(lastsyncdate);
|
|
lastsyncdate = sync.SyncDate;
|
|
if (sync.SyncEvents.Any())
|
|
{
|
|
// reload client application if server was restarted or site runtime/rendermode was modified
|
|
if (PageState != null && sync.SyncEvents.Exists(item => (item.TenantId == -1 || item.EntityName == EntityNames.Site && item.EntityId == SiteState.Alias.SiteId) && item.Reload))
|
|
{
|
|
NavigationManager.NavigateTo(_absoluteUri, true);
|
|
return;
|
|
}
|
|
if (sync.SyncEvents.Exists(item => item.EntityName == EntityNames.Site && item.EntityId == SiteState.Alias.SiteId))
|
|
{
|
|
refresh = UI.Refresh.Site;
|
|
}
|
|
}
|
|
|
|
if (refresh == UI.Refresh.Site || PageState == null || PageState.Alias.SiteId != SiteState.Alias.SiteId)
|
|
{
|
|
site = await SiteService.GetSiteAsync(SiteState.Alias.SiteId);
|
|
refresh = UI.Refresh.Site;
|
|
}
|
|
else
|
|
{
|
|
site = PageState.Site;
|
|
}
|
|
|
|
if (site != null)
|
|
{
|
|
if (PageState == null || refresh == UI.Refresh.Site)
|
|
{
|
|
// get user
|
|
var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
|
|
if (authState.User.Identity.IsAuthenticated)
|
|
{
|
|
user = await UserService.GetUserAsync(authState.User.Identity.Name, site.SiteId);
|
|
user.IsAuthenticated = authState.User.Identity.IsAuthenticated;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
user = PageState.User;
|
|
}
|
|
|
|
// process any sync events for user
|
|
if (refresh != UI.Refresh.Site && user != null && sync.SyncEvents.Any())
|
|
{
|
|
if (sync.SyncEvents.Exists(item => item.EntityName == EntityNames.User && item.EntityId == user.UserId))
|
|
{
|
|
refresh = UI.Refresh.Site;
|
|
}
|
|
}
|
|
|
|
if (PageState == null || refresh == UI.Refresh.Site)
|
|
{
|
|
pages = await PageService.GetPagesAsync(site.SiteId);
|
|
}
|
|
else
|
|
{
|
|
pages = PageState.Pages;
|
|
}
|
|
|
|
// format path and remove alias
|
|
path = path.Replace("//", "/"); // in case of doubleslash at end
|
|
path += (!path.EndsWith("/")) ? "/" : "";
|
|
if (SiteState.Alias.Path != "" && path.StartsWith(SiteState.Alias.Path))
|
|
{
|
|
path = path.Substring(SiteState.Alias.Path.Length + 1);
|
|
}
|
|
|
|
// extract admin route elements from path
|
|
var segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
|
|
int result;
|
|
|
|
int modIdPos = 0;
|
|
int actionPos = 0;
|
|
int urlParametersPos = 0;
|
|
|
|
for (int i = 0; i < segments.Length; i++)
|
|
{
|
|
|
|
if (segments[i] == Constants.UrlParametersDelimiter)
|
|
{
|
|
urlParametersPos = i + 1;
|
|
}
|
|
|
|
if (i >= urlParametersPos && urlParametersPos != 0)
|
|
{
|
|
urlparameters += "/" + segments[i];
|
|
}
|
|
|
|
if (segments[i] == Constants.ModuleDelimiter)
|
|
{
|
|
modIdPos = i + 1;
|
|
actionPos = modIdPos + 1;
|
|
if (actionPos <= segments.Length - 1)
|
|
{
|
|
action = segments[actionPos];
|
|
}
|
|
}
|
|
}
|
|
|
|
// check if path has moduleid and action specification ie. pagename/*/moduleid/action/
|
|
if (modIdPos > 0)
|
|
{
|
|
int.TryParse(segments[modIdPos], out result);
|
|
moduleid = result;
|
|
if (actionPos > segments.Length - 1)
|
|
{
|
|
path = path.Replace(segments[modIdPos - 1] + "/" + segments[modIdPos] + "/", "");
|
|
}
|
|
else
|
|
{
|
|
path = path.Replace(segments[modIdPos - 1] + "/" + segments[modIdPos] + "/" + segments[actionPos] + "/", "");
|
|
}
|
|
}
|
|
|
|
if (urlParametersPos > 0)
|
|
{
|
|
path = path.Replace(segments[urlParametersPos - 1] + urlparameters + "/", "");
|
|
}
|
|
|
|
// remove trailing slash so it can be used as a key for Pages
|
|
if (path.EndsWith("/")) path = path.Substring(0, path.Length - 1);
|
|
|
|
if (PageState == null || refresh == UI.Refresh.Site)
|
|
{
|
|
page = pages.FirstOrDefault(item => item.Path.Equals(path, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
else
|
|
{
|
|
page = PageState.Page;
|
|
}
|
|
|
|
// failsafe in case router cannot locate the home page for the site
|
|
if (page == null && path == "")
|
|
{
|
|
page = pages.FirstOrDefault();
|
|
path = page.Path;
|
|
}
|
|
|
|
// check if page has changed
|
|
if (page != null && page.Path != path)
|
|
{
|
|
page = pages.Where(item => item.Path == path).FirstOrDefault();
|
|
editmode = false;
|
|
}
|
|
|
|
if (page != null)
|
|
{
|
|
if (PageState == null)
|
|
{
|
|
editmode = false;
|
|
}
|
|
|
|
// check if user is authorized to view page
|
|
if (UserSecurity.IsAuthorized(user, PermissionNames.View, page.Permissions))
|
|
{
|
|
page = await ProcessPage(page, site, user);
|
|
|
|
if (PageState == null || refresh == UI.Refresh.Site)
|
|
{
|
|
modules = await ModuleService.GetModulesAsync(site.SiteId);
|
|
}
|
|
else
|
|
{
|
|
modules = PageState.Modules;
|
|
}
|
|
|
|
(page, modules) = ProcessModules(page, modules, moduleid, action, (!string.IsNullOrEmpty(page.DefaultContainerType)) ? page.DefaultContainerType : site.DefaultContainerType);
|
|
|
|
_pagestate = new PageState
|
|
{
|
|
Alias = SiteState.Alias,
|
|
Site = site,
|
|
Pages = pages,
|
|
Page = page,
|
|
User = user,
|
|
Modules = modules,
|
|
Uri = new Uri(_absoluteUri, UriKind.Absolute),
|
|
QueryString = querystring,
|
|
UrlParameters = urlparameters,
|
|
ModuleId = moduleid,
|
|
Action = action,
|
|
EditMode = editmode,
|
|
LastSyncDate = lastsyncdate,
|
|
Runtime = runtime
|
|
};
|
|
|
|
OnStateChange?.Invoke(_pagestate);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (user == null)
|
|
{
|
|
// redirect to login page
|
|
NavigationManager.NavigateTo(Utilities.NavigateUrl(SiteState.Alias.Path, "login", "?returnurl=" + path));
|
|
}
|
|
else
|
|
{
|
|
await LogService.Log(null, null, user.UserId, GetType().AssemblyQualifiedName, Utilities.GetTypeNameLastSegment(GetType().AssemblyQualifiedName, 1), LogFunction.Security, LogLevel.Error, null, "Page Does Not Exist Or User Is Not Authorized To View Page {Path}", path);
|
|
if (path != "")
|
|
{
|
|
// redirect to home page
|
|
NavigationManager.NavigateTo(Utilities.NavigateUrl(SiteState.Alias.Path, "", ""));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// site does not exist
|
|
}
|
|
}
|
|
|
|
private async void LocationChanged(object sender, LocationChangedEventArgs args)
|
|
{
|
|
_absoluteUri = args.Location;
|
|
await Refresh();
|
|
}
|
|
|
|
Task IHandleAfterRender.OnAfterRenderAsync()
|
|
{
|
|
if (!_navigationInterceptionEnabled)
|
|
{
|
|
_navigationInterceptionEnabled = true;
|
|
return NavigationInterception.EnableNavigationInterceptionAsync();
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Dictionary<string, string> ParseQueryString(string query)
|
|
{
|
|
Dictionary<string, string> querystring = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); // case insensistive keys
|
|
if (!string.IsNullOrEmpty(query))
|
|
{
|
|
if (query.StartsWith("?"))
|
|
{
|
|
query = query.Substring(1); // ignore "?"
|
|
}
|
|
foreach (string kvp in query.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
if (kvp != "")
|
|
{
|
|
if (kvp.Contains("="))
|
|
{
|
|
string[] pair = kvp.Split('=');
|
|
querystring.Add(pair[0], pair[1]);
|
|
}
|
|
else
|
|
{
|
|
querystring.Add(kvp, "true"); // default parameter when no value is provided
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return querystring;
|
|
}
|
|
|
|
private async Task<Page> ProcessPage(Page page, Site site, User user)
|
|
{
|
|
try
|
|
{
|
|
if (page.IsPersonalizable && user != null)
|
|
{
|
|
// load the personalized page
|
|
page = await PageService.GetPageAsync(page.PageId, user.UserId);
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(page.ThemeType))
|
|
{
|
|
page.ThemeType = site.DefaultThemeType;
|
|
}
|
|
|
|
page.Panes = new List<string>();
|
|
page.Resources = new List<Resource>();
|
|
|
|
string panes = PaneNames.Admin;
|
|
Type themetype = Type.GetType(page.ThemeType);
|
|
if (themetype == null)
|
|
{
|
|
// fallback
|
|
page.ThemeType = Constants.DefaultTheme;
|
|
themetype = Type.GetType(Constants.DefaultTheme);
|
|
}
|
|
if (themetype != null)
|
|
{
|
|
var themeobject = Activator.CreateInstance(themetype) as IThemeControl;
|
|
if (themeobject != null)
|
|
{
|
|
if (!string.IsNullOrEmpty(themeobject.Panes))
|
|
{
|
|
panes = themeobject.Panes;
|
|
}
|
|
page.Resources = ManagePageResources(page.Resources, themeobject.Resources);
|
|
}
|
|
}
|
|
page.Panes = panes.Replace(";", ",").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
}
|
|
catch
|
|
{
|
|
// error loading theme or layout
|
|
}
|
|
|
|
return page;
|
|
}
|
|
|
|
private (Page Page, List<Module> Modules) ProcessModules(Page page, List<Module> modules, int moduleid, string action, string defaultcontainertype)
|
|
{
|
|
var paneindex = new Dictionary<string, int>();
|
|
foreach (Module module in modules)
|
|
{
|
|
// initialize module control properties
|
|
module.SecurityAccessLevel = SecurityAccessLevel.Host;
|
|
module.ControlTitle = "";
|
|
module.Actions = "";
|
|
module.UseAdminContainer = false;
|
|
module.PaneModuleIndex = -1;
|
|
module.PaneModuleCount = 0;
|
|
|
|
if ((module.PageId == page.PageId || module.ModuleId == moduleid))
|
|
{
|
|
var typename = Constants.ErrorModule;
|
|
if (module.ModuleDefinition != null && (module.ModuleDefinition.Runtimes == "" || module.ModuleDefinition.Runtimes.Contains(Runtime)))
|
|
{
|
|
typename = module.ModuleDefinition.ControlTypeTemplate;
|
|
|
|
// handle default action
|
|
if (action == Constants.DefaultAction && !string.IsNullOrEmpty(module.ModuleDefinition.DefaultAction))
|
|
{
|
|
action = module.ModuleDefinition.DefaultAction;
|
|
}
|
|
|
|
// check if the module defines custom action routes
|
|
if (module.ModuleDefinition.ControlTypeRoutes != "")
|
|
{
|
|
foreach (string route in module.ModuleDefinition.ControlTypeRoutes.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
if (route.StartsWith(action + "="))
|
|
{
|
|
typename = route.Replace(action + "=", "");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ensure component exists and implements IModuleControl
|
|
module.ModuleType = "";
|
|
if (Constants.DefaultModuleActions.Contains(action, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
typename = Constants.DefaultModuleActionsTemplate.Replace(Constants.ActionToken, action);
|
|
}
|
|
else
|
|
{
|
|
typename = typename.Replace(Constants.ActionToken, action);
|
|
}
|
|
Type moduletype = Type.GetType(typename, false, true); // case insensitive
|
|
if (moduletype != null && moduletype.GetInterfaces().Contains(typeof(IModuleControl)))
|
|
{
|
|
module.ModuleType = Utilities.GetFullTypeName(moduletype.AssemblyQualifiedName); // get actual type name
|
|
}
|
|
|
|
// get additional metadata from IModuleControl interface
|
|
if (moduletype != null && module.ModuleType != "")
|
|
{
|
|
// retrieve module component resources
|
|
var moduleobject = Activator.CreateInstance(moduletype) as IModuleControl;
|
|
page.Resources = ManagePageResources(page.Resources, moduleobject.Resources);
|
|
if (action.ToLower() == "settings" && module.ModuleDefinition != null)
|
|
{
|
|
// settings components are embedded within a framework settings module
|
|
moduletype = Type.GetType(module.ModuleDefinition.ControlTypeTemplate.Replace(Constants.ActionToken, action), false, true);
|
|
if (moduletype != null)
|
|
{
|
|
moduleobject = Activator.CreateInstance(moduletype) as IModuleControl;
|
|
page.Resources = ManagePageResources(page.Resources, moduleobject.Resources);
|
|
}
|
|
}
|
|
|
|
// additional metadata needed for admin components
|
|
if (module.ModuleId == moduleid && action != "")
|
|
{
|
|
module.SecurityAccessLevel = moduleobject.SecurityAccessLevel;
|
|
module.ControlTitle = moduleobject.Title;
|
|
module.Actions = moduleobject.Actions;
|
|
module.UseAdminContainer = moduleobject.UseAdminContainer;
|
|
}
|
|
}
|
|
|
|
// ensure module's pane exists in current page and if not, assign it to the Admin pane
|
|
if (page.Panes == null || page.Panes.FindIndex(item => item.Equals(module.Pane, StringComparison.OrdinalIgnoreCase)) == -1)
|
|
{
|
|
module.Pane = PaneNames.Admin;
|
|
}
|
|
|
|
// calculate module position within pane
|
|
if (paneindex.ContainsKey(module.Pane.ToLower()))
|
|
{
|
|
paneindex[module.Pane.ToLower()] += 1;
|
|
}
|
|
else
|
|
{
|
|
paneindex.Add(module.Pane.ToLower(), 0);
|
|
}
|
|
|
|
module.PaneModuleIndex = paneindex[module.Pane.ToLower()];
|
|
|
|
// container fallback
|
|
if (string.IsNullOrEmpty(module.ContainerType))
|
|
{
|
|
module.ContainerType = defaultcontainertype;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (Module module in modules.Where(item => item.PageId == page.PageId))
|
|
{
|
|
if (paneindex.ContainsKey(module.Pane.ToLower()))
|
|
{
|
|
module.PaneModuleCount = paneindex[module.Pane.ToLower()] + 1;
|
|
}
|
|
}
|
|
|
|
return (page, modules);
|
|
}
|
|
|
|
private List<Resource> ManagePageResources(List<Resource> pageresources, List<Resource> resources)
|
|
{
|
|
if (resources != null)
|
|
{
|
|
foreach (var resource in resources)
|
|
{
|
|
// ensure resource does not exist already
|
|
if (pageresources.Find(item => item.Url == resource.Url) == null)
|
|
{
|
|
pageresources.Add(resource);
|
|
}
|
|
}
|
|
}
|
|
return pageresources;
|
|
}
|
|
}
|