public IActionResult AddTranslation(TranslationAddModel model) { if (ModelState.IsValid) { using (var uow = _localizationDataService.StartUnitOfWork()) { var resource = uow.ResourceRepository.Get(model.ResourceId); if (resource == null) { return(RedirectToAction(nameof(Index))); } var translation = uow.TranslationRepository.ByResource(resource).SingleOrDefault(t => t.Language == model.Language); if (translation != null) { return(RedirectToAction(nameof(EditTranslation), new { id = translation.Id })); } var newTranslation = new TranslationEntity { ResourceId = model.ResourceId, Language = model.Language, Value = model.Value }; uow.TranslationRepository.Add(newTranslation); uow.Commit(); } } return(View(model)); }
public void ShouldReturnTheNumberTranslation(string originalNumber, int translateNumber) { TranslationEntity translation = new TranslationEntity(); translation.TranslateKwegonian(originalNumber); translation.ArabicNumeral.Should().Be(translateNumber); }
public void ShouldReturnNullIfNotTranslates() { TranslationEntity translation = new TranslationEntity(); translation.TranslateKwegonian("popo"); translation.ArabicNumeral.Should().BeNull(); }
public TranslationEntity CreateTranslation(int language) { var t = new TranslationEntity { Language = language }; t.MakeDirty(); return(t); }
public Response <decimal> KwegonianToDecimal(string kwegonianNumber) { try { var listNumbers = SeparateText(kwegonianNumber); int result = 0; for (int i = 0; i < listNumbers.Length; i++) { var translete = new TranslationEntity(); int arabicNumeral1 = SetArabicNumeral(translete, listNumbers[i]); if (arabicNumeral1 == 0) { return(Response <decimal> .Fail("Number not exists")); } if (i + 1 < listNumbers.Length) { int arabicNumeral2 = SetArabicNumeral(translete, listNumbers[i + 1]); if (arabicNumeral2 == 0) { return(Response <decimal> .Fail("Number not exists")); } if (arabicNumeral1 >= arabicNumeral2) { result += arabicNumeral1; } else { result = result + arabicNumeral2 - arabicNumeral1; i++; } } else { result += arabicNumeral1; i++; } } return(Response <decimal> .Ok(result)); } catch (Exception) { //TODO: Fazer LOG da Exception throw; } }
public bool IsTranslationUnique(TranslationEntity expressionToCheck) { bool res; Log.StartTiming(); using (var context = GetContext()) { res = context.IsTranslationUnique(expressionToCheck); } Log.StopTiming(); return(res); }
public static TranslationResponseModel SendTranslation(TranslationEntity translation) { TranslationResponseModel response = new TranslationResponseModel() { English = translation.English, German = translation.German, GroupId = translation.GroupId, Messages = new string[] { "Translation returned" }, StatusCode = System.Net.HttpStatusCode.OK, Success = true }; return(response); }
private static void ClearStatistics(TranslationEntity e) { e.BadAnswers = 0; e.GoodAnswers = 0; e.WasLastAnswerGood = true; e.SpellingBadAnswers = 0; e.SpellingGoodAnswers = 0; e.SpellingWasLastAnswerGood = true; e.ReverseBadAnswers = 0; e.ReverseGoodAnswers = 0; e.ReverseWasLastAnswerGood = true; e.ReverseSpellingBadAnswers = 0; e.ReverseSpellingGoodAnswers = 0; e.ReverseSpellingWasLastAnswerGood = true; }
private static void CopyStatistics(TranslationEntity source, TranslationEntity dest) { dest.BadAnswers = source.BadAnswers; dest.GoodAnswers = source.GoodAnswers; dest.WasLastAnswerGood = source.WasLastAnswerGood; dest.SpellingBadAnswers = source.SpellingBadAnswers; dest.SpellingGoodAnswers = source.SpellingGoodAnswers; dest.SpellingWasLastAnswerGood = source.SpellingWasLastAnswerGood; dest.ReverseBadAnswers = source.ReverseBadAnswers; dest.ReverseGoodAnswers = source.ReverseGoodAnswers; dest.ReverseWasLastAnswerGood = source.ReverseWasLastAnswerGood; dest.ReverseSpellingBadAnswers = source.ReverseSpellingBadAnswers; dest.ReverseSpellingGoodAnswers = source.ReverseSpellingGoodAnswers; dest.ReverseSpellingWasLastAnswerGood = source.ReverseSpellingWasLastAnswerGood; }
HelperNormaliseTransliteSection(List <IRowItem> listRowItems) { Dictionary <ITranslationEntity, List <ITranslationEntity> > sections = new Dictionary <ITranslationEntity, List <ITranslationEntity> >(); IDataResult <Dictionary <ITranslationEntity, List <ITranslationEntity> > > dataResult = new DataResult <Dictionary <ITranslationEntity, List <ITranslationEntity> > >(); foreach (var rowItem in listRowItems) { List <ITranslationEntity> translationEntities = new List <ITranslationEntity>(); ITranslationEntity translationKey = new TranslationEntity(); foreach (var columnItem in rowItem.ColumnItems) { ITranslationEntity entity = columnItem.BaseEntity as ITranslationEntity; switch (columnItem.ColumnType) { case ColumnType.Section: if (entity != null) { translationKey.Value = entity.Value; translationKey.Language = entity.Language; } break; case ColumnType.SectionTransfer: ITranslationEntity tmpEntity = new TranslationEntity(); tmpEntity.Language = entity.Language; tmpEntity.Value = entity.Value; translationEntities.Add(tmpEntity); break; } } sections.Add(translationKey, translationEntities); } dataResult.Success = true; dataResult.Data = sections; return(dataResult); }
public static string GetTranslation(SECTION sectionID, int translationID) { string retVal = ""; List <TranslationEntity> model = new List <TranslationEntity>(); model = GetTranslationSection(sectionID); if (model != null) { TranslationEntity myQuery = model.Find(x => x.TranslationID.Equals(translationID)); if (myQuery != null) { retVal = myQuery.TranslationText; if (_debug) { retVal = retVal + _method; } } } return(retVal); }
private IBaseEntity GetBaseEntity(IExcelWorksheetEntity excelWorksheet, string data, int column, ExcelConfiguration excelConfiguration) { IBaseEntity baseEntity = new BaseEntity() { Value = data }; if (column == excelConfiguration.DataColumn .Datas.FirstOrDefault(p => p.ColumnType == (int)ColumnType.Section)?.Nomer || column == excelConfiguration.DataColumn.Datas .FirstOrDefault(p => p.ColumnType == (int)ColumnType.Language)?.Nomer) { string name = excelConfiguration.NameColumnSection.MainLanguage; ITranslationEntity entity = new TranslationEntity(); entity.Language = LanguageHolder.GetISOCodes(name, _dataNormalization); entity.Value = data; return(entity); } if (column == excelConfiguration.DataColumn.Datas .FirstOrDefault(p => p.ColumnType == (int)ColumnType.Picture)?.Nomer) { IDataResult <string> colorNameResult = _readExcelData.GetColorValue(excelWorksheet); IExcelColor excelColor = new ExcelColor(); if (colorNameResult.Success) { Color color = ColorTranslator.FromHtml("#" + colorNameResult.Data); excelColor.R = color.R; excelColor.G = color.G; excelColor.B = color.B; } return(excelColor); } return(baseEntity); }
public IDataResult <IColumnItem> ColumnParser (IExcelWorksheetEntity excelWorksheet, ExcelConfiguration excelConfiguration) { IDataResult <IColumnItem> dataResult = new DataResult <IColumnItem>() { Success = false }; IColumnItem columnItem = new ColumnItem(); int column = excelWorksheet.CellNo; IDataResult <string> resultValue = _readExcelData.GetValue(excelWorksheet); int nomertitle = excelConfiguration.DataRowIndex.Title; IExcelWorksheetEntity tmpExcel = new ExcelWorksheetEntity(); tmpExcel.RowNo = nomertitle; tmpExcel.ExcelWorksheet = excelWorksheet.ExcelWorksheet; tmpExcel.CellNo = column; string nameTitle = _readExcelData.GetValue(tmpExcel).Data; string configNameSection = excelConfiguration.DataColumn.Datas .FirstOrDefault(p => p.ColumnType == (int)ColumnType.Section)?.Name; configNameSection = _dataNormalization.NormalizeString(configNameSection).Data; columnItem.BaseEntity = new BaseEntity(); bool isResult = false; foreach (var data in excelConfiguration.DataColumn.Datas) { if (column == data.Nomer) { if (!resultValue.Success) { if (data.MustExist) { dataResult.Message += resultValue.Message; } } columnItem.ColumnType = (ColumnType)data.ColumnType; columnItem.BaseEntity = GetBaseEntity (excelWorksheet, resultValue.Data, column, excelConfiguration); isResult = true; } } if (!isResult) { nameTitle = _dataNormalization.NormalizeString(nameTitle).Data; if (nameTitle == null) { //TODO dataResult.Success = true; return(dataResult); } if (nameTitle.Contains(configNameSection)) { columnItem.ColumnType = ColumnType.SectionTransfer; nameTitle = nameTitle.Replace(configNameSection, string.Empty); } else { columnItem.ColumnType = ColumnType.WorldSection; } dataResult.Message += resultValue.Message; string language = LanguageHolder.GetISOCodes(nameTitle, _dataNormalization); ITranslationEntity entity = new TranslationEntity(); entity.Language = language; entity.Value = resultValue.Data; columnItem.BaseEntity = entity; } columnItem.ColumNumber = column; dataResult.Data = columnItem; dataResult.Success = true; return(dataResult); }
public bool IsTranslationUnique(TranslationEntity translationToCheck) { translationToCheck.NotNull("translationToCheck"); return(Translations.Any(t => t.Translation == translationToCheck.Translation)); }
private int SetArabicNumeral(TranslationEntity translete, string number) { translete.TranslateKwegonian(number); return(translete.ArabicNumeral == null ? 0 : Convert.ToInt32(translete.ArabicNumeral)); }
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ private static IEnumerable <IDictionary <string, object> > GetExistingTranslations <TEntity, TTranslatedEntity>(this DbContext context, TEntity entity, TranslationEntity translationEntity, Translation <TEntity>[] translationEntities) where TEntity : class where TTranslatedEntity : class { var schema = !string.IsNullOrWhiteSpace(translationEntity.Schema) ? $"[{translationEntity.Schema}]." : string.Empty; var query = new StringBuilder(); query.Append("SELECT "); query.Append(string.Join(" ,", context.Model.FindEntityType(translationEntity.Type).GetProperties().Select(property => $"[t].[{property.GetColumnName()}]"))); query.Append($" FROM {schema}[{translationEntity.TableName}] AS [t]"); query.Append(" WHERE "); query.Append(string.Join(" AND ", translationEntity.KeysFromSourceEntity .Select(property => $"[t].[{property.Value}] = @{property.Value}"))); query.Append(" AND ("); query.Append(string.Join(" OR ", translationEntities .Select((translation, index) => string.Join(" ,", translationEntity.KeysFromLanguageEntity .Select(key => $"[t].[{key.Name}] = @{key.Name}{index}"))))); query.Append(" );"); using (var command = context.Database.GetDbConnection().CreateCommand()) { #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities command.CommandText = query.ToString(); #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities foreach (var parameter in translationEntity.KeysFromSourceEntity .Select(property => (Name: property.Value, Value: entity.GetType().GetProperty(property.Key).GetValue(entity)))) { command.AddParameterWithValue(parameter.Name, parameter.Value); } foreach (var parameter in translationEntities.Select((translation, entityIndex) => translationEntity.KeysFromLanguageEntity .Select((key, keyIndex) => (Name: $"{key.Name}{entityIndex}", Value: translation.LanguageKey[keyIndex]))) .SelectMany(tuple => tuple)) { command.AddParameterWithValue(parameter.Name, parameter.Value); } context.Database.OpenConnection(); using (var reader = command.ExecuteReader()) { while (reader.Read()) { yield return(SqlDataReaderToExpando(reader)); } } } }
public IDataResult <IColumnItem> ColumnParser (IExcelWorksheetEntity worksheetEntity, ExcelConfiguration excelConfiguration) { IDataResult <IColumnItem> dataResult = new DataResult <IColumnItem>() { Success = false }; IColumnItem columnItem = new ColumnItem(); int column = worksheetEntity.CellNo; IDataResult <string> resultValue = _readExcelData.GetValue(worksheetEntity); int nomertitle = excelConfiguration.DataRowIndex.Title; if (!resultValue.Success) { dataResult.Message = resultValue.Message; } IExcelWorksheetEntity tmpExcel = new ExcelWorksheetEntity(); tmpExcel.RowNo = nomertitle; tmpExcel.ExcelWorksheet = worksheetEntity.ExcelWorksheet; tmpExcel.CellNo = column; IDataResult <string> resultNameTitle = _readExcelData.GetValue(tmpExcel); if (!resultNameTitle.Success) { dataResult.Message = MessageHolder.GetErrorMessage(MessageType.NotNameTitle); } string nameTitle = resultNameTitle.Data; nameTitle = _dataNormalization.NormalizeString(nameTitle).Data; string titleConfig = excelConfiguration.DataColumn.Datas? .FirstOrDefault(p => p.ColumnType == (int)ColumnType.Section)?.Name; titleConfig = _dataNormalization.NormalizeString(titleConfig).Data; ITranslationEntity translationEntity = new TranslationEntity(); translationEntity.Value = resultValue.Data; string mainLanguage = excelConfiguration.NameColumnSection.MainLanguage; mainLanguage = _dataNormalization.NormalizeString(mainLanguage).Data; string excelLanguage = null; if (titleConfig != null) { excelLanguage = nameTitle.Replace(titleConfig, string.Empty); } if (nameTitle.Equals(titleConfig) || (excelLanguage != null && excelLanguage.Equals(mainLanguage))) { columnItem.ColumnType = ColumnType.Section; translationEntity.Language = LanguageHolder.GetISOCodes(mainLanguage, _dataNormalization); if (!resultValue.Success) { dataResult.Message = resultValue.Message; return(dataResult); } columnItem.BaseEntity = translationEntity; } else { columnItem.ColumnType = ColumnType.SectionTransfer; translationEntity.Language = LanguageHolder.GetISOCodes(excelLanguage, _dataNormalization); if (!resultValue.Success) { dataResult.Message = resultValue.Message; return(dataResult); } columnItem.BaseEntity = translationEntity; } dataResult.Data = columnItem; dataResult.Success = true; return(dataResult); }
private Result Validate(TranslationEntity translation) { var placeholder = translation?.Placeholder?.Name; return(IsPlaceholderValid(placeholder) ? Result.Ok() : Result.Fail($"Placeholder '{placeholder}' has invalid format or contains forbidden characters")); }
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ private static void ConfigureKeys(this EntityTypeBuilder builder, IMutableEntityType entity, IMutableEntityType languageBuilder, TranslationEntity configuration) { var primaryKeys = new List <string>(); //Source Table foreach (var key in entity.GetProperties().Where(p => p.IsPrimaryKey())) { string name = $"{entity.ClrType.Name}{key.GetColumnName()}"; builder.Property(key.ClrType, name) .HasColumnType(key.GetColumnType()); primaryKeys.Add(name); configuration.KeysFromSourceEntity.Add(key.GetColumnName(), name); } builder.HasOne(entity.ClrType) .WithMany() .HasForeignKey(primaryKeys.ToArray()) .OnDelete(configuration.DeleteBehavior); //Language Table if (languageBuilder == null) { foreach (var key in TranslationConfiguration.LanguageTableConfiguration.PrimaryKey) { builder.Property(key.Type, key.Name); primaryKeys.Add(key.Name); configuration.KeysFromLanguageEntity.Add(new KeyConfiguration(key.Type, key.Name)); } } else { var foreignKeys = new List <KeyConfiguration>(); foreach (var property in languageBuilder.GetProperties().Where(p => p.IsPrimaryKey())) { string name = $"{languageBuilder.ClrType.Name}{property.GetColumnName()}"; builder.Property(property.ClrType, name) .HasColumnType(property.GetColumnType()); primaryKeys.Add(name); foreignKeys.Add(new KeyConfiguration(property.ClrType, name)); configuration.KeysFromLanguageEntity.Add(new KeyConfiguration(property.ClrType, name)); } builder.HasOne(languageBuilder.ClrType) .WithMany() .HasForeignKey(foreignKeys.Select(fk => fk.Name).ToArray()) .OnDelete(configuration.DeleteBehavior); TranslationConfiguration.LanguageTableConfiguration = new LanguageTableConfiguration(foreignKeys); } builder.HasKey(primaryKeys.ToArray()); }