public static FieldConverter FilterLanguages(LanguagesConfig config, IEnumerable <Language>?languages)
{
if (languages?.Any() != true)
{
return(Noop);
}
var languageSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var language in languages)
{
if (config.Contains(language.Iso2Code))
{
languageSet.Add(language.Iso2Code);
}
}
if (languageSet.Count == 0)
{
languageSet.Add(config.Master);
}
return((data, field) =>
{
if (field.Partitioning.Equals(Partitioning.Language))
{
foreach (var(key, _) in data.ToList())
{
if (!languageSet.Contains(key))
{
data.Remove(key);
}
}
}
return data;
});
}
public static void CanRemove(LanguagesConfig languages, RemoveLanguage command)
{
Guard.NotNull(command, nameof(command));
Validate.It(e =>
{
var language = command.Language;
if (language == null)
{
e(Not.Defined(nameof(command.Language)), nameof(command.Language));
}
else
{
EnsureConfigExists(languages, language);
if (languages.IsMaster(language))
{
e(T.Get("apps.languages.masterLanguageNotRemovable"));
}
}
});
}
public static void CanRemove(LanguagesConfig languages, RemoveLanguage command)
{
Guard.NotNull(command);
Validate.It(() => "Cannot remove language.", e =>
{
var language = command.Language;
if (language == null)
{
e(Not.Defined("Language code"), nameof(command.Language));
}
else
{
EnsureConfigExists(languages, language);
if (languages.IsMaster(language))
{
e("Master language cannot be removed.");
}
}
});
}
public LanguagesConfig ToConfig()
{
var languagesConfig = new LanguageConfig[Languages?.Count ?? 0];
if (Languages != null)
{
var i = 0;
foreach (var config in Languages)
{
languagesConfig[i++] = config.Value.ToConfig(config.Key);
}
}
var result = LanguagesConfig.Build(languagesConfig);
if (Master != null)
{
result.MakeMaster(Master);
}
return(result);
}
public static FieldConverter FilterLanguages(LanguagesConfig languagesConfig, IEnumerable <Language> languages)
{
if (languages == null)
{
return((data, field) => data);
}
var languageCodes =
new HashSet <string>(
languages.Select(x => x.Iso2Code).Where(x => languagesConfig.Contains(x)),
StringComparer.OrdinalIgnoreCase);
if (languageCodes.Count == 0)
{
return((data, field) => data);
}
return((data, field) =>
{
if (field.Partitioning.Equals(Partitioning.Language))
{
var result = new ContentFieldData();
foreach (var languageCode in languageCodes)
{
if (data.TryGetValue(languageCode, out var value))
{
result[languageCode] = value;
}
}
return result;
}
return data;
});
}
public void Should_return_flat_list_when_single_languages_specified()
{
var data =
new NamedContentData()
.AddField("field1",
new ContentFieldData()
.AddValue("de", 1)
.AddValue("en", 2))
.AddField("field2",
new ContentFieldData()
.AddValue("de", null)
.AddValue("en", 4))
.AddField("field3",
new ContentFieldData()
.AddValue("en", 6))
.AddField("field4",
new ContentFieldData()
.AddValue("it", 7));
var fallbackConfig =
LanguagesConfig.Build(
new LanguageConfig(Language.EN),
new LanguageConfig(Language.DE, false, Language.EN));
var output = (Dictionary <string, JToken>)data.ToLanguageModel(fallbackConfig, new List <Language> {
Language.DE
});
var expected = new Dictionary <string, JToken>
{
{ "field1", 1 },
{ "field2", 4 },
{ "field3", 6 }
};
Assert.True(expected.EqualsDictionary(output));
}
/// <summary>
/// Starts the dynamic application
/// </summary>
void DynamicApplication_Startup(object sender, StartupEventArgs e)
{
Settings.Parse(InitParams = NormalizeInitParams(e.InitParams));
ScriptTags = new DynamicScriptTags(LanguagesConfig);
ScriptTags.DownloadHtmlPage(() => {
ScriptTags.FetchScriptTags();
XamlScriptTags.Load();
LanguagesConfig.DownloadLanguages(AppManifest, () => {
ScriptTags.DownloadExternalCode(() => {
Engine = new DynamicEngine();
if (HtmlPage.IsEnabled && Settings.ConsoleEnabled && LanguagesConfig.LanguagesUsed.Count > 0)
{
Console = Repl.Show();
}
LanguageTypeExtensions.Load(Engine.LangConfig);
if (HtmlPage.IsEnabled)
{
ScriptTags.Run(Engine);
}
Engine.Run(Settings.EntryPoint);
});
});
});
}
public static object ToFlatLanguageModel(this NamedContentData content, LanguagesConfig languagesConfig, IReadOnlyCollection <Language>?languagePreferences = null)
{
Guard.NotNull(languagesConfig);
if (languagePreferences == null || languagePreferences.Count == 0)
{
return(content);
}
if (languagePreferences.Count == 1 && languagesConfig.TryGetConfig(languagePreferences.First(), out var languageConfig))
{
languagePreferences = languagePreferences.Union(languageConfig.LanguageFallbacks).ToList();
}
var result = new Dictionary <string, IJsonValue>();
foreach (var fieldValue in content)
{
var fieldData = fieldValue.Value;
if (fieldData != null)
{
foreach (var language in languagePreferences)
{
if (fieldData.TryGetValue(language, out var value) && value.Type != JsonValueType.Null)
{
result[fieldValue.Key] = value;
break;
}
}
}
}
return(result);
}
public void Should_not_throw_exception_if_language_to_remove_is_not_found()
{
var config_0 = LanguagesConfig.Build(Language.DE);
config_0.Remove(Language.EN);
}
public void Should_not_throw_exception_if_language_is_already_master_language()
{
var config_0 = LanguagesConfig.Build(Language.DE);
config_0.MakeMaster(Language.DE);
}
public void Should_throw_exception_if_language_to_make_master_is_not_found()
{
var config_0 = LanguagesConfig.Build(Language.DE);
Assert.Throws <KeyNotFoundException>(() => config_0.MakeMaster(Language.EN));
}
protected void On(AppLanguageAdded @event)
{
languagesConfig = languagesConfig.Add(@event.Language);
}
public static NamedContentData ToApiModel(this NamedContentData content, Schema schema, LanguagesConfig languagesConfig, bool excludeHidden = true, bool checkTypeCompatibility = false)
{
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(languagesConfig, nameof(languagesConfig));
var codeForInvariant = InvariantPartitioning.Instance.Master.Key;
var codeForMasterLanguage = languagesConfig.Master.Language.Iso2Code;
var result = new NamedContentData();
foreach (var fieldValue in content)
{
if (!schema.FieldsByName.TryGetValue(fieldValue.Key, out var field) || (excludeHidden && field.IsHidden))
{
continue;
}
if (checkTypeCompatibility)
{
var isValid = true;
foreach (var value in fieldValue.Value.Values)
{
try
{
if (!value.IsNull())
{
JsonValueConverter.ConvertValue(field, value);
}
}
catch
{
isValid = false;
break;
}
}
if (!isValid)
{
continue;
}
}
var fieldResult = new ContentFieldData();
var fieldValues = fieldValue.Value;
if (field.Partitioning.Equals(Partitioning.Language))
{
foreach (var languageConfig in languagesConfig)
{
var languageCode = languageConfig.Key;
if (fieldValues.TryGetValue(languageCode, out var value))
{
fieldResult.Add(languageCode, value);
}
else if (languageConfig == languagesConfig.Master && fieldValues.TryGetValue(codeForInvariant, out value))
{
fieldResult.Add(languageCode, value);
}
}
}
else
{
if (fieldValues.TryGetValue(codeForInvariant, out var value))
{
fieldResult.Add(codeForInvariant, value);
}
else if (fieldValues.TryGetValue(codeForMasterLanguage, out value))
{
fieldResult.Add(codeForInvariant, value);
}
else if (fieldValues.Count > 0)
{
fieldResult.Add(codeForInvariant, fieldValues.Values.First());
}
}
result.Add(field.Name, fieldResult);
}
return(result);
}
public static void Apply(this LanguagesConfig languagesConfig, AppLanguageAdded @event)
{
languagesConfig.Set(new LanguageConfig(@event.Language));
}
public void Should_make_first_language_to_master()
{
var config_0 = LanguagesConfig.Build(Language.IT);
Assert.Equal(Language.IT, config_0.Master.Language);
}
public static LanguagesConfig Apply(this LanguagesConfig languagesConfig, AppLanguageRemoved @event)
{
return(languagesConfig.Remove(@event.Language));
}
public static LanguagesConfig Apply(this LanguagesConfig languagesConfig, AppLanguageAdded @event)
{
return(languagesConfig.Set(new LanguageConfig(@event.Language)));
}
public void ApplyEvent(IEvent @event)
{
switch (@event)
{
case AppCreated e:
{
Roles = Roles.CreateDefaults(e.Name);
SimpleMapper.Map(e, this);
break;
}
case AppUpdated e:
{
SimpleMapper.Map(e, this);
break;
}
case AppImageUploaded e:
{
Image = e.Image;
break;
}
case AppImageRemoved _:
{
Image = null;
break;
}
case AppPlanChanged e:
{
Plan = AppPlan.Build(e.Actor, e.PlanId);
break;
}
case AppPlanReset _:
{
Plan = null;
break;
}
case AppContributorAssigned e:
{
Contributors = Contributors.Assign(e.ContributorId, e.Role);
break;
}
case AppContributorRemoved e:
{
Contributors = Contributors.Remove(e.ContributorId);
break;
}
case AppClientAttached e:
{
Clients = Clients.Add(e.Id, e.Secret);
break;
}
case AppClientUpdated e:
{
Clients = Clients.Update(e.Id, e.Role);
break;
}
case AppClientRenamed e:
{
Clients = Clients.Rename(e.Id, e.Name);
break;
}
case AppClientRevoked e:
{
Clients = Clients.Revoke(e.Id);
break;
}
case AppWorkflowAdded e:
{
Workflows = Workflows.Add(e.WorkflowId, e.Name);
break;
}
case AppWorkflowUpdated e:
{
Workflows = Workflows.Update(e.WorkflowId, e.Workflow);
break;
}
case AppWorkflowDeleted e:
{
Workflows = Workflows.Remove(e.WorkflowId);
break;
}
case AppPatternAdded e:
{
Patterns = Patterns.Add(e.PatternId, e.Name, e.Pattern, e.Message);
break;
}
case AppPatternDeleted e:
{
Patterns = Patterns.Remove(e.PatternId);
break;
}
case AppPatternUpdated e:
{
Patterns = Patterns.Update(e.PatternId, e.Name, e.Pattern, e.Message);
break;
}
case AppRoleAdded e:
{
Roles = Roles.Add(e.Name);
break;
}
case AppRoleDeleted e:
{
Roles = Roles.Remove(e.Name);
break;
}
case AppRoleUpdated e:
{
Roles = Roles.Update(e.Name, e.Permissions.Prefix(Name));
break;
}
case AppLanguageAdded e:
{
LanguagesConfig = LanguagesConfig.Set(e.Language);
break;
}
case AppLanguageRemoved e:
{
LanguagesConfig = LanguagesConfig.Remove(e.Language);
break;
}
case AppLanguageUpdated e:
{
LanguagesConfig = LanguagesConfig.Set(e.Language, e.IsOptional, e.Fallback);
if (e.IsMaster)
{
LanguagesConfig = LanguagesConfig.MakeMaster(e.Language);
}
break;
}
case AppArchived _:
{
Plan = null;
IsArchived = true;
break;
}
}
}
protected void On(AppLanguageRemoved @event)
{
LanguagesConfig = LanguagesConfig.Remove(@event.Language);
}
protected void On(AppLanguageAdded @event)
{
LanguagesConfig = LanguagesConfig.Set(@event.Language);
}
public override bool ApplyEvent(IEvent @event)
{
switch (@event)
{
case AppCreated e:
{
SimpleMapper.Map(e, this);
return(true);
}
case AppUpdated e when !string.Equals(e.Label, Label) || !string.Equals(e.Description, Description):
{
SimpleMapper.Map(e, this);
return(true);
}
case AppImageUploaded e:
return(UpdateImage(e, ev => ev.Image));
case AppImageRemoved e when Image != null:
return(UpdateImage(e, ev => null));
case AppPlanChanged e when !string.Equals(Plan?.PlanId, e.PlanId):
return(UpdatePlan(e, ev => AppPlan.Build(ev.Actor, ev.PlanId)));
case AppPlanReset e when Plan != null:
return(UpdatePlan(e, ev => null));
case AppContributorAssigned e:
return(UpdateContributors(e, (ev, c) => c.Assign(ev.ContributorId, ev.Role)));
case AppContributorRemoved e:
return(UpdateContributors(e, (ev, c) => c.Remove(ev.ContributorId)));
case AppClientAttached e:
return(UpdateClients(e, (ev, c) => c.Add(ev.Id, ev.Secret)));
case AppClientUpdated e:
return(UpdateClients(e, (ev, c) => c.Update(ev.Id, ev.Role)));
case AppClientRenamed e:
return(UpdateClients(e, (ev, c) => c.Rename(ev.Id, ev.Name)));
case AppClientRevoked e:
return(UpdateClients(e, (ev, c) => c.Revoke(ev.Id)));
case AppWorkflowAdded e:
return(UpdateWorkflows(e, (ev, w) => w.Add(ev.WorkflowId, ev.Name)));
case AppWorkflowUpdated e:
return(UpdateWorkflows(e, (ev, w) => w.Update(ev.WorkflowId, ev.Workflow)));
case AppWorkflowDeleted e:
return(UpdateWorkflows(e, (ev, w) => w.Remove(ev.WorkflowId)));
case AppPatternAdded e:
return(UpdatePatterns(e, (ev, p) => p.Add(ev.PatternId, ev.Name, ev.Pattern, ev.Message)));
case AppPatternDeleted e:
return(UpdatePatterns(e, (ev, p) => p.Remove(ev.PatternId)));
case AppPatternUpdated e:
return(UpdatePatterns(e, (ev, p) => p.Update(ev.PatternId, ev.Name, ev.Pattern, ev.Message)));
case AppRoleAdded e:
return(UpdateRoles(e, (ev, r) => r.Add(ev.Name)));
case AppRoleUpdated e:
return(UpdateRoles(e, (ev, r) => r.Update(ev.Name, ev.Permissions)));
case AppRoleDeleted e:
return(UpdateRoles(e, (ev, r) => r.Remove(ev.Name)));
case AppLanguageAdded e:
return(UpdateLanguages(e, (ev, l) => l.Set(ev.Language)));
case AppLanguageRemoved e:
return(UpdateLanguages(e, (ev, l) => l.Remove(ev.Language)));
case AppLanguageUpdated e:
return(UpdateLanguages(e, (ev, l) =>
{
l = l.Set(ev.Language, ev.IsOptional, ev.Fallback);
if (ev.IsMaster)
{
LanguagesConfig = LanguagesConfig.MakeMaster(ev.Language);
}
return l;
}));
case AppArchived _:
{
Plan = null;
IsArchived = true;
return(true);
}
}
return(false);
}
public void Should_throw_exception_if_language_to_remove_is_master()
{
var config_0 = LanguagesConfig.Build(Language.DE);
Assert.Throws <InvalidOperationException>(() => config_0.Remove(Language.DE));
}
public void Should_throw_exception_if_fallback_language_is_invalid()
{
var config_0 = LanguagesConfig.Build(Language.DE);
Assert.Throws <InvalidOperationException>(() => config_0.Set(new LanguageConfig(Language.DE, false, Language.EN)));
}
protected void On(AppLanguageAdded @event)
{
languagesConfig = languagesConfig.Apply(@event);
}
public static void Apply(this LanguagesConfig languagesConfig, AppLanguageRemoved @event)
{
languagesConfig.Remove(@event.Language);
}
public static JsonObject FormatReferences(this NamedContentData data, Schema schema, LanguagesConfig languages, string separator = ", ")
{
Guard.NotNull(schema);
var result = JsonValue.Object();
foreach (var language in languages)
{
result[language.Key] = JsonValue.Create(data.FormatReferenceFields(schema, language.Key, separator));
}
return(result);
}
public static AppLanguageDto FromLanguage(Language language, LanguageConfig config, LanguagesConfig languages)
{
var result = new AppLanguageDto
{
EnglishName = language.EnglishName,
IsMaster = languages.IsMaster(language),
IsOptional = languages.IsOptional(language),
Iso2Code = language.Iso2Code,
Fallback = config.Fallbacks.ToArray()
};
return(result);
}
public JsonLanguagesConfig(LanguagesConfig value)
{
Languages = value.Languages.ToDictionary(x => x.Key, x => new JsonLanguageConfig(x.Value));
Master = value.Master;
}
public void Should_not_throw_exception_if_language_to_add_already_exists()
{
var config_0 = LanguagesConfig.Build(Language.DE);
config_0.Set(new LanguageConfig(Language.DE));
}
protected void On(AppLanguageUpdated @event)
{
languagesConfig = languagesConfig.Update(@event.Language, @event.IsOptional, @event.IsMaster, @event.Fallback);
}
