private void comboTargetLang_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (comboTargetLang.SelectedIndex > 0)
{
targetLang = (EnumLanguage)(comboTargetLang.SelectedValue);
}
}
public static TranslationDict LoadFromXaml(string xamlFile, EnumLanguage lang)
{
var dict = new TranslationDict();
var p = "x:Key=\"";
var s1 = " xml:space=\"preserve\">";
var lines = new List <string>();
using (var sr = new StreamReader(xamlFile))
{
while (!sr.EndOfStream)
{
var s = sr.ReadLine();
if (s.Length > p.Length)
{
var i = s.IndexOf(p);
if (i > 0)
{
i = i + p.Length;
var j = s.IndexOf('\"', i + 1);
if (j > 0)
{
var key = s.Substring(i, j - i);
i = j + s1.Length;
j = s.IndexOf('<');
var value = s.Substring(i, j - i);
dict.Append(key, lang, value);
}
}
}
}
}
return(dict);
}
public static void ReplaceResx(TranslationDict dict, EnumLanguage lang, string resxFile, string destFile)
{
var xDoc = new XmlDocument();
xDoc.Load(resxFile);
var root = xDoc.DocumentElement;
var nodeList = root.GetElementsByTagName("data");
foreach (var node in nodeList)
{
var e = (XmlElement)node;
var key = e.GetAttribute("name");
if (!dict.ContainsKey(key))
{
Console.WriteLine(key);
continue;
}
var children = e.GetElementsByTagName("value");
foreach (var c in children)
{
var value = ((XmlElement)c).InnerText;
((XmlElement)c).InnerText = dict[key][lang];
break;
}
}
xDoc.Save(destFile);
}
public override void Execute()
{
StartStep();
// Playback the same VOD asset
res = CL.EA.VOD.PlayAsset(vodAsset, false);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to play the playback");
}
// Check that prefered audio language is played
EnumLanguage audioLanguage = EnumLanguage.Off;
CL.EA.GetCurrentAudioLanguage(ref audioLanguage);
if (audioLanguage != audioLanguage_2)
{
FailStep(CL, res, "Failed to check current audio language. Expected: " + audioLanguage_2.ToString() + ", Received: " + audioLanguage.ToString());
}
// Check that prefered subtitle language is displayed
EnumLanguage subtitleLanguage = EnumLanguage.Off;
CL.EA.GetCurrentSubtitleLanguage(ref subtitleLanguage);
if (subtitleLanguage != subtitleLanguage_2)
{
FailStep(CL, res, "Failed to check current subtitle language. Expected: " + subtitleLanguage_2.ToString() + ", Received: " + subtitleLanguage.ToString());
}
PassStep();
}
private void comboTranslation_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (comboTranslation.SelectedIndex > 0)
{
transLang = (EnumLanguage)(comboTranslation.SelectedValue);
}
}
private static IList <YearSpan> getNamedPeriods(EnumLanguage language = EnumLanguage.NONE)
{
IList <YearSpan> namedPeriods = null;
string path = "";
switch (language)
{
case EnumLanguage.IT:
path = @"fasti-named-periods.json";
break;
case EnumLanguage.NL:
path = @"dans-named-periods.json";
break;
default:
path = @"eh-named-periods.json";
break;
}
// string path = System.Web.HttpContext.Current.Request.MapPath("~\\eh-named-periods.json");
if (System.Web.HttpContext.Current != null)
{
path = System.Web.HttpContext.Current.Request.MapPath("~\\" + path);
}
string text = System.IO.File.ReadAllText(path);
namedPeriods = Newtonsoft.Json.JsonConvert.DeserializeObject <List <YearSpan> >(text);
foreach (IYearSpan span in namedPeriods)
{
span.label = span.label.Trim().ToUpper(); // for comparison purposes in match...
}
return(namedPeriods);
}
// input: "VII-VI secolo" or "III-II secolo a.C."
// output: { min: 601, max: 800, label: "VII-VI secolo" }
public static IYearSpan Match(string input, EnumLanguage language = EnumLanguage.NONE)
{
Match m = Regex.Match(input.Trim(), GetPattern(language), options);
if (!m.Success)
{
return(null);
}
string century = "";
int centuryMin = 0;
int centuryMax = 0;
century = m.Groups["centuryMin"].Value;
centuryMin = Regex.IsMatch(century, ROMAN) ? RomanToNumber.Parse(century) : Int32.Parse(century);
century = m.Groups["centuryMax"].Value;
centuryMax = Regex.IsMatch(century, ROMAN) ? RomanToNumber.Parse(century) : Int32.Parse(century);
EnumDatePrefix prefix1 = m.Groups["prefix1"] != null ? Lookup <EnumDatePrefix> .Match(m.Groups["prefix1"].Value, language) : EnumDatePrefix.NONE;
EnumDatePrefix prefix2 = m.Groups["prefix2"] != null ? Lookup <EnumDatePrefix> .Match(m.Groups["prefix2"].Value, language) : EnumDatePrefix.NONE;
EnumDateSuffix suffix = m.Groups["suffix"] != null ? Lookup <EnumDateSuffix> .Match(m.Groups["suffix"].Value, language) : EnumDateSuffix.NONE;
IYearSpan centuryMinSpan = getCenturyYearSpan(centuryMin, prefix1, suffix);
IYearSpan centuryMaxSpan = getCenturyYearSpan(centuryMax, prefix2, suffix);
return(new YearSpan(Math.Min(centuryMinSpan.min, centuryMaxSpan.min), Math.Max(centuryMinSpan.max, centuryMaxSpan.max), input, "RxFromCenturyToCentury"));
}
public static IYearSpan Match(string input, EnumLanguage language = EnumLanguage.NONE)
{
MatchCollection mc = Regex.Matches(input.Trim(), Pattern(language), options);
int yearMin = 0;
int yearMax = 0;
if (mc.Count == 0)
{
return(null);
}
if (mc.Count > 0)
{
int.TryParse(mc[0].Value, out yearMin);
}
if (mc.Count > 1)
{
int.TryParse(mc[1].Value, out yearMax);
}
else
{
yearMax = yearMin;
}
return(new YearSpan(yearMin, yearMax, input, "RxLastChance"));
}
public override void Execute()
{
StartStep();
// Set default audio language
res = CL.EA.STBSettings.SetPreferredAudioLanguage(audioLanguage_1);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to set prefered audio language to " + audioLanguage_1.ToString());
}
// Play an asset with with several languages and subtitles
res = CL.EA.VOD.PlayAsset(vodAsset);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to play the asset with several audio and subtitle languages");
}
// Check video is played with prefered language
EnumLanguage audioLanguage = EnumLanguage.Off;
CL.EA.GetCurrentAudioLanguage(ref audioLanguage);
if (audioLanguage != audioLanguage_1)
{
FailStep(CL, res, "Failed to check current audio language. Expected: " + audioLanguage_1.ToString() + ", Received: " + audioLanguage.ToString());
}
PassStep();
}
private static string GetPattern(EnumLanguage language = EnumLanguage.NONE)
{
string pattern = "";
switch (language)
{
default:
{
// circa late eighth to early ninth century AD
pattern = String.Concat(
START,
maybe(DateCirca.Pattern(language) + SPACE),
maybe(oneof(Lookup <EnumDatePrefix> .Patterns(language), "prefix1") + SPACE),
oneof(Lookup <EnumOrdinal> .Patterns(language), "centuryMin"),
maybe(SPACE + "century"),
@"\s*(?:[e\;\-\/]|to|or)\s*",
maybe(oneof(Lookup <EnumDatePrefix> .Patterns(language), "prefix2") + SPACE),
oneof(Lookup <EnumOrdinal> .Patterns(language), "centuryMax"),
maybe(SPACE + "century"),
maybe(SPACE + oneof(Lookup <EnumDateSuffix> .Patterns(language), "suffix")),
END
);
break;
}
}
return(pattern);
}
private static string GetPattern(EnumLanguage language = EnumLanguage.NONE)
{
string pattern = "";
switch (language)
{
case EnumLanguage.IT:
// ^(?:(?:Intorno\sal|circa)\s)?(?<yearMin>\d{2,})(?:\s*[\;\-\/]\s*)(?<yearMax>\d{1,2})(?:\s(?<suffix>a\.?C\.?|d\.?C\.?))?$
pattern = String.Concat(
START, // ^
maybe(DateCirca.Pattern(language) + SPACE), // (?:(?:Intorno\sal|circa)\s)?
group(@"\d{4,}", "yearMin"), // (?<yearMin>\d{2,})
@"\s*[\;\-\/]\s*", // separators
group(@"\d{1,2}", "yearMax"), // (?<yearMax>\d{1,2})
maybe(SPACE + DateSuffix.Pattern(language, "suffix")), // (?:\s(?<suffix>a\.?C\.?|d\.?C\.?))?
END
);
break;
default:
// ^(?:(?:C(?:\.|irca)|around|approx(?:\.|imately))\s)?(?<yearMin>\d{2,})(?:\s*[\;\-\/]\s*)(?<yearMax>\d{1,2})(?:\s(?<suffix>AD|BC|BP|CE))?$
pattern = String.Concat(
START, // ^
maybe(DateCirca.Pattern(language) + SPACE), // (?:(?:C(?:\.|irca)|around|approx(?:\.|imately))\s)?
group(@"\d{4,}", "yearMin"), // (?<yearMin>\d{2,})
@"\s*[\;\-\/]\s*", // separators
group(@"\d{1,2}", "yearMax"), // (?<yearMax>\d{1,2})
maybe(SPACE + DateSuffix.Pattern(language, "suffix")), // (?:\s(?<suffix>AD|BC|BP|CE))?
END
);
break;
}
return(pattern);
}
public static EnumDay Match(string input, EnumLanguage language = EnumLanguage.NONE)
{
RegexOptions options = RegexOptions.IgnoreCase;
input = input.Trim();
string[] patterns = Patterns(language);
for (int i = 0; i < patterns.Length; i++)
{
if (Regex.IsMatch(input, patterns[i], options))
{
switch (i)
{
case 0: return(EnumDay.MON);
case 1: return(EnumDay.TUE);
case 2: return(EnumDay.WED);
case 3: return(EnumDay.THU);
case 4: return(EnumDay.FRI);
case 5: return(EnumDay.SAT);
case 6: return(EnumDay.SUN);
}
}
}
return(EnumDay.NONE); // no match
}
//private IYearSpanParser parser = new YearSpanParser();
private void compare(String input, IYearSpan expected, EnumLanguage language)
{
//IInterval<int> result = parser.Parse(input);
IYearSpan result = YearSpan.Parse(input, language);
compare(result, expected);
}
// input: "Georgian" (NOTE: this is just a lookup - different to Regex parsers...)
// output: { min: 1714, max: 1837, label: "Georgian" } TODO: other languages (and give dates to periods in JSON files...)
public static IYearSpan Match(string input, EnumLanguage language = EnumLanguage.NONE)
{
// attempt to match on named period (returns null if not matched)
IYearSpan match = null;
switch (language)
{
case EnumLanguage.IT:
match = namedPeriodsIT.FirstOrDefault(o => o.label == input.Trim().ToUpper());
break;
case EnumLanguage.NL:
match = namedPeriodsNL.FirstOrDefault(o => o.label == input.Trim().ToUpper());
break;
default:
match = namedPeriodsEN.FirstOrDefault(o => o.label == input.Trim().ToUpper());
break;
}
if (match != null)
{
match.note = "RxNamedPeriod";
}
return(match);
}
// input: "1521", "C.1521", "C.1521 AD", "C.1521 BC"
// output: { min: 1521, max: 1521, label: "C. 1521 AD" }
public static IYearSpan Match(string input, EnumLanguage language = EnumLanguage.NONE)
{
string pattern = GetPattern(language);
Match m = Regex.Match(input.Trim(), pattern, options);
if (!m.Success)
{
return(null);
}
int year = 0;
int.TryParse(m.Groups["year"].Value, out year);
EnumDateSuffix suffix = m.Groups["suffix"] != null ? Lookup <EnumDateSuffix> .Match(m.Groups["suffix"].Value, language) : EnumDateSuffix.NONE;
switch (suffix)
{
case EnumDateSuffix.BC:
case EnumDateSuffix.BCE:
year *= -1;
break;
case EnumDateSuffix.BP:
year = PRESENT - year;
break;
}
return(new YearSpan(year, input, "RxSingleYear"));
}
/// <summary>
/// Редактирование контента
/// </summary>
/// <param name="content"></param>
/// <param name="id"></param>
/// <param name="lang"></param>
/// <returns></returns>
public BaseResponse EditContent(string content, string id, EnumLanguage lang)
{
try
{
var keyString = id.Split('-')[1];
if (!string.IsNullOrEmpty(keyString))
{
var key = int.Parse(keyString);
using (var db = new DataContext())
{
var setting = db.PageContentLangs.FirstOrDefault(x => x.PageContentId == key && x.Lang == (int)lang);
if (setting != null)
{
setting.Content = content;
//for (int i = 17; i < 300; i++)
//{
// var pageContent = new PageContent {Id = i};
// db.PageContents.Add(pageContent);
// var contentRu = new PageContentLang{PageContentId = i,Lang = 1};
// db.PageContentLangs.Add(contentRu);
// var contentEn = new PageContentLang{PageContentId = i,Lang = 2};
// db.PageContentLangs.Add(contentEn);
//}
db.SaveChanges();
return(new BaseResponse(EnumResponseStatus.Success, "Контент успешно изменен"));
}
}
}
return(new BaseResponse(EnumResponseStatus.Error));
}
catch (Exception ex)
{
return(new BaseResponse(EnumResponseStatus.Exception));
}
}
/// <summary>
/// 获取枚举的描述信息
/// </summary>
/// <param name="enumValue">枚举值</param>
/// <param name="language">枚举描述的语言</param>
/// <returns>枚举的描述信息</returns>
public static string GetEnumDescription <T>(T enumValue, EnumLanguage language)
{
FieldInfo fieldInfo = typeof(T).GetField(enumValue.ToString());
object[] attribArray = fieldInfo.GetCustomAttributes(false);
//如果没有描述
if (attribArray.Length == 0)
{
return(enumValue.ToString());
}
else
{
DescriptionAttribute attrib = attribArray[0] as DescriptionAttribute;
//没有描述，返回枚举值
if (string.IsNullOrEmpty(attrib.Description))
{
return(enumValue.ToString());
}
//返回枚举对应的语言
var descrips = attrib.Description.Split(',');
return(descrips.Length <= (int)language ? descrips[0] : descrips[(int)language]);
}
}
public override void Execute()
{
StartStep();
// Play an asset with with several languages and subtitles
res = CL.EA.VOD.PlayAsset(vodAsset);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to play the asset with subtitle languages");
}
// Select a subtitle language from action menu
res = CL.EA.SubtitlesLanguageChange(subtitleLanguage_1);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to change subtitle language in action bar from OFF to " + subtitleLanguage_1.ToString());
}
// Check subtitles are displayed
EnumLanguage subtitleLanguage = EnumLanguage.Off;
CL.EA.GetCurrentSubtitleLanguage(ref subtitleLanguage);
if (subtitleLanguage != subtitleLanguage_1)
{
FailStep(CL, res, "Failed to check current subtitle language. Expected: " + subtitleLanguage_1.ToString() + ", Received: " + subtitleLanguage.ToString());
}
PassStep();
}
public override void Execute()
{
StartStep();
// Select a subtitle language from action menu
res = CL.EA.SubtitlesLanguageChange(subtitleLanguage_2, subtitletype_2);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to change subtitle language in action bar from OFF to " + subtitleLanguage_1.ToString());
}
// Check that prefered subtitle language is displayed
EnumLanguage subtitleLanguage = EnumLanguage.Off;
CL.EA.GetCurrentSubtitleLanguage(ref subtitleLanguage);
if (subtitleLanguage != subtitleLanguage_2)
{
FailStep(CL, res, "Failed to check current subtitle language. Expected: " + subtitleLanguage_2.ToString() + ", Received: " + subtitleLanguage.ToString());
}
// Check subtitles type is correct
EnumSubtitleType subtitleType = EnumSubtitleType.NORMAL;
CL.EA.GetCurrentSubtitleType(ref subtitleType);
if (subtitleType != subtitletype_2)
{
FailStep(CL, res, "Failed to check current subtitle Type. Expected: " + subtitleLanguage_2.ToString() + ", Received: " + subtitleType.ToString());
}
PassStep();
}
public void StartConversation()
{
if (sentences == null)
{
sentences = new Queue <string>();
}
else
{
sentences.Clear();
}
EnumLanguage enumLanguage = PlayerPrefs.HasKey("enumLanguage") ?
(EnumLanguage)PlayerPrefs.GetInt("enumLanguage") : EnumLanguage.Vietnamese;
switch (enumLanguage)
{
case EnumLanguage.Vietnamese:
for (int i = 0; i < Contents.Length; i++)
{
sentences.Enqueue(Contents[i].Vietnamese);
}
break;
case EnumLanguage.English:
for (int i = 0; i < Contents.Length; i++)
{
sentences.Enqueue(Contents[i].English);
}
break;
}
}
public override void Execute()
{
StartStep();
// disable subtitle language from action menu
res = CL.EA.SubtitlesLanguageChange(EnumLanguage.Off);
if (!res.CommandSucceeded)
{
FailStep(CL, res, "Failed to change subtitle language in action bar from ON to OFF");
}
// Check that prefered subtitle language is not displayed
EnumLanguage subtitleLanguage = EnumLanguage.Off;
CL.EA.GetCurrentSubtitleLanguage(ref subtitleLanguage);
if (subtitleLanguage != EnumLanguage.Off)
{
FailStep(CL, res, "Failed to check current subtitle language is OFF");
}
PassStep();
}
public YearSpan()
{
this.min = 0;
this.max = 0;
this.label = "";
this.note = "";
this.language = EnumLanguage.NONE;
}
public void Remove(EnumLanguage lang)
{
if (Collection.ContainsKey(lang))
{
Collection.Remove(lang);
RaisePropertyChanged("Collection");
}
}
public static EnumLanguage[] GetLanguages()
{
EnumLanguage[] Ret = new EnumLanguage[_Languages.Length - 2];
for (int i = 1; i < _Languages.Length - 1; i++) // bypass the first Unknown and last All
{
Ret[i - 1] = MapLanguage(_Languages[i]);
}
return(Ret);
}
/// <summary>Attempt to Parse a <c cref="YearSpan">YearSpan</c> from a <c cref="System.String">String</c> input value</summary>
/// <param name="s">Input <c cref="System.String">String</c> to be parsed</param>
/// <param name="result">Output <c cref="YearSpan">YearSpan</c> if successful, <c>null</c> otherwise</param>
/// <returns>Returns <c>true</c> if parse was successful, <c>false</c> otherwise</returns>
/// <exception cref="System.ArgumentNullException">Thrown when s is null</exception>
public static bool TryParse(string s, EnumLanguage language, out IYearSpan result)
{
if (s == null)
{
throw new System.ArgumentNullException("s", "null input value");
}
result = Parse(s, language);
return(result == null ? false : true);
}
public GMapTypeLanguage Get(int idGMapType, EnumLanguage enumLanguage)
{
var result = Context.GMapTypeLanguage
.Where(x => x.CountryCode == enumLanguage.ToString() &&
x.IdGMapType == idGMapType)
.FirstOrDefault();
return(result);
}
public static IYearSpan Parse(string input, string language)
{
EnumLanguage lang = EnumLanguage.EN;
if (!Enum.TryParse(language.Trim().ToUpper(), true, out lang))
{
lang = EnumLanguage.EN;
}
return(Parse(input, lang));
}
/// <summary>
/// 转换函数
/// </summary>
/// <param name="value">值</param>
/// <param name="targetType">目标类型</param>
/// <param name="parameter">参数</param>
/// <param name="culture">本地化信息</param>
/// <returns>转换结果</returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value != null)
{
EnumLanguage language = (EnumLanguage)value;
string langName = Globals.GetEnumLanguageName(language);
return(Globals.GetStringFromCurrentLanguage($"TEXT_Use{langName}"));
}
Log.Assert(true, "EnumLanguageToTreslateNameConverter");
return(Globals.GetStringFromCurrentLanguage("TEXT_Error"));
}
public List <ModelSlider> GetSliderList(EnumLanguage lang, EnumSitePage sitePage)
{
using (var db = new DataContext())
{
var sliders = db.SliderLanguages.Include(x => x.Slider)
.Where(x => x.Slider.PageId == sitePage && x.LanguageId == lang)
.OrderByDescending(x => x.Slider.CreateDate).ToList();
var result = sliders.Select(x => ConvertToModelSlider(x)).ToList();
return(result);
}
}
public void ChangeLanguage(EnumLanguage enumLanguage)
{
MyJson.JsonNode_Object jsonConfig = new MyJson.JsonNode_Object();
//读取语言配置包
if (System.IO.File.Exists("appsetting.txt"))
{
var txt = System.IO.File.ReadAllText("appsetting.txt");
jsonConfig = MyJson.Parse(txt) as MyJson.JsonNode_Object;
jsonConfig["language"] = new MyJson.JsonNode_ValueNumber((uint)enumLanguage);
}
System.IO.File.WriteAllText("appsetting.txt", jsonConfig.ToString());
}
/// <summary>
/// Gets the message.
/// </summary>
/// <param name="language">The language.</param>
/// <returns></returns>
public string GetMessage(EnumLanguage language)
{
switch (language)
{
case EnumLanguage.Frensh:
return this.MessageFr;
case EnumLanguage.English:
return this.MessageEn;
case EnumLanguage.German:
return this.MessageDe;
default:
return null;
}
}
/// <summary>
/// Creates a vocabulary from a list of strings.
/// Applies grouping.
/// Applies stop words and stemming (if available for the language)
/// Does not performs a Distinct
/// </summary>
/// <param name="language"></param>
/// <param name="strings"></param>
/// <returns></returns>
public Return<List<string>> CreateVocabulary(EnumLanguage language, List<string> strings)
{
Return<List<string>> _answer = new Return<List<string>>();
if (strings == null)
{
_answer.theresError = true;
_answer.error = Utility.GetError(new ArgumentNullException("strings"), this.GetType());
}
else
{
try
{
switch (language)
{
case EnumLanguage.castilian: _answer = CreateVocabularyCastilianLanguage(strings); break;
case EnumLanguage.catalan: _answer = CreateVocabularyCatalanLanguage(strings); break;
case EnumLanguage.english: _answer = CreateVocabularyEnglishLanguage(strings); break;
case EnumLanguage.undetermined:
default: string _message = string.Format("It has not been implemented a solution for language \"{0}\"", Enum.GetName(typeof(EnumLanguage), language));
throw new NotImplementedException(_message);
}
}
catch (Exception _ex)
{
_answer.theresError = true;
_answer.error = Utility.GetError(_ex, this.GetType());
}
}
return _answer;
}
public DateIdentifier(EnumLanguage language)
{
this.language = language;
List<WritableTuple<EnumLanguage, string>> _patternsDatesDigits = new List<WritableTuple<EnumLanguage, string>>()
{
new WritableTuple<EnumLanguage, string>(EnumLanguage.castilian, PATTERN_DATES_DIGITS_ddMMaaa_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.catalan, PATTERN_DATES_DIGITS_ddMMaaa_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.french, PATTERN_DATES_DIGITS_ddMMaaa_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.italian, PATTERN_DATES_DIGITS_ddMMaaa_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.portuguese, PATTERN_DATES_DIGITS_ddMMaaa_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.undetermined , PATTERN_DATES_DIGITS_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.german , PATTERN_DATES_DIGITS_aaaaMMdd_001)
,new WritableTuple<EnumLanguage, string>(EnumLanguage.dutch , PATTERN_DATES_DIGITS_aaaaMMdd_001)
};
Return<object> _answerInitialize = Initialize(_patternsDatesDigits);
if (_answerInitialize.theresError)
throw _answerInitialize.error.exception;
}
private string GetXMLInformation(string filepath, EnumLanguage? language)
{
string _answer = string.Empty;
string _textHeader = "<?xml version=\"1.0\" encoding=\"utf-16\" ?>";
string _textFilepath = !string.IsNullOrWhiteSpace(filepath) ? string.Format("<filepath>{0}</filepath>", filepath) : string.Empty;
string _textLanguage = language.HasValue ? string.Format("<language>{0}</language>", Enum.GetName(typeof(EnumLanguage), language)) : string.Empty;
string _textInformation = string.Format("<information>{0}{1}</information>", _textFilepath, _textLanguage);
_answer = string.Format("{0}{1}", _textHeader, _textInformation);
return _answer;
}
public ActionResult ChangeLanguage(string returnUrl, EnumLanguage language)
{
LocalizationManger.SetLanguage(language);
return Redirect(returnUrl);
}
