public static IEnumerable <Command> GetImmutableCollectionCommands(LanguageDefinition languageDefinition)
{
return(languageDefinition
.Types
.Where(f => f.HasTag(KnownTags.Collection) && f.HasTag(KnownTags.Immutable))
.Select(f => new ImmutableCollectionTypeCommand(f)));
}
protected override void Execute(ExecutionContext context, Snippet snippet)
{
LanguageDefinition language = ((LanguageExecutionContext)context).Language;
if (snippet.HasTag(KnownTags.Array))
{
AddInitializer(context, snippet, language.GetArrayInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue());
}
else if (snippet.HasTag(KnownTags.Dictionary))
{
AddInitializer(context, snippet, language.GetDictionaryInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue());
}
else if (snippet.HasTag(KnownTags.Collection))
{
AddInitializer(context, snippet, language.GetCollectionInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue());
}
else if (snippet.HasTag(KnownTags.Variable))
{
AddInitializer(context, snippet, language.GetVariableInitializer($"${LiteralIdentifiers.Value}$"), language.GetDefaultValue());
}
else
{
AddInitializer(context, snippet, language.GetObjectInitializer($"${LiteralIdentifiers.Value}$"), "x");
}
}
public PageViewModel(
IPageConfiguration pageConfiguration,
LanguageDefinition language,
ContentViewModel contentViewModel,
ContentLinksViewModel contentLinksViewModel)
{
if(pageConfiguration == null)
{
throw new ArgumentNullException(nameof(pageConfiguration));
}
if (contentViewModel == null)
{
throw new ArgumentNullException(nameof(contentViewModel));
}
if(contentLinksViewModel == null)
{
throw new ArgumentNullException(nameof(contentLinksViewModel));
}
_pageConfiguration = pageConfiguration;
Language = language;
ContentViewModel = contentViewModel;
ContentLinksViewModel = contentLinksViewModel;
}
public void GetParameterValue_SentenceFinalPunctuationNR()
{
// Set up the punctuation for a Roman-script vernacular writing system.
int hvoWs = Cache.DefaultVernWs;
ILgWritingSystemFactory lgwsf = Cache.LanguageWritingSystemFactoryAccessor;
IWritingSystem ws = lgwsf.get_EngineOrNull(hvoWs);
LanguageDefinition langDef = new LanguageDefinition(ws);
// We add the following Arabic punctuation: percent sign (066A), decimal separator (066B),
// thousands separator (066C), five pointed star (066D), full stop (06D4), question mark (061F)
langDef.PunctuationPatterns = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
"<PunctuationPatterns>" +
"<pattern value=\"\u066A \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"\u066B \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"\u066C \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"\u066D \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"\u06D4 \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"\u061F \" context=\"WordFinal\" valid=\"true\" /></PunctuationPatterns>";
// Get the sentence-final punctuation
string sentenceFinalPunc = m_dataSource.GetParameterValue("SentenceFinalPunctuation");
// We expect that only sentence-final punctuation would be returned.
Assert.AreEqual("\u06D4\u061F", sentenceFinalPunc);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Finds or creates the writing system.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="icuLocale">The icu locale.</param>
/// <returns>The writing system</returns>
/// ------------------------------------------------------------------------------------
private LgWritingSystem FindOrCreateWs(FdoCache cache, string icuLocale)
{
// Look to see if the writing system already exists in the database
foreach (LgWritingSystem ws in cache.LanguageEncodings)
{
if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale))
{
return(ws);
}
}
// Create a new writing system based on the one noted in the XML file.
// Load it in from the XML and save into the database.
LanguageDefinitionFactory ldf =
new LanguageDefinitionFactory(cache.LanguageWritingSystemFactoryAccessor, icuLocale);
ldf.LanguageDefinition.SaveWritingSystem(icuLocale);
cache.ResetLanguageEncodings();
// search again. It better be there now!
foreach (LgWritingSystem ws in cache.LanguageEncodings)
{
if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale))
{
return(ws);
}
}
Debug.Assert(false);
return(null);
}
public void TestInitializeFromXml_NumericElementClosedTooEarly()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh</WordForming>" +
"<Numeric/>4\uFFFC5" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(4, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("e"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("f"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h"));
Assert.AreEqual(0, validCharsW.NumericCharacters.Count);
Assert.AreEqual(3, validCharsW.OtherCharacters.Count);
Assert.IsTrue(validCharsW.OtherCharacters.Contains(","));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("!"));
Assert.IsTrue(validCharsW.OtherCharacters.Contains("*"));
}
public PageViewModel(
IPageConfiguration pageConfiguration,
LanguageDefinition language,
ContentViewModel contentViewModel,
ContentLinksViewModel contentLinksViewModel)
{
if (pageConfiguration == null)
{
throw new ArgumentNullException(nameof(pageConfiguration));
}
if (contentViewModel == null)
{
throw new ArgumentNullException(nameof(contentViewModel));
}
if (contentLinksViewModel == null)
{
throw new ArgumentNullException(nameof(contentLinksViewModel));
}
_pageConfiguration = pageConfiguration;
Language = language;
ContentViewModel = contentViewModel;
ContentLinksViewModel = contentLinksViewModel;
}
public void SpawnFromDef(LanguageDefinition def)
{
DestroySpawned();
if (def == null)
return;
if (def.Data == null || def.Data.Count == 0)
return;
foreach (var pair in def.Data)
{
var spawn = Instantiate(Prefab, Content);
spawn.NameInput.text = pair.Value.Key.Trim();
spawn.DescriptionInput.text = pair.Value.Desription.Trim();
spawn.Lock.isOn = pair.Value.Locked;
string s = "";
// Make params string.
for (int i = 0; i < pair.Value.Params.Length; i++)
{
string str = pair.Value.Params[i];
string sep = ",\n";
if (i == pair.Value.Params.Length - 1)
sep = "";
s += str + sep;
}
spawn.ParamsInput.text = s;
spawned.Add(spawn);
}
}
public void TestInitializeFromXml_BogusFormat()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>e\uFFFCf\uFFFCg\uFFFCh" +
"</WordForming>" +
"<Numeric>4\uFFFC5" +
"<Other>,\uFFFC!\uFFFC*</Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
VerifyDefaultWordFormingCharacters(validChars);
Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException");
Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system:" +
Environment.NewLine + "\t" + langDef.ValidChars +
Environment.NewLine + "Parameter name: xmlSrc",
e.Message);
}
public static IEnumerable <Command> GetTypeCommands(LanguageDefinition languageDefinition)
{
return(languageDefinition
.Types
.Where(f => !f.HasTag(KnownTags.BasicType))
.Select(f => new TypeCommand(f)));
}
public void GetParameterValue_SentenceFinalPunctuation()
{
// Set up the punctuation for a Roman-script vernacular writing system.
int hvoWs = Cache.DefaultVernWs;
ILgWritingSystemFactory lgwsf = Cache.LanguageWritingSystemFactoryAccessor;
IWritingSystem ws = lgwsf.get_EngineOrNull(hvoWs);
LanguageDefinition langDef = new LanguageDefinition(ws);
// The test writing system has the following characters for punctuation:
// .?!;-)(:
langDef.PunctuationPatterns = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
"<PunctuationPatterns>" +
"<pattern value=\". \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"? \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"! \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"; \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"- \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\") \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\"( \" context=\"WordFinal\" valid=\"true\" />" +
"<pattern value=\": \" context=\"WordFinal\" valid=\"true\" /></PunctuationPatterns>";
// Get the sentence-final punctuation
string sentenceFinalPunc = m_dataSource.GetParameterValue("SentenceFinalPunctuation");
// We expect that only sentence-final punctuation would be returned.
Assert.AreEqual(".?!", sentenceFinalPunc);
}
public void TestInitializeFromXml_ValidAndBogusCharacters()
{
LanguageDefinition langDef = new LanguageDefinition();
langDef.LocaleName = "xmum";
langDef.LocaleScript = "IPA";
langDef.LocaleCountry = "usa";
langDef.LocaleVariant = "south";
langDef.ValidChars = ksXmlHeader + "<ValidCharacters><WordForming>\u05F6\uFFFCg\uFFFC\u05F7\uFFFCh</WordForming>" +
"<Numeric>1</Numeric>" +
"<Other></Other>" +
"</ValidCharacters>";
ValidCharacters validChars = ValidCharacters.Load(langDef);
ValidCharsWrapper validCharsW = new ValidCharsWrapper(validChars);
Assert.AreEqual(2, validCharsW.WordFormingCharacters.Count);
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("g"));
Assert.IsTrue(validCharsW.WordFormingCharacters.Contains("h"));
Assert.AreEqual(1, validCharsW.NumericCharacters.Count);
Assert.IsTrue(validCharsW.NumericCharacters.Contains("1"));
Assert.AreEqual(0, validCharsW.OtherCharacters.Count);
Exception e = (Exception)ReflectionHelper.GetField(typeof(ValidCharacters), "s_lastException");
Assert.AreEqual("Invalid ValidChars field while loading the xmum (IPA, usa, south) writing system. " +
"The following characters are invalid:" +
Environment.NewLine + "\t\u05F6 (U+05F6)" +
Environment.NewLine + "\t\u05F7 (U+05F7)" +
Environment.NewLine + "Parameter name: xmlSrc",
e.Message);
}
public void GetDisplayNameNameOnly()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.LocaleName = "English";
Assert.AreEqual("English", langDef.DisplayName);
}
public void SetPuaDefinitionsToNull()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.PuaDefinitions = new CharDef[] { new CharDef(0xF170, "COMBINING SNAKE BELOW;Mn;202;NSM;;;;") };
Assert.AreEqual(1, langDef.PuaDefinitionCount);
langDef.PuaDefinitions = null;
Assert.AreEqual(0, langDef.PuaDefinitionCount);
}
public void GetDisplayNameNameAndCountry()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.LocaleName = "English";
langDef.LocaleCountry = "United States";
Assert.AreEqual("English (United States)", langDef.DisplayName);
}
public void GetDisplayNameNameAndScript()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.LocaleName = "English";
langDef.LocaleScript = "Latin";
Assert.AreEqual("English (Latin)", langDef.DisplayName);
}
public void SetAbbreviationsNameOnlyAddCountry()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en";
langDef.CountryAbbr = "US";
Assert.AreEqual("en_US", langDef.XmlWritingSystem.WritingSystem.IcuLocale);
}
public void SetAbbreviationsNameOnlyAddVariant()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en";
langDef.VariantAbbr = "X_ETIC";
Assert.AreEqual("en__X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale);
}
public void SetAbbreviationsInsertCountry()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en__X_ETIC";
langDef.CountryAbbr = "UK";
Assert.AreEqual("en_UK_X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale);
}
public void SetAbbreviationsInsertScript()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en__X_ETIC";
langDef.ScriptAbbr = "Latn";
Assert.AreEqual("en_Latn__X_ETIC", langDef.XmlWritingSystem.WritingSystem.IcuLocale);
}
public void GetDisplayNameNameAndVariant()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.LocaleName = "English";
langDef.LocaleVariant = "Phonetic";
Assert.AreEqual("English (Phonetic)", langDef.DisplayName);
}
public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false)
{
//var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays));
var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All};
settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays));
settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays));
var json = JsonConvert.SerializeObject(definition, formatting, settings);
return json;
}
/// <summary>
/// Create language UI presentation.
/// </summary>
/// <param name="language">The language to be presented</param>
/// <param name="header">The header for a language value</param>
public LanguageUIDefinition(LanguageDefinition language, string header)
{
if (string.IsNullOrWhiteSpace(header))
{
throw new ArgumentException("Language header cannot be empty");
}
Language = language;
Header = header;
}
public void GetAbbreviationsUnderline()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en_Latn_US_X_ETIC_x";
Assert.AreEqual("en", langDef.LocaleAbbr);
Assert.AreEqual("Latn", langDef.ScriptAbbr);
Assert.AreEqual("US", langDef.CountryAbbr);
Assert.AreEqual("X_ETIC_X", langDef.VariantAbbr);
}
public void GetAbbreviationsNameAndCountry()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en_US";
Assert.AreEqual("en", langDef.LocaleAbbr);
Assert.AreEqual("US", langDef.CountryAbbr);
Assert.AreEqual("", langDef.VariantAbbr);
}
/// ----------------------------------------------------------------------------------------
/// <summary>
/// For a given LanguageDefinition, if the ValidChars field is empty then try to get a set
/// of ExemplarCharacters (valid characters) from ICU for this language.
/// </summary>
/// <param name="langDef"></param>
/// <param name="cpe">A character property engine (needed for normalization).</param>
/// ----------------------------------------------------------------------------------------
public static void TryLoadValidCharsIfEmpty(LanguageDefinition langDef,
ILgCharacterPropertyEngine cpe)
{
//Try to load the ValidChars if none have been loaded yet.
if (string.IsNullOrEmpty(langDef.ValidChars))
{
string IcuLocale = (langDef.BaseLocale ?? langDef.LocaleAbbr);
langDef.ValidChars = GetValidCharsForLocale(IcuLocale, cpe);
}
}
/// <summary>
/// Get <see cref="PageViewModel"/> by language using content view model retrieval method.
/// </summary>
/// <param name="languageDefinition">Language.</param>
/// <param name="contentViewModelMethod">Localized content retrieval method.</param>
/// <returns>Page view model.</returns>
private async Task <PageViewModel> GetPageViewModelByAsync(LanguageDefinition languageDefinition, Func <Task <ContentPublicViewData> > contentViewModelMethod)
{
var contentViewData = await contentViewModelMethod();
var linksData = await _contentRepository.GetContentLinksPresentationDataAsync(languageDefinition,
Enum.GetNames(typeof(PredefinedPages))
);
return(new PageViewModel(_pageConfiguration, languageDefinition, contentViewData, linksData));
}
public void GetDisplayNameAll()
{
LanguageDefinition langDef = new LanguageDefinition(m_wsEn);
langDef.LocaleName = "English";
langDef.LocaleScript = "Latin";
langDef.LocaleCountry = "United States";
langDef.LocaleVariant = "Phonetic";
Assert.AreEqual("English (Latin, United States, Phonetic)", langDef.DisplayName);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Looks up the ICU locale and returns the corresponding writing system code
/// </summary>
/// <param name="sICULocale">The ICU locale name</param>
/// <returns>The Writing System code</returns>
/// ------------------------------------------------------------------------------------
public int GetWsFromIcuLocale(string sICULocale)
{
foreach (ILgWritingSystem lgws in this)
{
if (LanguageDefinition.SameLocale(lgws.ICULocale, sICULocale))
{
return(lgws.Hvo);
}
}
return(0); // Couldn't find it.
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Loads the valid characters from the specified language definition into a new
/// instance of the <see cref="ValidCharacters"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public static ValidCharacters Load(LanguageDefinition langDef)
{
ValidCharacters validChars = Load(langDef.ValidChars, langDef.DisplayName, langDef);
if (validChars != null)
{
validChars.InitSortComparer(langDef.IcuLocaleOriginal);
}
return(validChars);
}
public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false)
{
//var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays));
var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All};
settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays));
settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays));
var json = JsonConvert.SerializeObject(definition, formatting, settings);
return(json);
}
public void SetsProperLanguage(
string language,
LanguageDefinition expectedModelLanguage)
{
SetupContent();
var result = _homeController.Index(language) as ViewResult;
var resultModel = result.ViewData.Model as PageViewModel;
Assert.Equal(expectedModelLanguage, resultModel.Language);
}
public ContentLinksViewModel(
LanguageDefinition linksLanguage,
IDictionary<string, LinkUI> internalNamesToLinksUI)
{
if(internalNamesToLinksUI == null)
{
throw new ArgumentNullException(nameof(internalNamesToLinksUI));
}
_internalNamesToLinksUI = internalNamesToLinksUI;
_linksLanguage = linksLanguage;
}
public ContentViewModel FindTranslatedContentByInternalCaption(LanguageDefinition langDefinition, string internalCaption)
{
GuardNotDisposed();
var contentAndTranslation = (from x in _dataDbContext.Translations
join c in _dataDbContext.Contents
on new { Id = x.ContentId, Caption = internalCaption }
equals new { Id = c.Id, Caption = c.InternalCaption }
where x.Version == langDefinition
&& x.State == DataAvailabilityState.published
let urlNames = (from y in c.Translations
where y.State == DataAvailabilityState.published
select new { y.Version, y.UrlName }).ToDictionary(z => z.Version, z => z.UrlName)
select FillContentViewModel(c.InternalCaption, x, urlNames)).FirstOrDefault();
return contentAndTranslation;
}
public ContentViewModel FindTranslatedContentByUrlName(LanguageDefinition langDefinition, string urlName)
{
GuardNotDisposed();
var lowerCaseUrlName = urlName.ToLowerInvariant();
var contentAndTranslation = (from x in _dataDbContext.Translations
join c in _dataDbContext.Contents on x.ContentId equals c.Id
where x.Version == langDefinition
&& x.UrlName == lowerCaseUrlName
&& x.State == DataAvailabilityState.published
let urlNames = (from y in c.Translations
where y.State == DataAvailabilityState.published
select new { y.Version, y.UrlName }).ToDictionary(z => z.Version, z => z.UrlName)
select FillContentViewModel(c.InternalCaption, x, urlNames)).FirstOrDefault();
return contentAndTranslation;
}
private PageViewModel GetPageViewModelBy(LanguageDefinition languageDefinition, Func<ContentViewModel> contentViewModelMethod)
{
GuardNotDisposed();
ContentViewModel contentVM;
ContentLinksViewModel linksVM;
using (_contentRepository)
{
contentVM = contentViewModelMethod();
if (contentVM == null)
{
return null; // No content available.
}
linksVM = _contentRepository.GetContentLinksPresentationData(languageDefinition,
Enum.GetNames(typeof(PredefinedPages))
);
}
return new PageViewModel(_pageConfiguration, languageDefinition, contentVM, linksVM);
}
public ContentLinksViewModel GetContentLinksPresentationData(LanguageDefinition languageDefinition, IList<string> internalContentNames)
{
GuardNotDisposed();
var internalNamesToLinkViewModels = (from t in _dataDbContext.Translations
join c in _dataDbContext.Contents on t.ContentId equals c.Id
where
internalContentNames.Contains(c.InternalCaption)
&& t.State == DataAvailabilityState.published
&& t.Version == languageDefinition
select new
{
LinkUI = new LinkUI {
LinkTitle = t.Title,
UrlName = t.UrlName
},
InternalCaption = c.InternalCaption
}).ToDictionary(x => x.InternalCaption, x => x.LinkUI);
return new ContentLinksViewModel(
languageDefinition,
internalNamesToLinkViewModels);
}
public static string Serialize(LanguageDefinition definition, bool serializeAsArrays = false)
{
return Serialize(definition, Formatting.Indented, serializeAsArrays);
}
public string LanguageDefinitionToLanguageRepresentation(LanguageDefinition definition)
{
return _languageDefinitionToRepresentations[definition];
}
public CultureInfo LanguageDefinitionToCultureInfo(LanguageDefinition languageDefinition)
{
return _languageDefinitionToCultureInfo[languageDefinition];
}
public void SetsProperLanguage(
string language,
LanguageDefinition expectedModelLanguage)
{
SetupContent();
var result = _homeController.Index(language) as ViewResult;
var resultModel = result.ViewData.Model as PageViewModel;
Assert.Equal(expectedModelLanguage, resultModel.Language);
}
/// <summary>
/// Get translated page by its translated human-readable name.
/// </summary>
/// <param name="languageDefinition">Required language definition.</param>
/// <param name="urlName">Human-readable name of a content.</param>
/// <returns><typeparamref name="PageViewModel"/> instance</returns>
public PageViewModel GetPageByHumanReadableName(LanguageDefinition languageDefinition, string urlName)
{
return GetPageViewModelBy(languageDefinition, () => _contentRepository.FindTranslatedContentByUrlName(languageDefinition, urlName));
}
/// <summary>
/// Get translated page by its internal caption.
/// </summary>
/// <param name="languageDefinition">Required language definition.</param>
/// <param name="internalCaption">Internal caption of a content.</param>
/// <returns><typeparamref name="PageViewModel"/> instance</returns>
public PageViewModel GetPageByInternalCaption(LanguageDefinition languageDefinition, string internalCaption)
{
return GetPageViewModelBy(languageDefinition, () => _contentRepository.FindTranslatedContentByInternalCaption(languageDefinition, internalCaption));
}
