public static async Task<IEnumerable<IItem>> GetItemsStaticInfosAsync(
this IHasItemIds hasItemIds,
ItemDataEnum? itemData = null,
RegionEnum? region = null,
LanguageEnum? languageCode = null,
string dataDragonVersion = null)
{
if (hasItemIds == null) throw new ArgumentNullException("hasItemIds");
var result = new List<IItem>();
var staticService = new StaticService(hasItemIds.ApiConfiguration);
foreach (var itemId in hasItemIds.ItemIds.Where(x => x > 0))
{
var item = await staticService.GetItemsAsync(
itemId,
itemData,
region,
languageCode,
dataDragonVersion);
result.Add(item);
}
return result;
}
public Loader(LanguageEnum lang, string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException("Can't find i18n file !");
}
var i18nFile = new XmlDocument();
i18nFile.Load(path);
foreach (XmlNode mainNode in i18nFile.GetElementsByTagName("i18nText"))
{
var textId = int.Parse(mainNode.Attributes["id"].InnerText);
var textStr = mainNode.InnerText;
this.Texts.Add(textId, textStr);
}
if (!Languages.ContainsKey(lang))
{
Languages.Add(lang, this);
}
else
{
throw new Exception("The specificated language was already loaded in i18n cache !");
}
}
/// <summary>
/// Get a language text from resources.
/// </summary>
/// <param name="item">Language item to get.</param>
/// <returns>Returns text.</returns>
public static string GetText(LanguageEnum item)
{
if (cultureInfo.CompareInfo != Thread.CurrentThread.CurrentCulture.CompareInfo)
{
SetLanguage(cultureInfo);
}
return resourceManager.GetString(GetDescription(item));
}
public SolutionItem(string name, string path, LanguageEnum language, bool website, IEnumerable<SolutionItem> projectReferences)
{
Guid = Guid.NewGuid();
Name = name;
Path = path;
Language = language;
Website = website;
ProjectReferences = projectReferences != null
? new List<SolutionItem>(projectReferences)
: new List<SolutionItem>();
}
/// <summary>
/// Get description for an enum value.
/// </summary>
/// <param name="item">Value of the enum.</param>
/// <returns>Returns description of the value.</returns>
private static string GetDescription(LanguageEnum item)
{
FieldInfo fieldInfo = item.GetType().GetField(item.ToString());
DescriptionAttribute[] descriptionAttribute = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (descriptionAttribute.Length > 0)
{
return descriptionAttribute[0].Description;
}
return item.ToString();
}
/// <summary>
/// Initializes a new instance of the <see cref="CitySearchableItem" /> class.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="name">The name.</param>
/// <param name="lang">The language.</param>
/// <exception cref="System.ArgumentNullException">Can't have negative ids.</exception>
public CitySearchableItem(int id, string name, LanguageEnum lang)
{
if (id < 0)
{
throw new ArgumentNullException("Can't have negative ids.");
}
this.Id = id;
this.Name = name;
this.Language = lang;
this.Category = CategoryEnum.City;
}
public void WriteToStream (LanguageEnum language, IContainer container, Stream stream, string namespaceName, string containerClassName)
{
Container containerImpl = (Container)container;
ICodeGenerator generator = null;
if (language == LanguageEnum.Csharp) {
generator = new CsharpCodeGenerator ();
}
if (generator == null)
{
throw new InvalidOperationException ("No generator for language");
}
generator.WriteToStream (containerImpl.Definitions, stream, namespaceName, containerClassName);
}
public static Menu ReadMenu(LanguageEnum langtype)
{
XDocument xdoc;
IEnumerable<XElement> xmlquery;
OpenXml(out xdoc, out xmlquery);
Menu _menu = new Menu();
_menu.Children = new List<Menu>();
foreach (var x in xmlquery)
{
Menu tem = new Menu();
if (langtype == LanguageEnum.VietNamese)
tem.Title = x.Element("Title").Value;
else
tem.Title = x.Element("TitleEng").Value;
tem.Link = x.Element("Link").Value.Trim();
tem.IsActive = true;
var att = x.Element("Roles").Elements("Role");
tem.Roles = new List<string>();
if (att != null)
{
foreach (var y in att)
{
tem.Roles.Add(y.Value);
}
}
var menu2 = x.Elements("Menu2");
tem.Children = new List<Menu>();
if (menu2 != null)
{
foreach (var z in menu2)
{
Menu tem2 = new Menu();
if (langtype == LanguageEnum.VietNamese)
tem2.Title = z.Element("Title").Value;
else
tem2.Title = z.Element("TitleEng").Value;
tem2.Link = z.Element("Link").Value;
tem.Children.Add(tem2);
}
}
_menu.Children.Add(tem);
}
return _menu;
}
public static async Task<IChampion> GetChampionStaticInfosAsync(
this IHasChampionId hasChampionId,
ChampDataEnum? champData = null,
RegionEnum? region = null,
LanguageEnum? languageCode = null,
string dataDragonVersion = null)
{
if (hasChampionId == null) throw new ArgumentNullException("hasChampionId");
var staticService = new StaticService(hasChampionId.ApiConfiguration);
return await staticService.GetChampionAsync(
hasChampionId.ChampionId,
champData,
region,
languageCode,
dataDragonVersion);
}
public static async Task<IRune> GetRuneStaticInfosAsync(
this IHasRuneId hasRuneId,
RuneDataEnum? runeData = null,
RegionEnum? region = null,
LanguageEnum? languageCode = null,
string dataDragonVersion = null)
{
if (hasRuneId == null) throw new ArgumentNullException("hasRuneId");
var staticService = new StaticService(hasRuneId.ApiConfiguration);
return await staticService.GetRuneAsync(
hasRuneId.RuneId,
runeData,
region,
languageCode,
dataDragonVersion);
}
public static async Task<IMastery> GetMasteryStaticInfosAsync(
this IHasMasteryId hasMasteryId,
MasteryDataEnum? masteryData = null,
RegionEnum? region = null,
LanguageEnum? languageCode = null,
string dataDragonVersion = null)
{
if (hasMasteryId == null) throw new ArgumentNullException("hasMasteryId");
var staticService = new StaticService(hasMasteryId.ApiConfiguration);
return await staticService.GetMasteryAsync(
hasMasteryId.Id,
masteryData,
region,
languageCode,
dataDragonVersion);
}
public PlayuavOSD()
{
self = this;
InitializeComponent();
SIZE_TO_FONT.Add(5);
SIZE_TO_FONT.Add(8);
SIZE_TO_FONT.Add(11);
langid = LanguageEnum.LANG_EN;
switch (System.Globalization.CultureInfo.CurrentUICulture.Name)
{
case "zh-CN":
case "zh-Hans":
langid = LanguageEnum.LANG_ZH;
break;
default:
break;
}
graphicsObjectGDIP = Graphics.FromImage(objBitmap);
}
public static void CreateLanguageKey(ILanguage language, LanguageEnum languagetype)
{
string path;
if (languagetype == LanguageEnum.English)
path = MvcApplication.Englishpath;
else
path = MvcApplication.VietNamesepath;
XmlReaderSettings xmlsetting = new XmlReaderSettings();
xmlsetting.DtdProcessing = DtdProcessing.Parse;
XmlReader xmlread = XmlReader.Create(path, xmlsetting);
XDocument xdoc = XDocument.Load(xmlread);
var AllKey = xdoc.Root.Elements("Keys");
language.Language = new Dictionary<string, string>();
language.Lang = languagetype;
foreach (var x in AllKey)
{
language.Language.Add(x.Element("KeyWord").Value, x.Element("KeyValue").Value);
}
}
public FontRegistryEntry(int HorizontalSize, int VerticalSize, int HorizontalResolution,
int VerticalResolution, int ExtraAttributes, int Weight,
FamilyEnum Family, StyleEnum StyleStyle, ushort StyleSub, LanguageEnum Language,
ushort Region, ushort Country, String FileName,
String Name, uint Expire, int ShadowOption)
{
this.ExtraAttributes = ExtraAttributes;
this.ShadowOption = ShadowOption;
this.FontStyle = new FontStyle()
{
Size = new HorizontalVerticalFloat() { Horizontal = HorizontalSize, Vertical = VerticalSize, },
Resolution = new HorizontalVerticalFloat() { Horizontal = HorizontalResolution, Vertical = VerticalResolution, },
Weight = Weight,
Family = Family,
StyleStyle = StyleStyle,
StyleSub = StyleSub,
Language = Language,
Region = Region,
Country = Country,
FileName = FileName,
Name = Name,
Expire = Expire,
};
}
private void SetupTest(ContactModel contactModelToDo, CultureInfo culture, string actionStr)
{
LanguageEnum languageEnum = (culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en);
if (contactModelToDo == null)
{
user = null;
}
else
{
user = new GenericPrincipal(new GenericIdentity(contactModelToDo.LoginEmail, "Forms"), null);
}
routeData = new RouteData();
routeData.Values.Add("culture", culture);
routeData.Values.Add("controller", controllerName);
routeData.Values.Add("action", actionStr);
stubHttpContext = new StubHttpContextBase();
stubHttpRequestBase = new StubHttpRequestBase();
stubHttpContext.RequestGet = () => stubHttpRequestBase;
requestContext = new RequestContext(stubHttpContext, routeData);
controller = new EmailController();
controller.Url = new UrlHelper(requestContext);
controller.ControllerContext = new ControllerContext(stubHttpContext, routeData, controller);
stubHttpContext.UserGet = () => user;
controller.SetRequestContext(requestContext);
// Assert
// BaseController Asserts
Assert.IsNotNull(controller);
Assert.AreEqual(2, controller.CultureListAllowable.Count);
Assert.AreEqual("en-CA", controller.CultureListAllowable[0]);
Assert.AreEqual("fr-CA", controller.CultureListAllowable[1]);
Assert.IsNotNull(controller._ContactService);
Assert.IsNotNull(controller._RequestContext);
Assert.IsNotNull(controller._TVItemService);
Assert.IsNotNull(controller._TVItemStatService);
Assert.IsNotNull(culture.Name, controller._RequestContext.RouteData.Values["culture"].ToString());
Assert.IsNotNull(controllerName, controller._RequestContext.RouteData.Values["controller"].ToString());
Assert.IsNotNull(actionStr, controller._RequestContext.RouteData.Values["action"].ToString());
Assert.AreEqual((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), controller.LanguageRequest);
Assert.AreEqual((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), controller.ViewBag.Language);
Assert.AreEqual(culture.Name, controller.CultureRequest);
Assert.AreEqual(culture.Name, controller.ViewBag.Culture);
Assert.AreEqual(Thread.CurrentThread.CurrentCulture, culture);
Assert.AreEqual(Thread.CurrentThread.CurrentUICulture, culture);
if (contactModelToDo != null)
{
Assert.AreEqual(contactModelToDo.IsAdmin, controller.IsAdmin);
Assert.AreEqual(contactModelToDo.IsAdmin, controller.ViewBag.IsAdmin);
}
Assert.AreEqual(true, controller.Debug);
Assert.AreEqual(true, controller.ViewBag.Debug);
// EmailController Asserts
Assert.IsNotNull(controller._EmailController);
Assert.IsNotNull(controller._EmailService);
Assert.IsNotNull(controller._TVItemLinkService);
// variables for testing
randomService = new RandomService(languageEnum, user);
emailService = new EmailService(languageEnum, user);
}
public List<CAMPAIGN> GetCampaignsByCategoryName(string CategoryName, LanguageEnum Language)
{
if (Language == LanguageEnum.AL)
return Context.CAMPAIGN.Where(c => c.CATEGORY.Any(cat => cat.Name == CategoryName) && c.Active && c.Approved.Value).ToList();
else
return Context.CAMPAIGN.Where(c => c.CATEGORY.Any(cat => cat.NameEng == CategoryName) && c.Active && c.Approved.Value).ToList();
}
private TVFileLanguageModel AddTVFileLanguageModel(LanguageEnum LangToAdd)
{
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
if (!string.IsNullOrWhiteSpace(tvItemModelRoot.Error))
{
return new TVFileLanguageModel()
{
Error = tvItemModelRoot.Error
}
}
;
TVItemModel tvItemModelFile = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, "Unique File Name", TVTypeEnum.File);
if (!string.IsNullOrWhiteSpace(tvItemModelFile.Error))
{
return new TVFileLanguageModel()
{
Error = tvItemModelFile.Error
}
}
;
TVFileModel tvFileModelNew = new TVFileModel()
{
ClientFilePath = randomService.RandomString("", 20),
FileCreatedDate_UTC = DateTime.Now,
FileInfo = randomService.RandomString("", 20),
FileDescription = randomService.RandomString("", 20),
FilePurpose = FilePurposeEnum.Picture,
FileSize_kb = randomService.RandomInt(10, 20),
FileType = FileTypeEnum.JPEG,
FromWater = false,
Language = LanguageEnum.en,
ServerFileName = randomService.RandomString("", 20),
ServerFilePath = randomService.RandomString("", 20),
TemplateTVType = (int)TVTypeEnum.Error,
TVFileTVItemID = tvItemModelFile.TVItemID,
};
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
return new TVFileLanguageModel()
{
Error = tvFileModelRet.Error
}
}
;
//TVFileLanguageModel tvFileLanguageModelNew = new TVFileLanguageModel();
//tvFileLanguageModelNew.TVFileID = tvFileModelRet.TVFileID;
//tvFileLanguageModelNew.FileDescription = tvFileModelNew.FileDescription;
//FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
TVFileLanguageModel tvFileLanguagModelRet = tvFileLanguageService.GetTVFileLanguageModelWithTVFileIDAndLanguageDB(tvFileModelRet.TVFileID, LanguageEnum.en);
if (!string.IsNullOrWhiteSpace(tvFileLanguagModelRet.Error))
{
return(tvFileLanguagModelRet);
}
//Assert.IsNotNull(tvFileLanguagModelRet);
//CompareTVFileLanguageModels(tvFileLanguageModelNew, tvFileLanguagModelRet);
return(tvFileLanguagModelRet);
}
// public LocalizationResourceConfig()
// {
// Language = LanguageEnum.UNKNOWN;
// Resource = default(RESOURCE_TYPE);
// }
public LocalizationResourceConfig(LanguageEnum lan, RESOURCE_TYPE res = default(RESOURCE_TYPE))
{
Language = lan;
Resource = res;
}
public LanguageEvent(CombatItem evtcItem) : base(evtcItem)
{
Language = evtcItem.SrcAgent < (byte)LanguageEnum.Unknown ? (LanguageEnum)evtcItem.SrcAgent
: LanguageEnum.Unknown;
}
/// <summary>
/// Returns template with body in html for client presentation, draft...
/// </summary>
/// <param name="htmlMessage"></param>
/// <param name="subject"></param>
/// <param name="jsonParams"></param>
/// <param name="language"></param>
/// <returns></returns>
public Task <string> GetEmailTemplateHtml(string htmlMessage, string subject = "subject", dynamic jsonParams = null, LanguageEnum language = LanguageEnum.es_ES)
{
return(BuildMessage(htmlMessage, subject, jsonParams == null ? string.Empty : JsonConvert.SerializeObject(jsonParams), language));
}
/// <summary>
/// Load all the available books for a specific language.
/// </summary>
/// <param name="htmlParser">Html parser.</param>
/// <param name="webClient">Webclient that loads the dynamic content.</param>
/// <param name="lang">Html parser.</param>
/// <param name="languageAvailablePages">Books pages count.</param>
/// <returns>List of books.</returns>
private static List <Book> LoadBooks(HtmlParser htmlParser, HtmlWeb webClient, LanguageEnum lang, int languageAvailablePages)
{
List <Book> books = new List <Book>();
for (int i = 1; i <= languageAvailablePages; i++) //for spanish just 20 pages
{
string booksPage = $"https://librivox.org/search?primary_key={(int)lang}&search_category=language&search_page={i}&search_form=get_results";
var document = LoadDocument(htmlParser, webClient, booksPage, "li.catalog-result");
if (document != null)
{
var htmlBooksList = document.QuerySelectorAll("li.catalog-result");
foreach (var bookNode in htmlBooksList)
{
AngleSharp.Dom.IElement nameAndLink = bookNode.QuerySelector("h3").QuerySelector("a");
AngleSharp.Dom.IElement element = bookNode.QuerySelector("div.download-btn");
if (element != null)
{
Book book = new Book
{
Url = nameAndLink.GetAttribute("href"),
Title = nameAndLink.TextContent,
BookMeta = bookNode.QuerySelector("p.book-meta").TextContent,
ZipFile = element.QuerySelector("a").GetAttribute("href")
};
books.Add(book);
//Console.Clear();
Console.WriteLine($"Book found: {book.Title}");
Console.WriteLine($"Books count: {books.Count}");
}
}
}
}
return(books);
}
public SamplingPlanSubsectorService(LanguageEnum LanguageRequest, IPrincipal User)
: base(LanguageRequest, User)
{
_LogService = new LogService(LanguageRequest, User);
}
/// <summary>
/// 通过名字查询
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public List <BiomeInfoBean> QueryDataByName(LanguageEnum language, string name)
{
return(BaseQueryData <BiomeInfoBean>($"name_{language.GetEnumName()}", $"'{name}'"));
}
public CoCoRaHSSiteService(LanguageEnum LanguageRequest, IPrincipal User)
: base(LanguageRequest, User)
{
}
public TVTypeUserAuthorizationService(LanguageEnum LanguageRequest, IPrincipal User)
: base(LanguageRequest, User)
{
_LogService = new LogService(LanguageRequest, User);
}
public static void SetDataSetLanguage(LanguageEnum lang)
{
_lang = lang;
}
public static void SetDataSetLanguage(string filename)
{
if (filename.EndsWith(families.langDE))
_lang = LanguageEnum.de_DE;
else if (filename.EndsWith(families.langEN))
_lang = LanguageEnum.en_GB;
}
private async Task <string> BuildMessage(string htmlMessage, string subject, string jsonParams = null, LanguageEnum language = LanguageEnum.es_ES)
{
var mailTemplate = await GetMailTemplate(language);
if (string.IsNullOrEmpty(mailTemplate) || !mailTemplate.Contains("{{body}}"))
{
throw new InvalidDataException("MailTemplate does not contain {{body}} format param");
}
var fullBodyHtml = htmlMessage;
if (!string.IsNullOrEmpty(jsonParams))
{
var json = JsonConvert.DeserializeObject(jsonParams);
if (json != null && json is JObject)
{
foreach (var param in json as JObject)
{
fullBodyHtml = fullBodyHtml.Replace("{" + param.Key + "}", param.Value.ToString());
}
}
}
mailTemplate = mailTemplate
.Replace("{{body}}", fullBodyHtml)
.Replace("{{subject}}", subject);
return(mailTemplate);
}
public void AdminController_RemoveUserTVItemAuthJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
LanguageEnum languageEnum = (culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en);
// Arrange
controllerAction = "RemoveUserTVItemAuthJSON";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
// Act
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
// Assert
Assert.AreEqual("", tvItemModelRoot.Error);
// Act
TVItemModel tvItemModelCountry = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, "Unique Country", TVTypeEnum.Country);
// Assert
Assert.AreEqual("", tvItemModelCountry.Error);
TVItemUserAuthorizationService tvItemUserAuthorizationService = new TVItemUserAuthorizationService(languageEnum, user);
// Arrange
TVItemUserAuthorizationModel tvItemUserAuthorizationModelNew = new TVItemUserAuthorizationModel();
tvItemUserAuthorizationModelNew.ContactTVItemID = contactModelListGood[2].ContactTVItemID;
tvItemUserAuthorizationModelNew.TVItemID1 = tvItemModelCountry.TVItemID;
tvItemUserAuthorizationModelNew.TVAuth = TVAuthEnum.Delete;
// Act
TVItemUserAuthorizationModel tvItemUserAuthorizationModelRet = tvItemUserAuthorizationService.PostAddTVItemUserAuthorizationDB(tvItemUserAuthorizationModelNew);
// Assert
Assert.AreEqual("", tvItemUserAuthorizationModelRet.Error);
Assert.AreEqual(contactModelListGood[2].ContactTVItemID, tvItemUserAuthorizationModelRet.ContactTVItemID);
Assert.AreEqual(tvItemUserAuthorizationModelNew.ContactTVItemID, tvItemUserAuthorizationModelRet.ContactTVItemID);
Assert.AreEqual(tvItemUserAuthorizationModelNew.TVItemID1, tvItemUserAuthorizationModelRet.TVItemID1);
Assert.AreEqual(tvItemUserAuthorizationModelNew.TVAuth, tvItemUserAuthorizationModelRet.TVAuth);
// Act
JsonResult jsonResult = controller.RemoveUserTVItemAuthJSON(tvItemUserAuthorizationModelRet.TVItemUserAuthorizationID) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
// Act
SetupTest(contactModelListGood[2], culture, controllerAction);
// Act
jsonResult = controller.RemoveUserTVItemAuthJSON(tvItemUserAuthorizationModelRet.TVItemUserAuthorizationID) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
retStr = (string)jsonResult.Data;
Assert.AreEqual(ControllerRes.NeedToBeAnAdministrator, retStr);
}
}
}
public void Query_Every_Property_Has_Get_Set_Test()
{
Type val1 = typeof(Query);
query.ModelType = val1;
Assert.AreEqual(val1, query.ModelType);
LanguageEnum val2 = (LanguageEnum)3;
query.Language = val2;
Assert.AreEqual(val2, query.Language);
string val3 = "Some text";
query.Lang = val3;
Assert.AreEqual(val3, query.Lang);
int val4 = 45;
query.Skip = val4;
Assert.AreEqual(val4, query.Skip);
int val5 = 45;
query.Take = val5;
Assert.AreEqual(val5, query.Take);
string val6 = "Some text";
query.Asc = val6;
Assert.AreEqual(val6, query.Asc);
string val7 = "Some text";
query.Desc = val7;
Assert.AreEqual(val7, query.Desc);
string val8 = "Some text";
query.Where = val8;
Assert.AreEqual(val8, query.Where);
string val9 = "Some text";
query.Extra = val9;
Assert.AreEqual(val9, query.Extra);
List <string> val10 = new List <string>()
{
"testing", "Bonjour Allo"
};
query.AscList = val10;
Assert.AreEqual(val10, query.AscList);
List <string> val11 = new List <string>()
{
"testing", "Bonjour Allo"
};
query.DescList = val11;
Assert.AreEqual(val11, query.DescList);
List <WhereInfo> val12 = new List <WhereInfo>()
{
new WhereInfo(), new WhereInfo()
};
query.WhereInfoList = val12;
Assert.AreEqual(val12, query.WhereInfoList);
bool val13 = true;
query.HasErrors = val13;
Assert.AreEqual(val13, query.HasErrors);
IEnumerable <ValidationResult> val42 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
query.ValidationResults = val42;
Assert.AreEqual(val42, query.ValidationResults);
}
public LanguageEvent(CombatItem evtcItem, long offset) : base(evtcItem, offset)
{
Language = evtcItem.SrcAgent < (ulong)LanguageEnum.Unknown ? (LanguageEnum)evtcItem.SrcAgent
: LanguageEnum.Unknown;
}
public static Loader GetLoader(LanguageEnum lang)
{
return(Languages[lang]);
}
public SolutionItem(string name, string path, LanguageEnum language)
: this(name, path, language, false, null)
{
}
public List <ReportTypeModel> GetReportTypeModelListWithTVTypeAndLanguageDB(TVTypeEnum TVType, LanguageEnum language)
{
List <ReportTypeModel> ReportTypeModelList = (from c in db.ReportTypes
where c.TVType == (int)TVType &&
c.Language == (int)language
orderby c.TVType
select new ReportTypeModel
{
Error = "",
ReportTypeID = c.ReportTypeID,
DBCommand = DBCommandEnum.Original,
TVType = (TVTypeEnum)c.TVType,
FileType = (FileTypeEnum)c.FileType,
UniqueCode = c.UniqueCode,
Language = (LanguageEnum)c.Language,
Name = c.Name,
Description = c.Description,
StartOfFileName = c.StartOfFileName,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).ToList <ReportTypeModel>();
return(ReportTypeModelList);
}
// 所有的子类需要自行处理本方法
protected virtual void updateResource(LanguageEnum lan)
{
Debug.Assert(lan != LanguageEnum.UNKNOWN);
}
public ReportTypeModel PostAddOrModifyReportTypeDB(FormCollection fc)
{
int tempInt = 0;
int ReportTypeID = 0;
TVTypeEnum TVType = TVTypeEnum.Error;
FileTypeEnum FileType = FileTypeEnum.Error;
string UniqueCode = "";
LanguageEnum Language = LanguageEnum.Error;
//string Name = "";
//string StartOfFileName = "";
//string Description = "";
int.TryParse(fc["ReportTypeID"], out ReportTypeID);
// if ReportTypeID == 0 then we should create a new one else we should modify the existing one
ReportTypeModel reportTypeModel = new ReportTypeModel();
if (ReportTypeID != 0)
{
reportTypeModel = GetReportTypeModelWithReportTypeIDDB(ReportTypeID);
if (!string.IsNullOrWhiteSpace(reportTypeModel.Error))
{
return(ReturnError(reportTypeModel.Error));
}
}
reportTypeModel.DBCommand = DBCommandEnum.Original;
int.TryParse(fc["TVType"], out tempInt);
TVType = (TVTypeEnum)tempInt;
reportTypeModel.TVType = TVType;
int.TryParse(fc["FileType"], out tempInt);
FileType = (FileTypeEnum)tempInt;
reportTypeModel.FileType = FileType;
UniqueCode = fc["UniqueCode"];
reportTypeModel.UniqueCode = UniqueCode;
int.TryParse(fc["Language"], out tempInt);
Language = (LanguageEnum)tempInt;
reportTypeModel.Language = Language;
reportTypeModel.Name = fc["Name"];
reportTypeModel.StartOfFileName = fc["StartOfFileName"];
reportTypeModel.Description = fc["Description"];
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
ReportTypeModel reportTypeModelHasUniqueCode = GetReportTypeModelWithUniqueCodeDB(UniqueCode);
if (string.IsNullOrWhiteSpace(reportTypeModelHasUniqueCode.Error))
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.UniqueCode)));
}
ReportTypeModel reportTypeModelRet = new ReportTypeModel();
using (TransactionScope ts = new TransactionScope())
{
if (ReportTypeID == 0)
{
reportTypeModelRet = PostAddReportTypeDB(reportTypeModel);
if (!string.IsNullOrWhiteSpace(reportTypeModelRet.Error))
{
return(ReturnError(reportTypeModelRet.Error));
}
LogModel logModel = _LogService.PostAddLogForObj("ReportTypes", reportTypeModelRet.ReportTypeID, LogCommandEnum.Add, reportTypeModelRet);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
}
else
{
reportTypeModelRet = PostUpdateReportTypeDB(reportTypeModel);
if (!string.IsNullOrWhiteSpace(reportTypeModelRet.Error))
{
return(ReturnError(reportTypeModelRet.Error));
}
LogModel logModel = _LogService.PostAddLogForObj("ReportTypes", reportTypeModelRet.ReportTypeID, LogCommandEnum.Change, reportTypeModelRet);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
}
ts.Complete();
}
return(GetReportTypeModelWithReportTypeIDDB(reportTypeModelRet.ReportTypeID));
}
private void chineseToolStripMenuItem_Click(object sender, EventArgs e)
{
//englishToolStripMenuItem.Checked = false;
//chineseToolStripMenuItem.CheckState = CheckState.Checked;
langid = LanguageEnum.LANG_ZH;
processToScreen();
}
public void TVFileLanguageService_TVFileLanguageModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
LanguageEnum LangToAdd = LanguageEnum.es;
using (TransactionScope ts = new TransactionScope())
{
TVFileLanguageModel tvFileLanguageModel = AddTVFileLanguageModel(LangToAdd);
Assert.AreEqual("", tvFileLanguageModel.Error);
tvFileLanguageModelNew.TVFileID = tvFileLanguageModel.TVFileID;
#region TVFileID
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
tvFileLanguageModelNew.TVFileID = 0;
string retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull(string.Format(ServiceRes._IsRequired, ServiceRes.TVFileID), retStr);
#endregion TVFileID
#region Language
tvFileLanguageModelNew.TVFileID = tvFileLanguageModel.TVFileID;
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
int Max = 2;
tvFileLanguageModelNew.Language = (LanguageEnum)1000;
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull(string.Format(ServiceRes._IsRequired, ServiceRes.Language), retStr);
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
tvFileLanguageModelNew.Language = LanguageEnum.en;
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull("", retStr);
#endregion Language
#region FileDescription
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
Max = 1000;
tvFileLanguageModelNew.FileDescription = randomService.RandomString("", 0);
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull("", retStr);
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
tvFileLanguageModelNew.FileDescription = randomService.RandomString("", Max + 1);
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull(string.Format(ServiceRes._MaxLengthIs_, ServiceRes.Language, Max), retStr);
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
tvFileLanguageModelNew.FileDescription = randomService.RandomString("", Max - 1);
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull("", retStr);
FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
tvFileLanguageModelNew.FileDescription = randomService.RandomString("", Max);
retStr = tvFileLanguageService.TVFileLanguageModelOK(tvFileLanguageModelNew);
Assert.IsNotNull("", retStr);
#endregion TVText
}
}
}
public List<CAMPAIGN> GetCampaignsByCategoryName(string CategoryName, LanguageEnum Language)
{
return _campaignDAO.GetCampaignsByCategoryName(CategoryName, Language);
}
/// <summary>
/// 获取翻译结果
/// </summary>
/// <param name="url">图片地址</param>
/// <param name="sourceLanguage">原文语言</param>
/// <param name="targetLanguage">译文语言</param>
/// <param name="extra"></param>
/// <returns></returns>
public async Task <GetImageTranslateResponse> GetImageTranslateAsync(string url, LanguageEnum sourceLanguage = LanguageEnum.中文, LanguageEnum targetLanguage = LanguageEnum.英语, string extra = null)
{
GetImageTranslateRequest getImageTranslateRequest = new GetImageTranslateRequest()
{
Url = url,
SourceLanguage = sourceLanguage.GetDescription(),
TargetLanguage = targetLanguage.GetDescription(),
Extra = extra
};
return(await BaseClient.GetImageTranslateSimplyAsync(getImageTranslateRequest));
}
public ReportTypeService(LanguageEnum LanguageRequest, IPrincipal User)
: base(LanguageRequest, User)
{
_LogService = new LogService(LanguageRequest, User);
}
public void ReportTypeLanguageExtraB_Every_Property_Has_Get_Set_Test()
{
string val1 = "Some text";
reportTypeLanguageExtraB.ReportTypeLanguageReportTest = val1;
Assert.AreEqual(val1, reportTypeLanguageExtraB.ReportTypeLanguageReportTest);
string val2 = "Some text";
reportTypeLanguageExtraB.LastUpdateContactText = val2;
Assert.AreEqual(val2, reportTypeLanguageExtraB.LastUpdateContactText);
string val3 = "Some text";
reportTypeLanguageExtraB.LanguageText = val3;
Assert.AreEqual(val3, reportTypeLanguageExtraB.LanguageText);
string val4 = "Some text";
reportTypeLanguageExtraB.TranslationStatusNameText = val4;
Assert.AreEqual(val4, reportTypeLanguageExtraB.TranslationStatusNameText);
string val5 = "Some text";
reportTypeLanguageExtraB.TranslationStatusDescriptionText = val5;
Assert.AreEqual(val5, reportTypeLanguageExtraB.TranslationStatusDescriptionText);
string val6 = "Some text";
reportTypeLanguageExtraB.TranslationStatusStartOfFileNameText = val6;
Assert.AreEqual(val6, reportTypeLanguageExtraB.TranslationStatusStartOfFileNameText);
int val7 = 45;
reportTypeLanguageExtraB.ReportTypeLanguageID = val7;
Assert.AreEqual(val7, reportTypeLanguageExtraB.ReportTypeLanguageID);
int val8 = 45;
reportTypeLanguageExtraB.ReportTypeID = val8;
Assert.AreEqual(val8, reportTypeLanguageExtraB.ReportTypeID);
LanguageEnum val9 = (LanguageEnum)3;
reportTypeLanguageExtraB.Language = val9;
Assert.AreEqual(val9, reportTypeLanguageExtraB.Language);
string val10 = "Some text";
reportTypeLanguageExtraB.Name = val10;
Assert.AreEqual(val10, reportTypeLanguageExtraB.Name);
TranslationStatusEnum val11 = (TranslationStatusEnum)3;
reportTypeLanguageExtraB.TranslationStatusName = val11;
Assert.AreEqual(val11, reportTypeLanguageExtraB.TranslationStatusName);
string val12 = "Some text";
reportTypeLanguageExtraB.Description = val12;
Assert.AreEqual(val12, reportTypeLanguageExtraB.Description);
TranslationStatusEnum val13 = (TranslationStatusEnum)3;
reportTypeLanguageExtraB.TranslationStatusDescription = val13;
Assert.AreEqual(val13, reportTypeLanguageExtraB.TranslationStatusDescription);
string val14 = "Some text";
reportTypeLanguageExtraB.StartOfFileName = val14;
Assert.AreEqual(val14, reportTypeLanguageExtraB.StartOfFileName);
TranslationStatusEnum val15 = (TranslationStatusEnum)3;
reportTypeLanguageExtraB.TranslationStatusStartOfFileName = val15;
Assert.AreEqual(val15, reportTypeLanguageExtraB.TranslationStatusStartOfFileName);
DateTime val16 = new DateTime(2010, 3, 4);
reportTypeLanguageExtraB.LastUpdateDate_UTC = val16;
Assert.AreEqual(val16, reportTypeLanguageExtraB.LastUpdateDate_UTC);
int val17 = 45;
reportTypeLanguageExtraB.LastUpdateContactTVItemID = val17;
Assert.AreEqual(val17, reportTypeLanguageExtraB.LastUpdateContactTVItemID);
bool val18 = true;
reportTypeLanguageExtraB.HasErrors = val18;
Assert.AreEqual(val18, reportTypeLanguageExtraB.HasErrors);
IEnumerable <ValidationResult> val57 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
reportTypeLanguageExtraB.ValidationResults = val57;
Assert.AreEqual(val57, reportTypeLanguageExtraB.ValidationResults);
}
public SolutionItem(string name, string path, LanguageEnum language)
: this(name, path, language, false, null)
{
}
public IDailyQueryBuilder Lang(LanguageEnum lang)
{
queryParams.Add("lang", lang.ToString());
return this;
}
public static async Task<IEnumerable<ISummonerSpell>> GetSummonerSpellsStaticInfosAsync(
this IHasSummonerSpells hasSummonerSpells,
SpellDataEnum? itemData = null,
RegionEnum? region = null,
LanguageEnum? languageCode = null,
string dataDragonVersion = null)
{
if (hasSummonerSpells == null) throw new ArgumentNullException("hasSummonerSpells");
var staticService = new StaticService(hasSummonerSpells.ApiConfiguration);
var allSummonerSpells = await staticService.GetSummonerSpellsAsync(
false,
itemData,
region,
languageCode,
dataDragonVersion);
return allSummonerSpells.Data
.Where(x => hasSummonerSpells.SummonerSpells.Select(z => z.ToString()).Contains(x.Value.Key))
.Select(x => x.Value);
}
public static Loader GetLoader(LanguageEnum lang)
{
return Languages[lang];
}
/// <summary>
/// This takes a csv file for the Staar Subject and unpivots it. It then saves it in the output folder.
/// </summary>
/// <param name="filePath">The *.csv path to read from.</param>
/// <param name="outPath">The folder to store the output.</param>
/// <param name="grade">The grade to be associated with the file(s).</param>
/// <param name="language">The language the test was taken in.</param>
/// <param name="x">The number of columns at the beginning.</param>
public void UnpivotStaarTestNarrow(string filePath, string outPath, LanguageEnum language)
{
var dataTable = new DataTable(string.Format("Parsed {0}", filePath));
int j;
var sb = new StringBuilder();
var fileName = Path.GetFileNameWithoutExtension(filePath);
var outFile = string.Format("{0}/{1} - Parsed Narrow.csv", outPath, fileName);
var emptyList = new[] { "0", "", "." };
//remove past file if it exists
if (File.Exists(outFile))
File.Delete(outFile);
//Validation
if (!filePath.Contains(".csv"))
throw new CustomException("This is not a csv file.");
//read the lines in. First row is headers. save it then remove
var rows = File.ReadAllLines(filePath).ToList();
var headers = rows[0].Trim().Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList();
rows.RemoveAt(0); //pop the top off
// check if second row is headers
var possibleHeader = rows[0].Trim().Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (!int.TryParse(possibleHeader[0], out j)) //check if second row of headers
{
headers.AddRange(possibleHeader);
rows.RemoveAt(0); //pop the top off
}
//Groom the headers
for (var i = 0; i < headers.Count; i++)
{
headers[i] = headers[i].Trim();
}
//find the first header that should be split. All previous are the 'first x'
var x = headers.FindIndex(h => h.Split(new[] { '_' }).Length > 1);
//setup the headers for the first X columns
for (var i = 0; i < x; i++)
{
if(!headers[i].Equals("GRADE"))
dataTable.Columns.Add(headers[i]);
}
//set up remaining headers
dataTable.Columns.Add("GRADE");
dataTable.Columns.Add("LanguageEnum");
dataTable.Columns.Add("Subject");
dataTable.Columns.Add("Demographic");
dataTable.Columns.Add("Category");
dataTable.Columns.Add("Value");
//Write the column names to the stringbuilder
var columnNames = dataTable.Columns.Cast<DataColumn>().Select(column => column.ColumnName);
sb.AppendLine(string.Join(",", columnNames));
//Begin adding data
var gradeIndex = headers.IndexOf("Grade");
var dataRow = dataTable.NewRow();
var writer = File.AppendText(outFile);
//Get grade to use
var rowSplit = rows.Select(row => row.Split(',')).ToList();
var foundGrade = gradeIndex != -1 ? rowSplit[0][gradeIndex] : "EOC";
foreach (var campus in rowSplit)
{
//fill the first columns. These are the same for every campus
FillFirstX(dataRow, campus, x); //First 6 (Campus, year, region, district, dname, cname)
dataRow["Grade"] = foundGrade;
dataRow["LanguageEnum"] = language.ToString();
//for each complex header whose category matches the current category make a demo and value
for (var i = x; i < headers.Count; i++)
{
//if the value is empty, skip it
if (emptyList.Contains(campus[i].Trim()))
continue;
//if it is not a triple (the first x columns), skip it
var triple = headers[i].Split(new[] { '_' }, 3);
if (triple.Length != 3)
continue;
//write the remaining values, then write to stringbuilder
dataRow["Subject"] = triple[0];
dataRow["Demographic"] = triple[1];
dataRow["Category"] = triple[2];
dataRow["Value"] = campus[i];
sb.AppendLine(string.Join(",", dataRow.ItemArray));
}
//write campus to file
writer.Write(sb.ToString());
sb.Clear();
}
writer.Flush();
writer.Close();
}
/// <summary>
/// Logs given message in given language to the console
/// </summary>
/// <param name="message">Message to log</param>
/// <param name="language">Language in which the message is logged</param>
public static void LogMessageToConsole(Message message, LanguageEnum language = LanguageEnum.En)
{
Console.WriteLine($"{DateTime.Now}:\t{message.GetMessage(language)}");
}
public void AdminController_SetUserTVTypeAuthJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
LanguageEnum languageEnum = (culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en);
// Arrange
controllerAction = "SetUserTVTypeAuthJSON";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVTypeUserAuthorizationService tvTypeUserAuthorizationService = new TVTypeUserAuthorizationService(languageEnum, user);
// Arrange
TVTypeUserAuthorizationModel tvTypeUserAuthorizationModelNew = new TVTypeUserAuthorizationModel();
tvTypeUserAuthorizationModelNew.ContactTVItemID = contactModelListGood[2].ContactTVItemID;
tvTypeUserAuthorizationModelNew.TVType = TVTypeEnum.Country;
tvTypeUserAuthorizationModelNew.TVAuth = TVAuthEnum.Delete;
// Act
TVTypeUserAuthorizationModel tvTypeUserAuthorizationModelRet = tvTypeUserAuthorizationService.GetTVTypeUserAuthorizationModelWithContactTVItemIDAndTVTypeDB(tvTypeUserAuthorizationModelNew.ContactTVItemID, tvTypeUserAuthorizationModelNew.TVType);
if (tvTypeUserAuthorizationModelRet.TVTypeUserAuthorizationID > 0)
{
// Act
tvTypeUserAuthorizationModelRet = tvTypeUserAuthorizationService.PostDeleteTVTypeUserAuthorizationDB(tvTypeUserAuthorizationModelRet.TVTypeUserAuthorizationID);
// Assert
Assert.AreEqual("", tvTypeUserAuthorizationModelRet.Error);
}
// Act
JsonResult jsonResult = controller.SetUserTVTypeAuthJSON(tvTypeUserAuthorizationModelNew) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
TVTypeUserAuthorizationModel tvTypeUserAuthorizationModel = (TVTypeUserAuthorizationModel)jsonResult.Data;
Assert.AreEqual("", tvTypeUserAuthorizationModel.Error);
Assert.AreEqual(tvTypeUserAuthorizationModelNew.ContactTVItemID, tvTypeUserAuthorizationModel.ContactTVItemID);
Assert.AreEqual(tvTypeUserAuthorizationModelNew.TVType, tvTypeUserAuthorizationModel.TVType);
Assert.AreEqual(tvTypeUserAuthorizationModelNew.TVAuth, tvTypeUserAuthorizationModel.TVAuth);
tvTypeUserAuthorizationModel.TVAuth = TVAuthEnum.Create;
// Act
jsonResult = controller.SetUserTVTypeAuthJSON(tvTypeUserAuthorizationModel) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
TVTypeUserAuthorizationModel tvTypeUserAuthorizationModel2 = (TVTypeUserAuthorizationModel)jsonResult.Data;
Assert.AreEqual("", tvTypeUserAuthorizationModel2.Error);
Assert.AreEqual(tvTypeUserAuthorizationModel.ContactTVItemID, tvTypeUserAuthorizationModel2.ContactTVItemID);
Assert.AreEqual(tvTypeUserAuthorizationModel.TVType, tvTypeUserAuthorizationModel2.TVType);
Assert.AreEqual(tvTypeUserAuthorizationModel.TVAuth, tvTypeUserAuthorizationModel2.TVAuth);
// Act
SetupTest(contactModelListGood[1], culture, controllerAction);
// Act
jsonResult = controller.SetUserTVTypeAuthJSON(tvTypeUserAuthorizationModel) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
tvTypeUserAuthorizationModel2 = (TVTypeUserAuthorizationModel)jsonResult.Data;
Assert.AreEqual(ControllerRes.NeedToBeAnAdministrator, tvTypeUserAuthorizationModel2.Error);
}
}
}
private void ChangeLanguage(LanguageEnum language)
{
if (language == LanguageEnum.Ukrainian)
{
pageChanger_SummEr.Content = "Сторінка";
ErrorOfMeasureOpener.Text = "Похибка вимірювання";
RestartButton_SummEr.Content = "Заново";
languageChanger_SummEr.Content = "Мова";
languageEng1.Text = "Англійська";
languageUkr1.Text = "Українська";
themeChanger_SummEr.Content = "Тема";
themeDark1.Text = "Темна";
themeLight1.Text = "Світла";
EnterNumberBlock_SummEr.Text = "Введіть кількість вимірювань:";
confProbBlockSE.Text = "Довірча ймовірність:";
marginErrorBlock.Text = "Гранична похибка:";
roundingIntBlock.Text = "Інтервал заокруглення:";
maxRowsEntering_SummEr.Header = "Максимальна кількість рядків в колонці";
maxRowsEntering_SummEr.PlaceholderText = $"зараз це {maxRows}";
EnterValuesBlock_SummEr.Text = "Введіть вимірювання";
if (summaryErrorOutput.Text != "")
{
Output();
}
for (int i = 0; i < textBoxesList.Count; i++)
{
if (textBoxesList[i].PlaceholderText == "Incorrect format")
{
textBoxesList[i].PlaceholderText = "Невірний формат";
}
}
if (NumOfValuesEntering_SummEr.PlaceholderText == "Incorrect format")
{
NumOfValuesEntering_SummEr.PlaceholderText = "Невірний формат";
}
if (confProbEnteringSE.PlaceholderText == "Incorrect format")
{
confProbEnteringSE.PlaceholderText = "Невірний формат";
}
if (marginErrorEntering.PlaceholderText == "Incorrect format")
{
marginErrorEntering.PlaceholderText = "Невірний формат";
}
if (roundingIntEntering.PlaceholderText == "Incorrect format")
{
roundingIntEntering.PlaceholderText = "Невірний формат";
}
}
if (language == LanguageEnum.English)
{
pageChanger_SummEr.Content = "Page";
ErrorOfMeasureOpener.Text = "Error of measure";
RestartButton_SummEr.Content = "Restart";
languageChanger_SummEr.Content = "Language";
languageEng1.Text = "English";
languageUkr1.Text = "Ukrainian";
themeChanger_SummEr.Content = "Theme";
themeDark1.Text = "Dark";
themeLight1.Text = "Light";
EnterNumberBlock_SummEr.Text = "Enter number of values:";
confProbBlockSE.Text = "Confidence probability:";
marginErrorBlock.Text = "Margin error:";
roundingIntBlock.Text = "Rounding interval:";
maxRowsEntering_SummEr.Header = "Maximal number of rows in column";
maxRowsEntering_SummEr.PlaceholderText = $"currently it is {maxRows}";
EnterValuesBlock_SummEr.Text = "Enter values";
if (summaryErrorOutput.Text != "")
{
Output();
}
for (int i = 0; i < textBoxesList.Count; i++)
{
if (textBoxesList[i].PlaceholderText == "Невірний формат")
{
textBoxesList[i].PlaceholderText = "Incorrect format";
}
}
if (NumOfValuesEntering_SummEr.PlaceholderText == "Невірний формат")
{
NumOfValuesEntering_SummEr.PlaceholderText = "Incorrect format";
}
if (confProbEnteringSE.PlaceholderText == "Невірний формат")
{
confProbEnteringSE.PlaceholderText = "Incorrect format";
}
if (marginErrorEntering.PlaceholderText == "Невірний формат")
{
marginErrorEntering.PlaceholderText = "Incorrect format";
}
if (roundingIntEntering.PlaceholderText == "Невірний формат")
{
roundingIntEntering.PlaceholderText = "Incorrect format";
}
}
}
public static TranslationResult TranslatedWithBaidu(string source, LanguageEnum from = LanguageEnum.Auto, LanguageEnum to = LanguageEnum.Auto)
{
var jsonResult = string.Empty;
try
{
var fromParam = from.ToString().ToLowerInvariant();
var toParam = to.ToString().ToLowerInvariant();
var randomNum = DateTime.Now.Millisecond.ToString();
var signFormatStr = string.Format("{0}{1}{2}{3}", ConstFile.App_Id, source, randomNum, ConstFile.Security_Code);
var md5Sign = EncryptWithMD5(signFormatStr);
var url = $"{ConstFile.baiduHost}?q={HttpUtility.UrlEncode(source, Encoding.UTF8)}&from={fromParam}&to={toParam}&appid={ConstFile.App_Id}&salt={randomNum}&sign={md5Sign}";
WebClient webClient = new WebClient();
jsonResult = webClient.DownloadString(url);
var result = JsonConvert.DeserializeObject <TranslationResult>(jsonResult);
return(result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(new TranslationResult());
}
public async Task SendEmailAsync(string toEmail, string toName, string subject, string htmlMessage, dynamic jsonParams = null, IEnumerable <object> attachmentsInline = null, IEnumerable <object> attachments = null, LanguageEnum language = LanguageEnum.es_ES)
{
var html = await BuildMessage(htmlMessage, subject, jsonParams == null?string.Empty : JsonConvert.SerializeObject(jsonParams), language);
await _emailSender.SendEmailAsync(toEmail, toName, subject, html, (EmailAttachments)attachmentsInline, (EmailAttachments)attachments);
}
/// <summary>
/// 获取用户基本信息
/// </summary>
/// <param name="userName">公众号</param>
/// <param name="openId">用户id</param>
/// <param name="language">语言</param>
/// <param name="errorMessage">返回获取是否成功</param>
/// <returns>返回用户基本信息；如果获取失败，返回null。</returns>
public static UserInfo GetUserInfo(string userName, string openId, LanguageEnum language, out ErrorMessage errorMessage)
{
return(GetUserInfo(userName, openId, language.ToString("g"), out errorMessage));
}
/// <summary>
/// 获取OAuth用户基本信息
/// </summary>
/// <param name="accessToken">网页access token</param>
/// <param name="openId">用户id</param>
/// <param name="language">语言</param>
/// <param name="errorMessage">返回获取是否成功</param>
/// <returns>返回用户基本信息；如果获取失败，返回null。</returns>
public static UserInfo GetOAuthUserInfo(string accessToken, string openId, LanguageEnum language, out ErrorMessage errorMessage)
{
return(OAuthAccessToken.GetUserInfo(accessToken, openId, language, out errorMessage));
}
public static void InicializeValidator(LanguageEnum languageValidation)
{
NHibernate.Validator.Cfg.Environment.LanguageValidation = languageValidation;
var provider = new NHibernateSharedEngineProvider();
NHibernate.Validator.Cfg.Environment.SharedEngineProvider = provider;
}
/// <summary>
/// This takes a csv file for the Staar Subject and unpivots it. It then saves it in the output folder.
/// </summary>
/// <param name="file">The *.csv path to read from.</param>
/// <param name="outPath">The folder to store the output.</param>
/// <param name="grade">The grade to be associated with the file(s).</param>
/// <param name="language">The language the test was taken in.</param>
/// <param name="x">The number of columns at the beginning.</param>
public void UnpivotStaarTestWide(string file, string outPath, LanguageEnum language)
{
//Validation
if (!file.Contains(".csv"))
throw new Exception("The file is not a csv file.");
//Lets unpivot this shit
Console.WriteLine("Unpivoting: {0}", file);
int j;
var demographics = Enum.GetValues(typeof(StaarDemographic)).Cast<StaarDemographic>().Select(c => c.ToString()).ToList();
var rows = File.ReadAllLines(file).ToList();
var headers = rows[0].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList();
var gradeIndex = headers.IndexOf("GRADE");
rows.RemoveAt(0); //pop the top off
var possibleHeader = rows[0].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (!int.TryParse(possibleHeader[0], out j)) //check if second row of headers
{
headers.AddRange(possibleHeader);
rows.RemoveAt(0); //pop the top off
}
var sdc = headers.Select(h => h.Split(new[] { '_' }, 3)).ToList();
var dynamicCategories = sdc
.Where(s => s.Count() == 3)
.Select(s => s[2])
.Distinct()
.Except(_excludedCategories)
.ToList();
//begin changing stuff
var dataTable = new DataTable(string.Format("Parsed {0}", file));
//find the first header that should be split. All previous are the 'first x'
var x = headers.FindIndex(h => h.Split(new[] { '_' }).Length > 1);
//first X
for (var i = 0; i < x; i++)
{
if(!headers[i].Equals("GRADE"))
dataTable.Columns.Add(headers[i]);
}
//subject, grade, language, category
dataTable.Columns.Add("Subject");
dataTable.Columns.Add("Grade");
dataTable.Columns.Add("Language");
dataTable.Columns.Add("Category");
var genericHeaders = new List<string>(new[] { "Subject", "Grade", "Language" });
//weird ones
foreach (var cat in _excludedCategories)
{
dataTable.Columns.Add(cat);
}
//demographics
foreach (var demo in demographics)
{
dataTable.Columns.Add(demo);
}
//Write the column names to the sb
var sb = new StringBuilder();
var columnNames = dataTable.Columns.Cast<DataColumn>().Select(column => column.ColumnName);
sb.AppendLine(string.Join(",", columnNames));
//Begin adding data
var dataRow = dataTable.NewRow();
foreach (var campus in rows.Select(row => row.Split(',')))
{
//find subjects
var subjs = sdc
.Where(s => s.Count() == 3)
.Select(s => s[0])
.Distinct()
.ToList();
//set up basic set
var lang = language == LanguageEnum.English ? "English" : "Spanish";
var foundGrade = gradeIndex != -1 ? campus[gradeIndex] : "EOC";
FillFirstX(dataRow, campus, x);
FillWeirdHeaders(dataRow, headers, campus);
FillGenericData(dataRow, genericHeaders, foundGrade, lang);
foreach (var subj in subjs)
{
foreach (var category in dynamicCategories)
{
//for each complex header whose category matches the current category
for (var i = 6; i < headers.Count; i++)
{
if (sdc[i].Length == 3 && sdc[i][0] == subj && sdc[i][2] == category)
{
//set the data column of the found demographic equal to the
dataRow[sdc[i][1]] = campus[i];
}
}
//add the category, then write to sb
dataRow["Category"] = category;
dataRow["Subject"] = subj;
sb.AppendLine(string.Join(",", dataRow.ItemArray));
//dataTable.Rows.Add(dataRow);
}
}
}
var fileName = Path.GetFileNameWithoutExtension(file);
File.WriteAllText(string.Format("{0}/{1} - Parsed Wide.csv", outPath, fileName), sb.ToString());
}
