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);
}
