public async Task GetAllSeiyuuRolesAsync_GivenMultipleRoles_ShouldReturnMultiple()
{
// Given
var seiyuuId = Guid.NewGuid();
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new SeiyuuRoleRepository(dbContext);
var japanese = new LanguageBuilder().WithLanguageId(LanguageId.Japanese).Build();
var seiyuu = new SeiyuuBuilder().WithId(seiyuuId).Build();
seiyuu.Role = new List <AnimeRole>
{
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
};
await dbContext.AddAsync(seiyuu);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAllSeiyuuRolesAsync(seiyuuId, false);
// Then
result.Should().HaveCount(5);
}
public void UpdateTranslate_should_update_translate()
{
var dto = TranslateFakeData.GetFakedUpdatedTranslate();
var translate = Substitute.For <Translator>();
var repository = Substitute.For <ITranslationRepository>();
repository.GetById(dto.Id).Returns(translate);
var sut = new TranslationService(repository);
sut.ModifyTranslate(dto);
var language = new LanguageBuilder().WithAbbrevation(dto.LanguageAbbr).Build();
var phraseType = new PhraseTypeBuilder().WithName(dto.PhraseType).Build();
var phrase = new PhraseBuilder().WithId(dto.PhraseId).WithPhraseType(phraseType).Build();
var translations = new List <Domain.Entities.Translation>()
{
new Domain.Entities.Translation(language, dto.Translation)
};
var expectedTranslate = new TranslateBuilder()
.WithId(dto.Id)
.WithPhrase(phrase)
.WithTranslations(translations).Build();
translate.Received().Update(phrase, translations);
}
public void MergeTest()
{
var expectedBuilder = new LanguageBuilder();
expectedBuilder.AddLanguage(new LanguageModel("py", "file1.py"));
expectedBuilder.AddLanguage(new LanguageModel("py", "file2.py"));
expectedBuilder.AddLanguage(new LanguageModel("cs", "file1.cs"));
expectedBuilder.AddLanguage(new LanguageModel("java", "file1.java"));
var builder1 = new LanguageBuilder();
builder1.AddLanguage(new LanguageModel("py", "file1.py"));
builder1.AddLanguage(new LanguageModel("py", "file2.py"));
var builder2 = new LanguageBuilder();
builder2.AddLanguage(new LanguageModel("cs", "file1.cs"));
builder2.AddLanguage(new LanguageModel("java", "file1.java"));
var resultMerge = builder1.Merge(builder2);
var builderMerge = (LanguageBuilder)resultMerge;
Assert.AreEqual(expectedBuilder.LanguageAttributes["Phyton"].Count, builderMerge.LanguageAttributes["Phyton"].Count);
Assert.AreEqual(expectedBuilder.LanguageAttributes["Java"].File[0], builderMerge.LanguageAttributes["Java"].File[0]);
Assert.AreEqual(expectedBuilder.LanguageAttributes["C#"].File[0], builderMerge.LanguageAttributes["C#"].File[0]);
}
public async Task GetAllSeiyuuRolesByMalIdAsync_GivenSeiyuuWithMultipleRolesAndMainRolesOnly_ShouldReturnPartial()
{
// Given
const int seiyuuMalId = 1;
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new SeiyuuRoleRepository(dbContext);
var japanese = new LanguageBuilder().WithLanguageId(LanguageId.Japanese).Build();
var seiyuu = new SeiyuuBuilder().WithMalId(seiyuuMalId).Build();
var mainRole = new AnimeRoleTypeBuilder().WithId(AnimeRoleTypeId.Main).Build();
var supportingRole = new AnimeRoleTypeBuilder().WithId(AnimeRoleTypeId.Supporting).Build();
seiyuu.Role = new List <AnimeRole>
{
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(mainRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(mainRole).Build()
};
await dbContext.AddAsync(seiyuu);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAllSeiyuuRolesByMalIdAsync(seiyuuMalId, true);
// Then
result.Should().HaveCount(2);
}
public void Can_Export_Languages()
{
// Arrange
ILocalizationService localizationService = GetRequiredService <ILocalizationService>();
ILanguage languageNbNo = new LanguageBuilder()
.WithCultureInfo("nb-NO")
.WithCultureName("Norwegian")
.Build();
localizationService.Save(languageNbNo);
ILanguage languageEnGb = new LanguageBuilder()
.WithCultureInfo("en-GB")
.Build();
localizationService.Save(languageEnGb);
var newPackageXml = XElement.Parse(ImportResources.Dictionary_Package);
XElement languageItemsElement = newPackageXml.Elements("Languages").First();
// Act
XElement xml = Serializer.Serialize(new[] { languageNbNo, languageEnGb });
// Assert
Assert.That(xml.ToString(), Is.EqualTo(languageItemsElement.ToString()));
}
public void Set_Default_Language()
{
ILanguage languageEnAu = new LanguageBuilder()
.WithCultureInfo("en-AU")
.WithIsDefault(true)
.Build();
LocalizationService.Save(languageEnAu);
ILanguage result = LocalizationService.GetLanguageById(languageEnAu.Id);
Assert.IsTrue(result.IsDefault);
ILanguage languageEnNz = new LanguageBuilder()
.WithCultureInfo("en-NZ")
.WithIsDefault(true)
.Build();
LocalizationService.Save(languageEnNz);
ILanguage result2 = LocalizationService.GetLanguageById(languageEnNz.Id);
// re-get
result = LocalizationService.GetLanguageById(languageEnAu.Id);
Assert.IsTrue(result2.IsDefault);
Assert.IsFalse(result.IsDefault);
}
public async Task GetAllRolesInSeason_GivenSeasonWithSingleAnimeWithMultipleRoles_ShouldReturnMultiple()
{
// Given
var animeId = Guid.NewGuid();
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new SeasonRoleRepository(dbContext);
var japanese = new LanguageBuilder().WithLanguageId(LanguageId.Japanese).Build();
var anime = new AnimeBuilder().WithId(animeId).Build();
anime.Role = new List <AnimeRole>
{
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).Build(),
};
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAllRolesInSeason(new List <Guid> {
animeId
}, false);
// Then
result.Should().HaveCount(5);
}
public void TagsCanBecomeInvariantByPropertyTypeAndBackToVariant()
{
ILanguage language = new LanguageBuilder()
.WithCultureInfo("fr-FR")
.Build();
LocalizationService.Save(language); // en-US is already there
Template template = TemplateBuilder.CreateTextPageTemplate();
FileService.SaveTemplate(template);
ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", mandatoryProperties: true, defaultTemplateId: template.Id);
PropertyType propertyType = CreateAndAddTagsPropertyType(contentType, ContentVariation.Culture);
ContentTypeService.Save(contentType);
IContent content1 = ContentBuilder.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.SetCultureName("name-fr", "fr-FR");
content1.SetCultureName("name-en", "en-US");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags", new[] { "hello", "world", "some", "tags", "plus" }, culture: "fr-FR");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags", new[] { "hello", "world", "another", "one" }, culture: "en-US");
ContentService.SaveAndPublish(content1);
propertyType.Variations = ContentVariation.Nothing;
ContentTypeService.Save(contentType);
// FIXME: This throws due to index violations
propertyType.Variations = ContentVariation.Culture;
ContentTypeService.Save(contentType);
// TODO: Assert results
}
private void BuildLanguage(Dictionary <string, LanguageTable> tables, bool build)
{
string allLanguages = ConversionUtil.GetConfig(ConfigKey.AllLanguage, ConfigFile.LanguageConfig);
//string languageDirectory = ConversionUtil.GetPath(ConversionUtil.GetConfig(ConfigKey.LanguageDirectory, ConfigFile.LanguageConfig));
string languageDirectory = ConversionUtil.GetPath(textTableFolder.Text);
LanguageBuilder builder = new LanguageBuilder(
allLanguages,
languageDirectory,
ConversionUtil.GetPath(ConversionUtil.GetConfig(ConfigKey.TranslationDirectory, ConfigFile.LanguageConfig)),
tables);
bool success = build ? builder.Build() : builder.RefreshLanguage();
if (success)
{
string[] languages = builder.GetLanguages();
List <string> languageFiles = new List <string>();
foreach (var language in languages)
{
languageFiles.Add(languageDirectory + "/Language_" + language + ".xls");
}
new TableBuilder().Transform(string.Join(";", languageFiles.ToArray()),
textTableConfig.Text,
textBoxPackage.Text,
ConversionUtil.GetConfig(ConfigKey.SpawnList, ConfigFile.InitConfig),
false,
Extends.GetChecked(refreshNote),
ConversionUtil.GetProgramConfig());
}
}
public async Task GetAllRolesInSeason_GivenSeasonWithSingleAnimeWithMultipleRolesAndMainRolesOnly_ShouldReturnPartial()
{
// Given
var animeId = Guid.NewGuid();
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new SeasonRoleRepository(dbContext);
var japanese = new LanguageBuilder().WithLanguageId(LanguageId.Japanese).Build();
var anime = new AnimeBuilder().WithId(animeId).Build();
var mainRole = new AnimeRoleTypeBuilder().WithId(AnimeRoleTypeId.Main).Build();
var supportingRole = new AnimeRoleTypeBuilder().WithId(AnimeRoleTypeId.Supporting).Build();
anime.Role = new List <AnimeRole>
{
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(mainRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(supportingRole).Build(),
new AnimeRoleBuilder().WithLanguage(japanese).WithRoleType(mainRole).Build()
};
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAllRolesInSeason(new List <Guid> {
animeId
}, true);
// Then
result.Should().HaveCount(2);
}
public void TagsCanBeVariant()
{
ILocalizationService languageService = LocalizationService;
ILanguage language = new LanguageBuilder()
.WithCultureInfo("fr-FR")
.Build();
LocalizationService.Save(language); // en-US is already there
Template template = TemplateBuilder.CreateTextPageTemplate();
FileService.SaveTemplate(template);
ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", mandatoryProperties: true, defaultTemplateId: template.Id);
CreateAndAddTagsPropertyType(contentType, ContentVariation.Culture);
ContentTypeService.Save(contentType);
IContent content1 = ContentBuilder.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.SetCultureName("name-fr", "fr-FR");
content1.SetCultureName("name-en", "en-US");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags", new[] { "hello", "world", "some", "tags", "plus" }, culture: "fr-FR");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags", new[] { "hello", "world", "another", "one" }, culture: "en-US");
ContentService.SaveAndPublish(content1);
content1 = ContentService.GetById(content1.Id);
string[] frTags = content1.Properties["tags"].GetTagsValue(PropertyEditorCollection, DataTypeService, Serializer, "fr-FR").ToArray();
Assert.AreEqual(5, frTags.Length);
Assert.Contains("plus", frTags);
Assert.AreEqual(-1, frTags.IndexOf("one"));
string[] enTags = content1.Properties["tags"].GetTagsValue(PropertyEditorCollection, DataTypeService, Serializer, "en-US").ToArray();
Assert.AreEqual(4, enTags.Length);
Assert.Contains("one", enTags);
Assert.AreEqual(-1, enTags.IndexOf("plus"));
IEnumerable <IGrouping <int?, ITag> > tagGroups = TagService.GetAllTags(culture: "*").GroupBy(x => x.LanguageId);
foreach (ITag tag in TagService.GetAllTags())
{
Console.WriteLine($"{tag.Group}:{tag.Text} {tag.LanguageId}");
}
Assert.AreEqual(2, tagGroups.Count());
IGrouping <int?, ITag> frTagGroup = tagGroups.FirstOrDefault(x => x.Key == 2);
Assert.IsNotNull(frTagGroup);
Assert.AreEqual(5, frTagGroup.Count());
Assert.IsTrue(frTagGroup.Any(x => x.Text == "plus"));
Assert.IsFalse(frTagGroup.Any(x => x.Text == "one"));
IGrouping <int?, ITag> enTagGroup = tagGroups.FirstOrDefault(x => x.Key == 1);
Assert.IsNotNull(enTagGroup);
Assert.AreEqual(4, enTagGroup.Count());
Assert.IsTrue(enTagGroup.Any(x => x.Text == "one"));
Assert.IsFalse(enTagGroup.Any(x => x.Text == "plus"));
}
private void OnDestroy()
{
if (lb != null)
{
lb.OnLanguageChange -= UpdateText; // remove event
lb = null;
}
}
public async Task HandleAsync_GivenMultipleCommonSeiyuu_ShouldReturnMultipleResults()
{
// Given
var query = new CompareAnimeQuery {
AnimeMalIds = new List <long> {
1, 2
}
};
var dbContext = InMemoryDbProvider.GetDbContext();
var miyukiSawashiro = new SeiyuuBuilder().WithId(Guid.NewGuid()).WithMalId(1).WithName("Miyuki Sawashiro").Build();
var chiwaSaito = new SeiyuuBuilder().WithId(Guid.NewGuid()).WithMalId(2).WithName("Chiwa Saito").Build();
var onePieceAnime = new AnimeBuilder().WithId(Guid.NewGuid()).WithMalId(1).WithTitle("One Piece").Build();
var bakemonogatariAnime = new AnimeBuilder().WithId(Guid.NewGuid()).WithMalId(2).WithTitle("Bakemonogatari").Build();
var japanese = new LanguageBuilder().WithLanguageId(LanguageId.Japanese).Build();
var animeRoles = new List <AnimeRole>
{
new AnimeRoleBuilder()
.WithAnime(onePieceAnime)
.WithSeiyuu(miyukiSawashiro)
.WithCharacter(x => x.WithId(Guid.NewGuid()).WithMalId(1).WithName("Charlotte Pudding").Build())
.WithLanguage(japanese)
.Build(),
new AnimeRoleBuilder()
.WithAnime(bakemonogatariAnime)
.WithSeiyuu(miyukiSawashiro)
.WithCharacter(x => x.WithId(Guid.NewGuid()).WithMalId(2).WithName("Kanbaru Suruga").Build())
.WithLanguage(japanese)
.Build(),
new AnimeRoleBuilder()
.WithAnime(onePieceAnime)
.WithSeiyuu(chiwaSaito)
.WithCharacter(x => x.WithId(Guid.NewGuid()).WithMalId(1).WithName("Chimney").Build())
.WithLanguage(japanese)
.Build(),
new AnimeRoleBuilder()
.WithAnime(bakemonogatariAnime)
.WithSeiyuu(chiwaSaito)
.WithCharacter(x => x.WithId(Guid.NewGuid()).WithMalId(2).WithName("Hitagi Senjougahara").Build())
.WithLanguage(japanese)
.Build()
};
await dbContext.AddRangeAsync(animeRoles);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext);
// When
var result = await handler.HandleAsync(query);
// Then
result.Should().HaveCount(2);
}
private void sameToolStripMenuItem_Click(object sender, EventArgs e)
{
if (this.languagesContainer_0 != null)
{
if (!string.IsNullOrWhiteSpace(openedloc))
{
LanguageBuilder languageBuilder = new LanguageBuilder();
languageBuilder.Build(this.languagesContainer_0, openedloc);
MessageBox.Show("Languages save has completed.", "Save completed");
}
}
}
public void TransformPathInFolder()
{
var test = "folder1";
var test2 = @".\TesteFolder\Folder";
var model = LanguageBuilder.TransformPathToLanguageModel(test);
Assert.AreEqual("Folder", model.Name);
Assert.AreEqual("folder1", model.File);
model = LanguageBuilder.TransformPathToLanguageModel(test2);
Assert.AreEqual("Folder", model.Name);
Assert.AreEqual("Folder", model.File);
}
public void InvalidLanguageTest()
{
var builder = new LanguageBuilder();
var valid = new LanguageModel("rb", "file1.rb");
builder.AddLanguage(valid);
valid = new LanguageModel("html", "file1.html");
builder.AddLanguage(valid);
Assert.AreEqual(0, builder.LanguageAttributes.Count);
Assert.IsFalse(builder.LanguageAttributes.ContainsKey("Ruby"));
Assert.IsFalse(builder.LanguageAttributes.ContainsKey("HTML"));
}
private void LoadTextAsset()
{
string path = EditorUtility.OpenFilePanel("Open Language Teset", "Assets", "txt");
if (path != "")
{
fileContents = File.ReadAllText(path);
if (LanguageBuilder.LoadedLanguage() != null)
{
formattedContents = LanguageBuilder.LoadedLanguage().Format(fileContents);
}
}
}
public void TagsCanBecomeInvariant2()
{
var language = new LanguageBuilder()
.WithCultureInfo("fr-FR")
.Build();
LocalizationService.Save(language); // en-US is already there
var enId = LocalizationService.GetLanguageIdByIsoCode("en-US").Value;
var template = TemplateBuilder.CreateTextPageTemplate();
FileService.SaveTemplate(template);
var contentType = ContentTypeBuilder.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type",
mandatoryProperties: true, defaultTemplateId: template.Id);
var propertyType = CreateAndAddTagsPropertyType(contentType, ContentVariation.Culture);
ContentTypeService.Save(contentType);
IContent content1 = ContentBuilder.CreateSimpleContent(contentType, "Tagged content 1");
content1.SetCultureName("name-fr", "fr-FR");
content1.SetCultureName("name-en", "en-US");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags",
new[] { "hello", "world", "some", "tags", "plus" }, culture: "fr-FR");
content1.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags",
new[] { "hello", "world", "another", "one" }, culture: "en-US");
ContentService.SaveAndPublish(content1);
IContent content2 = ContentBuilder.CreateSimpleContent(contentType, "Tagged content 2");
content2.SetCultureName("name-fr", "fr-FR");
content2.SetCultureName("name-en", "en-US");
content2.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags",
new[] { "hello", "world", "some", "tags", "plus" }, culture: "fr-FR");
content2.AssignTags(PropertyEditorCollection, DataTypeService, Serializer, "tags",
new[] { "hello", "world", "another", "one" }, culture: "en-US");
ContentService.SaveAndPublish(content2);
//// pretend we already have invariant values
// using (var scope = ScopeProvider.CreateScope())
// {
// scope.Database.Execute("INSERT INTO [cmsTags] ([tag], [group], [languageId]) SELECT DISTINCT [tag], [group], NULL FROM [cmsTags] WHERE [languageId] IS NOT NULL");
// }
// this should work
propertyType.Variations = ContentVariation.Nothing;
Assert.DoesNotThrow(() => ContentTypeService.Save(contentType));
}
public void GetToTranslations_sholud_load_phrases(string typeName, string languageAbbr)
{
var builder = new ToTranslateRequestBuilder();
var type = new PhraseTypeBuilder().WithName(typeName).Build();
var lang = new LanguageBuilder().WithAbbrevation(languageAbbr).Build();;
ToTranslateRequest request = builder.WithPhraseType(type).WithLanguage(lang).Build();
var repository = Substitute.For <ITranslationRepository>();
var sut = new TranslationService(repository);
var fake = new FakeData(request.PhraseType, request.Language);
var translates = sut.GetPhrases(request).Returns(fake.GetPhrases());
Assert.NotEmpty(sut.GetPhrases(request));
}
public void Save_Language_And_GetLanguageById()
{
// Arrange
ILanguage languageEnAu = new LanguageBuilder()
.WithCultureInfo("en-AU")
.Build();
// Act
LocalizationService.Save(languageEnAu);
ILanguage result = LocalizationService.GetLanguageById(languageEnAu.Id);
// Assert
Assert.NotNull(result);
}
public void Save_Language_And_GetLanguageByIsoCode()
{
// Arrange
string isoCode = "en-AU";
ILanguage languageEnAu = new LanguageBuilder()
.WithCultureInfo(isoCode)
.Build();
// Act
LocalizationService.Save(languageEnAu);
ILanguage result = LocalizationService.GetLanguageByIsoCode(isoCode);
// Assert
Assert.NotNull(result);
}
public void GivenLanguageWhenValidatingThenRequiredRelationsMustExist()
{
var builder = new LanguageBuilder(this.Session);
builder.Build();
Assert.IsTrue(this.Session.Derive().HasErrors);
builder.WithIsoCode("XX").Build();
Assert.IsTrue(this.Session.Derive().HasErrors);
builder.WithLocalisedName(new LocalisedTextBuilder(this.Session).WithLocale(new Locales(this.Session).FindBy(Locales.Meta.Name, Locales.EnglishGreatBritainName)).WithText("XXX)").Build());
Assert.IsFalse(this.Session.Derive().HasErrors);
}
public void PointsAddTest()
{
var builder = new LanguageBuilder();
var model = new LanguageModel("cs", "Somehting.cs");
builder.AddLanguage(model);
builder.AddLanguage(model);
model = new LanguageModel("java", "Program.java");
builder.AddLanguage(model);
model = new LanguageModel("py", "program.py");
builder.AddLanguage(model);
Assert.AreEqual(2, builder.LanguageAttributes["C#"].Count);
Assert.AreEqual(1, builder.LanguageAttributes["Java"].Count);
Assert.AreEqual(1, builder.LanguageAttributes["Phyton"].Count);
}
public void Is_Built_Correctly()
{
// Arrange
var builder = new LanguageBuilder();
var expected = CultureInfo.GetCultureInfo("en-GB");
// Act
var language = builder
.WithCultureInfo(expected.Name)
.Build();
// Assert
Assert.AreEqual(expected.Name, language.IsoCode);
Assert.AreEqual(expected.EnglishName, language.CultureName);
}
public void Deleted_Language_Should_Not_Exist()
{
string isoCode = "en-AU";
ILanguage languageEnAu = new LanguageBuilder()
.WithCultureInfo(isoCode)
.Build();
LocalizationService.Save(languageEnAu);
// Act
LocalizationService.Delete(languageEnAu);
ILanguage result = LocalizationService.GetLanguageByIsoCode(isoCode);
// Assert
Assert.Null(result);
}
public void GivenLanguageWhenValidatingThenRequiredRelationsMustExist()
{
var builder = new LanguageBuilder(this.Session);
builder.Build();
Assert.True(this.Session.Derive(false).HasErrors);
builder.WithIsoCode("XX").Build();
Assert.True(this.Session.Derive(false).HasErrors);
builder.WithLocalisedName(new LocalisedTextBuilder(this.Session).WithLocale(new Locales(this.Session).FindBy(M.Locale.Name, Locales.EnglishGreatBritainName)).WithText("XXX)").Build());
Assert.False(this.Session.Derive(false).HasErrors);
}
public void Can_Delete_Language()
{
ILanguage languageNbNo = new LanguageBuilder()
.WithCultureInfo("nb-NO")
.Build();
LocalizationService.Save(languageNbNo, 0);
Assert.That(languageNbNo.HasIdentity, Is.True);
int languageId = languageNbNo.Id;
LocalizationService.Delete(languageNbNo);
ILanguage language = LocalizationService.GetLanguageById(languageId);
Assert.Null(language);
}
public void ValidLanguageTests()
{
var builder = new LanguageBuilder();
var valid = new LanguageModel("cs", "file1.cs");
builder.AddLanguage(valid);
valid = new LanguageModel("java", "file1.java");
builder.AddLanguage(valid);
valid = new LanguageModel("js", "file1.js");
builder.AddLanguage(valid);
Assert.AreEqual(3, builder.LanguageAttributes.Count);
Assert.IsTrue(builder.LanguageAttributes.ContainsKey("JavaScript"));
Assert.IsTrue(builder.LanguageAttributes.ContainsKey("C#"));
Assert.IsTrue(builder.LanguageAttributes.ContainsKey("Java"));
}
public void Can_Delete_Language_Used_As_Fallback()
{
ILanguage languageDaDk = LocalizationService.GetLanguageByIsoCode("da-DK");
ILanguage languageNbNo = new LanguageBuilder()
.WithCultureInfo("nb-NO")
.WithFallbackLanguageId(languageDaDk.Id)
.Build();
LocalizationService.Save(languageNbNo, 0);
int languageId = languageDaDk.Id;
LocalizationService.Delete(languageDaDk);
ILanguage language = LocalizationService.GetLanguageById(languageId);
Assert.Null(language);
}
public void lvlUpTest()
{
var builder = new LanguageBuilder();
var languageModel = new LanguageModel("cs", "file1.cs");
var lang = new SimpleLanguage(languageModel);
languageModel = new LanguageModel("cs", "file.cs");
lang.Add(languageModel);
languageModel = new LanguageModel("cs", "file23.cs");
lang.Add(languageModel);
builder.LanguageAttributes.Add("cs", lang);
var expLang = new LanguageExperience("Teste", @".\Contents\Level\lvlUpTest.prop", "Language Points");
expLang.AddModel(builder);
Assert.AreEqual(2, expLang.Level);
Assert.AreEqual(3, expLang.ExperiencePoints);
Assert.AreEqual("Teste", expLang.Name);
}
private void CreateDictionaryData()
{
var localizationService = GetRequiredService <ILocalizationService>();
var languageNbNo = new LanguageBuilder()
.WithCultureInfo("nb-NO")
.WithCultureName("Norwegian")
.Build();
localizationService.Save(languageNbNo);
var languageEnGb = new LanguageBuilder()
.WithCultureInfo("en-GB")
.Build();
localizationService.Save(languageEnGb);
var parentItem = new DictionaryItem("Parent")
{
Key = Guid.Parse("28f2e02a-8c66-4fcd-85e3-8524d551c0d3")
};
var parentTranslations = new List <IDictionaryTranslation>
{
new DictionaryTranslation(languageNbNo, "ForelderVerdi"),
new DictionaryTranslation(languageEnGb, "ParentValue")
};
parentItem.Translations = parentTranslations;
localizationService.Save(parentItem);
var childItem =
new DictionaryItem(parentItem.Key, "Child")
{
Key = Guid.Parse("e7dba0a9-d517-4ba4-8e18-2764d392c611")
};
var childTranslations = new List <IDictionaryTranslation>
{
new DictionaryTranslation(languageNbNo, "BarnVerdi"),
new DictionaryTranslation(languageEnGb, "ChildValue")
};
childItem.Translations = childTranslations;
localizationService.Save(childItem);
}
public void TransformPathInLanguageModel()
{
var test1 = @"C:\folder\file.cs";
var test2 = @"..\folder\file2.java";
var test3 = @"arquivo.cs";
var model = LanguageBuilder.TransformPathToLanguageModel(test1);
Assert.AreEqual("cs", model.Name);
Assert.AreEqual("file.cs", model.File);
model = LanguageBuilder.TransformPathToLanguageModel(test2);
Assert.AreEqual("java", model.Name);
Assert.AreEqual("file2.java", model.File);
model = LanguageBuilder.TransformPathToLanguageModel(test3);
Assert.AreEqual("cs", model.Name);
Assert.AreEqual("arquivo.cs", model.File);
}
public void Sync()
{
var englishNameByCountry = new Dictionary<Country, string>();
var englishNameByCurrency = new Dictionary<Currency, string>();
var englishNameByLanguage = new Dictionary<Language, string>();
var countryByIsoCode = new Dictionary<string, Country>();
foreach (Country country in new Countries(this.Session).Extent())
{
countryByIsoCode.Add(country.IsoCode, country);
}
var languageByIsoCode = new Dictionary<string, Language>();
foreach (Language language in new Languages(this.Session).Extent())
{
languageByIsoCode.Add(language.IsoCode, language);
}
var currencyByIsoCode = new Dictionary<string, Currency>();
foreach (Currency currency in new Currencies(this.Session).Extent())
{
currencyByIsoCode.Add(currency.IsoCode, currency);
}
var localeByName = new Dictionary<string, Locale>();
foreach (Locale locale in new Locales(this.Session).Extent())
{
localeByName.Add(locale.Name, locale);
}
foreach (var cultureInfo in CultureInfo.GetCultures(CultureTypes.SpecificCultures))
{
if (cultureInfo.LCID != 127)
{
var languageIsoCode = cultureInfo.TwoLetterISOLanguageName.ToLower();
Language language;
if (!languageByIsoCode.TryGetValue(languageIsoCode, out language))
{
language = new LanguageBuilder(this.Session)
.WithIsoCode(languageIsoCode)
.Build();
languageByIsoCode.Add(languageIsoCode, language);
englishNameByLanguage.Add(language, cultureInfo.Parent.EnglishName);
}
Country country = null;
var regionInfo = new RegionInfo(cultureInfo.LCID);
// Should be upper, but just in case ...
var countryIsoCode = regionInfo.TwoLetterISORegionName.ToUpper();
// sometimes a 2 letter code is a 3 digit code ...
if (countryIsoCode.Length == 2)
{
if (!countryByIsoCode.TryGetValue(countryIsoCode, out country))
{
country = new CountryBuilder(this.Session).WithIsoCode(countryIsoCode).Build();
englishNameByCountry.Add(country, regionInfo.EnglishName);
countryByIsoCode.Add(countryIsoCode, country);
}
var currencyIsoCode = regionInfo.ISOCurrencySymbol.ToUpper();
Currency currency;
if (!currencyByIsoCode.TryGetValue(currencyIsoCode, out currency))
{
currency = new CurrencyBuilder(this.Session).WithIsoCode(currencyIsoCode).WithSymbol(regionInfo.CurrencySymbol).Build();
currencyByIsoCode.Add(currencyIsoCode, currency);
englishNameByCurrency.Add(currency, regionInfo.CurrencyEnglishName);
}
if (country != null)
{
country.Currency = currency;
}
}
var localeIdentifier = cultureInfo.Name;
Locale locale;
if (!localeByName.TryGetValue(localeIdentifier, out locale))
{
if (country != null && language != null)
{
locale = new LocaleBuilder(this.Session)
.WithName(cultureInfo.Name)
.WithCountry(country)
.WithLanguage(language)
.Build();
localeByName.Add(localeIdentifier, locale);
}
}
else
{
locale.Name = cultureInfo.Name;
locale.Language = language;
locale.Country = country;
}
}
}
var englishLocale = localeByName[EnglishGreatBritainName];
foreach (var country in countryByIsoCode.Values)
{
if (englishNameByCountry.ContainsKey(country))
{
var enlgishName = englishNameByCountry[country];
var englishCountryName = new LocalisedTextBuilder(this.Session)
.WithText(enlgishName)
.WithLocale(englishLocale)
.Build();
country.Name = enlgishName;
country.AddLocalisedName(englishCountryName);
}
}
foreach (var currency in currencyByIsoCode.Values)
{
if (englishNameByCurrency.ContainsKey(currency))
{
var englishName = englishNameByCurrency[currency];
var englishCurrencyName = new LocalisedTextBuilder(this.Session)
.WithText(englishName)
.WithLocale(englishLocale)
.Build();
currency.Name = englishName;
currency.AddLocalisedName(englishCurrencyName);
}
}
foreach (var language in languageByIsoCode.Values)
{
if (englishNameByLanguage.ContainsKey(language))
{
var englishName = englishNameByLanguage[language];
var englishLanguageName = new LocalisedTextBuilder(this.Session)
.WithText(englishName)
.WithLocale(englishLocale)
.Build();
language.Name = englishName;
language.AddLocalisedName(englishLanguageName);
}
}
}
