public override async Task <IDisplayResult> UpdateAsync(HttpsSettings settings, BuildEditorContext context) { if (context.GroupId == SettingsGroupId) { var model = new HttpsSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); settings.EnableStrictTransportSecurity = model.EnableStrictTransportSecurity; settings.RequireHttps = model.RequireHttps; settings.RequireHttpsPermanent = model.RequireHttpsPermanent; settings.SslPort = model.SslPort; // If the settings are valid, reload the current tenant. if (context.Updater.ModelState.IsValid) { await _shellHost.ReloadShellContextAsync(_shellSettings); } } return(await EditAsync(settings, context)); }
public async Task BuildEditorAsync(ContentItem contentItem, BuildEditorContext context) { var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType); if (contentTypeDefinition == null) { return; } dynamic contentShape = context.Shape; dynamic partsShape = context.ShapeFactory.Create("Zone", Arguments.Empty); contentShape.Zones["Parts"] = partsShape; foreach (var displayDriver in _displayDrivers) { try { var result = await displayDriver.BuildEditorAsync(contentItem, context); if (result != null) { result.Apply(context); } } catch (Exception ex) { InvokeExtensions.HandleException(ex, Logger, displayDriver.GetType().Name, nameof(BuildEditorAsync)); } } foreach (var typePartDefinition in contentTypeDefinition.Parts) { ContentPart part; part = _contentPartFactory.CreateContentPart(typePartDefinition.Name) ?? new ContentPart(); part = (ContentPart)contentItem.Get(part.GetType(), typePartDefinition.Name) ?? part; part.ContentItem = contentItem; // Create a custom shape to render all the part shapes into it dynamic typePartShape = context.ShapeFactory.Create("ContentPart_Edit", Arguments.Empty); typePartShape.ContentPart = part; typePartShape.ContentTypePartDefinition = typePartDefinition; var partPosition = typePartDefinition.Settings["Position"]?.ToString() ?? "before"; partsShape.Add(typePartShape, partPosition); partsShape[typePartDefinition.Name] = typePartShape; context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => new PlacementInfo { Location = $"Parts.{typePartDefinition.Name}" }; await _partDisplayDrivers.InvokeAsync(async contentDisplay => { var result = await contentDisplay.BuildEditorAsync(part, typePartDefinition, context); if (result != null) { result.Apply(context); } }, Logger); foreach (var partFieldDefinition in typePartDefinition.PartDefinition.Fields) { var fieldName = partFieldDefinition.Name; var fieldPosition = partFieldDefinition.Settings["Position"]?.ToString() ?? "before"; context.FindPlacement = (shapeType, differentiator, displayType, displayContext) => new PlacementInfo { Location = $"Parts.{typePartDefinition.Name}:{fieldPosition}" }; await _fieldDisplayDrivers.InvokeAsync(async contentDisplay => { var result = await contentDisplay.BuildEditorAsync(part, partFieldDefinition, typePartDefinition, context); if (result != null) { result.Apply(context); } }, Logger); } } }
public override void Apply(BuildEditorContext context) { var templateShape = context.New.EditorTemplate(TemplateName: TemplateName, Model: Model, Prefix: Prefix); context.Shape.Zones[Zone].Add(templateShape, Position); }
protected virtual void BuildEditorShape(BuildEditorContext context, TPart instance) { }
public Task ApplyAsync(BuildEditorContext context) { return(ApplyImplementationAsync(context, "Edit")); }
public override void Apply(BuildEditorContext context) { ApplyImplementation(context, null); }
public override async Task <IDisplayResult> UpdateAsync(LayerSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageLayers)) { return(null); } if (context.GroupId == GroupId) { var model = new LayerSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); settings.Zones = model.Zones.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries); } return(await EditAsync(settings, context)); }
public override async Task <IDisplayResult> EditAsync(MatomoSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, MatomoPermissions.ManageMatomoSettings)) { return(null); } return(Initialize <MatomoSettingsViewModel>("MatomoSettings_Edit", model => { model.SiteID = settings.SiteID; model.ServerUri = settings.ServerUri; }).Location("Content:5").OnGroup(MatomoConstants.Features.Matomo)); }
public override async Task <IDisplayResult> UpdateAsync(SmtpSettings section, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageEmailSettings)) { return(null); } if (context.GroupId == GroupId) { var previousPassword = section.Password; await context.Updater.TryUpdateModelAsync(section, Prefix); // Restore password if the input is empty, meaning that it has not been reset. if (string.IsNullOrWhiteSpace(section.Password)) { section.Password = previousPassword; } else { // encrypt the password var protector = _dataProtectionProvider.CreateProtector(nameof(SmtpSettingsConfiguration)); section.Password = protector.Protect(section.Password); } // Release the tenant to apply the settings await _shellHost.ReleaseShellContextAsync(_shellSettings); } return(await EditAsync(section, context)); }
public override async Task <IDisplayResult> EditAsync(LayerSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageLayers)) { return(null); } return(Initialize <LayerSettingsViewModel>("LayerSettings_Edit", model => { model.Zones = String.Join(", ", settings.Zones); }).Location("Content:3").OnGroup(GroupId)); }
public override async Task <IDisplayResult> UpdateAsync(UserProfile profile, IUpdateModel updater, BuildEditorContext context) { var model = new EditUserProfileViewModel(); if (await context.Updater.TryUpdateModelAsync(model, Prefix)) { profile.Age = model.Age; profile.Name = model.Name; } return(Edit(profile)); }
Task <IDisplayResult> IContentPartDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, BuildEditorContext context) { var buildEditorContext = new BuildPartEditorContext(typePartDefinition, context); return(EditAsync(contentPart, buildEditorContext)); }
public override async Task <IDisplayResult> UpdateAsync(GCCollabAuthenticationSettings settings, BuildEditorContext context) { if (context.GroupId == GCCollabConstants.Features.GCCollabAuthentication) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageGCCollabAuthentication)) { return(null); } var model = new GCCollabAuthenticationSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); if (context.Updater.ModelState.IsValid) { var protector = _dataProtectionProvider.CreateProtector(GCCollabConstants.Features.GCCollabAuthentication); settings.ClientID = model.ClientID; settings.ClientSecret = protector.Protect(model.ClientSecret); settings.CallbackPath = model.CallbackUrl; await _shellHost.ReloadShellContextAsync(_shellSettings); } } return(await EditAsync(settings, context)); }
public override async Task <IDisplayResult> EditAsync(GCCollabAuthenticationSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageGCCollabAuthentication)) { return(null); } return(Initialize <GCCollabAuthenticationSettingsViewModel>("GCCollabAuthenticationSettings_Edit", model => { model.ClientID = settings.ClientID; if (!string.IsNullOrWhiteSpace(settings.ClientSecret)) { var protector = _dataProtectionProvider.CreateProtector(GCCollabConstants.Features.GCCollabAuthentication); model.ClientSecret = protector.Unprotect(settings.ClientSecret); } else { model.ClientSecret = string.Empty; } if (settings.CallbackPath.HasValue) { model.CallbackUrl = settings.CallbackPath.Value; } }).Location("Content:5").OnGroup(GCCollabConstants.Features.GCCollabAuthentication)); }
public override async Task <IDisplayResult> EditAsync(AdminSearchSettings section, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageAdminSearchSettings)) { return(null); } return(Initialize <AdminSearchSettingsViewModel>("AdminSearchSettings_Edit", async model => { model.AdminSearchIndex = section.AdminSearchIndex; model.AdminSearchFields = String.Join(", ", section.AdminSearchFields ?? new string[0]); // model.SearchIndexes = _luceneIndexProvider .List(); model.SearchIndexes = (await _luceneIndexSettingsService.GetSettingsAsync()).Select(x => x.IndexName); }).Location("Content:2").OnGroup(GroupId)); }
Task <IDisplayResult> IContentFieldDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentPartFieldDefinition partFieldDefinition, ContentTypePartDefinition typePartDefinition, BuildEditorContext context) { if (!string.Equals(typeof(TField).Name, partFieldDefinition.FieldDefinition.Name) && !string.Equals(nameof(ContentField), partFieldDefinition.FieldDefinition.Name)) { return(Task.FromResult(default(IDisplayResult))); } var field = contentPart.GetOrCreate <TField>(partFieldDefinition.Name); if (field != null) { BuildPrefix(typePartDefinition, partFieldDefinition, context.HtmlFieldPrefix); var fieldEditorContext = new BuildFieldEditorContext(contentPart, typePartDefinition, partFieldDefinition, context); _typePartDefinition = typePartDefinition; _partFieldDefinition = partFieldDefinition; var result = EditAsync(field, fieldEditorContext); _typePartDefinition = null; _partFieldDefinition = null; return(result); } return(Task.FromResult(default(IDisplayResult))); }
public override async Task <IDisplayResult> UpdateAsync(AdminSearchSettings section, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageAdminSearchSettings)) { return(null); } if (context.GroupId == GroupId) { var model = new AdminSearchSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); section.AdminSearchIndex = model.AdminSearchIndex; section.AdminSearchFields = model.AdminSearchFields?.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); } return(await EditAsync(section, context)); }
public override async Task <IDisplayResult> UpdateAsync(MatomoSettings settings, BuildEditorContext context) { if (context.GroupId == MatomoConstants.Features.Matomo) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, MatomoPermissions.ManageMatomoSettings)) { return(null); } var model = new MatomoSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); if (model.ServerUri.StartsWith("http://") || model.ServerUri.StartsWith("https://") || model.ServerUri.StartsWith("://") || !Uri.IsWellFormedUriString(model.ServerUri, UriKind.RelativeOrAbsolute)) { context.Updater.ModelState.AddModelError(Prefix, S["Please enter a valid server url."]); } if (context.Updater.ModelState.IsValid) { settings.SiteID = model.SiteID; // remove trailing / as it's added when injecting the script settings.ServerUri = model.ServerUri.TrimEnd('/'); } } return(await EditAsync(settings, context)); }
/// <inheritdocs /> public override async Task <IDisplayResult> EditAsync(LocalizationSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (!await _authorizationService.AuthorizeAsync(user, Permissions.ManageCultures)) { return(null); } return(Initialize <LocalizationSettingsViewModel>("LocalizationSettings_Edit", model => { model.Cultures = CultureInfo.GetCultures(CultureTypes.AllCultures) .Select(cultureInfo => { return new CultureEntry { Supported = settings.SupportedCultures.Contains(cultureInfo.Name, StringComparer.OrdinalIgnoreCase), CultureInfo = cultureInfo, IsDefault = String.Equals(settings.DefaultCulture, cultureInfo.Name, StringComparison.OrdinalIgnoreCase) }; }).ToArray(); if (!model.Cultures.Any(x => x.IsDefault)) { model.Cultures[0].IsDefault = true; } }).Location("Content:2").OnGroup(GroupId)); }
/// <inheritdocs /> public override async Task <IDisplayResult> UpdateAsync(LocalizationSettings section, BuildEditorContext context) { if (context.GroupId == GroupId) { var model = new LocalizationSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); var supportedCulture = JsonConvert.DeserializeObject <string[]>(model.SupportedCultures); if (!supportedCulture.Any()) { context.Updater.ModelState.AddModelError("SupportedCultures", S["A culture is required"]); } if (context.Updater.ModelState.IsValid) { // Invariant culture name is empty so a null value is bound. section.DefaultCulture = model.DefaultCulture ?? ""; section.SupportedCultures = supportedCulture; if (!section.SupportedCultures.Contains(section.DefaultCulture)) { section.DefaultCulture = section.SupportedCultures[0]; } // We always release the tenant for the default culture and also supported cultures to take effect await _shellHost.ReleaseShellContextAsync(_shellSettings); _notifier.Warning(H["The site has been restarted for the settings to take effect"]); } } return(await EditAsync(section, context)); }
Task <IDisplayResult> IContentFieldDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentPartFieldDefinition partFieldDefinition, ContentTypePartDefinition typePartDefinition, BuildEditorContext context) { if (!string.Equals(typeof(TField).Name, partFieldDefinition.FieldDefinition.Name) && !string.Equals(nameof(ContentField), partFieldDefinition.FieldDefinition.Name)) { return(Task.FromResult(default(IDisplayResult))); } var field = contentPart.GetOrCreate <TField>(partFieldDefinition.Name); Prefix = typePartDefinition.Name + "." + partFieldDefinition.Name; var fieldEditorContext = new BuildFieldEditorContext(contentPart, typePartDefinition, partFieldDefinition, context); return(EditAsync(field, fieldEditorContext)); }
public virtual void BuildEditor(BuildEditorContext context) { }
public override async Task <IDisplayResult> EditAsync(TwitterSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageTwitterSignin)) { return(null); } return(Initialize <TwitterSettingsViewModel>("TwitterSettings_Edit", model => { model.APIKey = settings.ConsumerKey; if (!string.IsNullOrWhiteSpace(settings.ConsumerSecret)) { var protector = _dataProtectionProvider.CreateProtector(TwitterConstants.Features.Twitter); model.APISecretKey = protector.Unprotect(settings.ConsumerSecret); } else { model.APISecretKey = string.Empty; } model.AccessToken = settings.AccessToken; if (!string.IsNullOrWhiteSpace(settings.AccessTokenSecret)) { var protector = _dataProtectionProvider.CreateProtector(TwitterConstants.Features.Twitter); model.AccessTokenSecret = protector.Unprotect(settings.AccessTokenSecret); } else { model.AccessTokenSecret = string.Empty; } }).Location("Content:5").OnGroup(TwitterConstants.Features.Twitter)); }
public BuildFieldEditorContext(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, ContentPartFieldDefinition partFieldDefinition, BuildEditorContext context) : base(context.Shape, context.GroupId, context.ShapeFactory, context.Layout, context.Updater) { ContentPart = contentPart; TypePartDefinition = typePartDefinition; PartFieldDefinition = partFieldDefinition; }
public override async Task <IDisplayResult> UpdateAsync(TwitterSettings settings, BuildEditorContext context) { if (context.GroupId == TwitterConstants.Features.Twitter) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageTwitter)) { return(null); } var model = new TwitterSettingsViewModel(); await context.Updater.TryUpdateModelAsync(model, Prefix); if (context.Updater.ModelState.IsValid) { var protector = _dataProtectionProvider.CreateProtector(TwitterConstants.Features.Twitter); settings.ConsumerKey = model.APIKey; settings.ConsumerSecret = protector.Protect(model.APISecretKey); settings.AccessToken = model.AccessToken; settings.AccessTokenSecret = protector.Protect(model.AccessTokenSecret); await _shellHost.ReloadShellContextAsync(_shellSettings); } } return(await EditAsync(settings, context)); }
public override async Task <IDisplayResult> EditAsync(HttpsSettings settings, BuildEditorContext context) { var user = _httpContextAccessor.HttpContext?.User; if (user == null || !await _authorizationService.AuthorizeAsync(user, Permissions.ManageHttps)) { return(null); } return(Initialize <HttpsSettingsViewModel>("HttpsSettings_Edit", model => { var isHttpsRequest = _httpContextAccessor.HttpContext.Request.IsHttps; if (!isHttpsRequest) { _notifier.Warning(T["For safety, Enabling require HTTPS over HTTP has been prevented."]); } model.EnableStrictTransportSecurity = settings.EnableStrictTransportSecurity; model.IsHttpsRequest = isHttpsRequest; model.RequireHttps = settings.RequireHttps; model.RequireHttpsPermanent = settings.RequireHttpsPermanent; model.SslPort = settings.SslPort ?? (isHttpsRequest && !settings.RequireHttps ? _httpContextAccessor.HttpContext.Request.Host.Port : null); }).Location("Content:2").OnGroup(SettingsGroupId)); }
async Task <IDisplayResult> IContentPartDisplayDriver.BuildEditorAsync(ContentPart contentPart, ContentTypePartDefinition typePartDefinition, BuildEditorContext context) { var part = contentPart as TPart; if (part == null) { return(null); } BuildPrefix(typePartDefinition, context.HtmlFieldPrefix); _typePartDefinition = typePartDefinition; var buildEditorContext = new BuildPartEditorContext(typePartDefinition, context); var result = await EditAsync(part, buildEditorContext); _typePartDefinition = null; return(result); }
public override async Task <IDisplayResult> UpdateAsync(RegistrationSettings section, BuildEditorContext context) { if (context.GroupId == GroupId) { await context.Updater.TryUpdateModelAsync(section, Prefix); } return(await EditAsync(section, context)); }
public override void Apply(BuildEditorContext context) { }
public virtual void BuildEditor(BuildEditorContext context) {}
public async Task BuildPartFieldEditorAsync(ContentPartFieldDefinition model, BuildEditorContext context) { await _partFieldDisplayDrivers.InvokeAsync(async contentDisplay => { var result = await contentDisplay.BuildEditorAsync(model, context); if (result != null) { await result.ApplyAsync(context); } }, Logger); }