public static void CanUpdate(LanguagesConfig languages, UpdateLanguage command)
{
Guard.NotNull(command, nameof(command));
var languageConfig = GetLanguageConfigOrThrow(languages, command.Language);
Validate.It(() => "Cannot update language.", error =>
{
if (command.Language == null)
{
error(new ValidationError("Language cannot be null.", nameof(command.Language)));
}
if ((languages.Master == languageConfig || command.IsMaster) && command.IsOptional)
{
error(new ValidationError("Cannot make master language optional.", nameof(command.IsMaster)));
}
if (command.Fallback != null)
{
foreach (var fallback in command.Fallback)
{
if (!languages.Contains(fallback))
{
error(new ValidationError($"Config does not contain fallback language {fallback}.", nameof(command.Fallback)));
}
}
}
});
}
public void CanUpdateLanguage_should_throw_exception_if_language_is_null()
{
var command = new UpdateLanguage();
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages, command),
new ValidationError("Language code is required.", "Language"));
}
public static void CanUpdate(LanguagesConfig languages, UpdateLanguage command)
{
Guard.NotNull(command, nameof(command));
var config = GetConfigOrThrow(languages, command.Language);
Validate.It(() => "Cannot update language.", e =>
{
if (command.Language == null)
{
e("Language is required.", nameof(command.Language));
}
if ((languages.Master == config || command.IsMaster) && command.IsOptional)
{
e("Master language cannot be made optional.", nameof(command.IsMaster));
}
if (command.Fallback == null)
{
return;
}
foreach (var fallback in command.Fallback)
{
if (!languages.Contains(fallback))
{
e($"App does not have fallback language '{fallback}'.", nameof(command.Fallback));
}
}
});
}
public async Task UpdateLanguage_should_create_events_and_update_state()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new List <Language> {
Language.EN
}
};
await ExecuteCreateAsync();
await ExecuteAddLanguageAsync(Language.DE);
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(sut.Snapshot);
Assert.True(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppLanguageUpdated {
Language = Language.DE, Fallback = new List <Language> {
Language.EN
}
})
);
}
public void Enable(IEnumerable <CultureInfo> cultures)
{
foreach (var culture in cultures)
{
var command = new UpdateLanguage(culture, true);
command.Execute();
}
}
public void CanUpdateLanguage_should_not_throw_exception_if_language_is_valid()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new[] { Language.EN }
};
GuardAppLanguages.CanUpdate(languages, command);
}
public void CanUpdateLanguage_should_throw_exception_if_not_found()
{
var command = new UpdateLanguage {
Language = Language.IT
};
Assert.Throws <DomainObjectNotFoundException>(() => GuardAppLanguages.CanUpdate(languages, command));
}
public AppDomainObject UpdateLanguage(UpdateLanguage command)
{
ThrowIfNotCreated();
RaiseEvent(SimpleMapper.Map(command, new AppLanguageUpdated()));
return(this);
}
public void CanUpdateLanguage_should_throw_exception_if_language_is_null()
{
var command = new UpdateLanguage();
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
Assert.Throws <ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command));
}
public void CanUpdateLanguage_should_throw_exception_if_language_has_invalid_fallback()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new[] { Language.IT }
};
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages, command),
new ValidationError("App does not have fallback language 'Italian'.", "Fallback"));
}
public void CanUpdateLanguage_should_throw_exception_if_fallback_language_defined_and_master()
{
var command = new UpdateLanguage {
Language = Language.EN, Fallback = new[] { Language.DE }
};
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages, command),
new ValidationError("Master language cannot have fallback languages.", "Fallback"));
}
public void CanUpdateLanguage_should_throw_exception_if_language_is_optional_and_master()
{
var command = new UpdateLanguage {
Language = Language.EN, IsOptional = true
};
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages, command),
new ValidationError("Master language cannot be made optional.", "IsMaster"));
}
protected Task On(UpdateLanguage command, CommandContext context)
{
return(handler.UpdateSyncedAsync <AppDomainObject>(context, a =>
{
GuardAppLanguages.CanUpdate(a.Snapshot.LanguagesConfig, command);
a.UpdateLanguage(command);
}));
}
public void CanUpdateLanguage_should_throw_exception_if_language_is_null()
{
var command = new UpdateLanguage();
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages_1, command),
new ValidationError("Language is required.", "Language"));
}
public AppDomainObject UpdateLanguage(UpdateLanguage command)
{
Guard.Valid(command, nameof(command), () => "Cannot update language");
ThrowIfNotCreated();
RaiseEvent(SimpleMapper.Map(command, new AppLanguageUpdated()));
return(this);
}
public void CanUpdateLanguage_should_throw_exception_if_language_is_optional_and_master()
{
var command = new UpdateLanguage {
Language = Language.DE, IsOptional = true
};
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
Assert.Throws <ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command));
}
public bool UpdateLanguage(int userID, UpdateLanguage newValue)
{
using (IDbConnection dbConnection = Connection)
{
string languageQuery = "UPDATE tbllanguage SET level = @level WHERE userid = @id AND languageid = @languageid";
int rowsAffected = dbConnection.Execute(languageQuery, new { level = newValue.NewValue, id = userID, languageid = newValue.LanguageID });
return(rowsAffected > 0);
}
}
public void CanUpdateLanguage_should_throw_exception_if_language_has_invalid_fallback()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new List <Language> {
Language.IT
}
};
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
Assert.Throws <ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command));
}
public void CanUpdateLanguage_should_not_throw_exception_if_language_is_valid()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new List <Language> {
Language.EN
}
};
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
GuardAppLanguages.CanUpdate(languages_1, command);
}
public void CanUpdateLanguage_should_throw_exception_if_language_has_invalid_fallback()
{
var command = new UpdateLanguage {
Language = Language.DE, Fallback = new List <Language> {
Language.IT
}
};
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN));
ValidationAssert.Throws(() => GuardAppLanguages.CanUpdate(languages_1, command),
new ValidationError("App does not have fallback language 'Italian'.", "Fallback"));
}
public static void CanUpdate(UpdateLanguage command, IAppEntity app)
{
Guard.NotNull(command, nameof(command));
var languages = app.Languages;
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) || command.IsMaster)
{
if (command.IsOptional)
{
e(T.Get("apps.languages.masterLanguageNotOptional"), nameof(command.IsMaster));
}
if (command.Fallback?.Length > 0)
{
e(T.Get("apps.languages.masterLanguageNoFallbacks"), nameof(command.Fallback));
}
}
if (command.Fallback == null)
{
return;
}
foreach (var fallback in command.Fallback)
{
if (!languages.Contains(fallback))
{
e(T.Get("apps.languages.fallbackNotFound", new { fallback }), nameof(command.Fallback));
}
}
}
});
}
public static void CanUpdate(LanguagesConfig languages, UpdateLanguage command)
{
Guard.NotNull(command);
Validate.It(() => "Cannot update 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) || command.IsMaster)
{
if (command.IsOptional)
{
e("Master language cannot be made optional.", nameof(command.IsMaster));
}
if (command.Fallback?.Count > 0)
{
e("Master language cannot have fallback languages.", nameof(command.Fallback));
}
}
if (command.Fallback == null)
{
return;
}
foreach (var fallback in command.Fallback)
{
if (!languages.Contains(fallback))
{
e($"App does not have fallback language '{fallback}'.", nameof(command.Fallback));
}
}
}
});
}
private void UpdateLanguage(UpdateLanguage command)
{
Raise(command, new AppLanguageUpdated());
}
public async Task <Unit> UpdateLanguageAsync([FromBody] UpdateLanguage updateLanguage)
{
return(await _mediator.Send(updateLanguage));
}
public void UpdateLanguage(UpdateLanguage command)
{
RaiseEvent(SimpleMapper.Map(command, new AppLanguageUpdated()));
}
static Promise updateLanguage(long id)
{
Promise promise = new Promise();
UpdateLanguage request = new UpdateLanguage(new LanguageModel(id, "pl", translations));
builder.Build(request);
while (!request.Process().isDone) { }
if (request.Successful()) {
promise.Resolve();
}
else {
promise.Reject(new Exception(request.GetErrorMessage()));
}
return promise;
}
protected Task On(UpdateLanguage command, CommandContext context)
{
return(handler.UpdateAsync <AppDomainObject>(context, a => a.UpdateLanguage(command)));
}
public void Put(int id, [FromBody] UpdateLanguage newValue)
{
ur.UpdateLanguage(id, newValue);
}
