private async Task <SyncBase> AddUserWordPairAsync(int userId, WordTranslation wordTranslation)
{
// add word pair in repository
WordPair wordPair = await AddPairAsync(wordTranslation).ConfigureAwait(false);
// Load a word from a cell of a foreign word
Word wordForeign = await wordRepository.FindById(wordPair.WordForeignId).ConfigureAwait(false);
// If the loaded foreign word does not match the word
// in the repository then the pair is considered inverted
var createdPair = new UserWordPair
{
WordPairId = wordPair.WordPairId,
IsInvertPair = !wordForeign.Content.Equals(wordTranslation.WordForeign.ToLower()),
UserId = userId
};
// add pair to user dictionary
createdPair = await userWordPairRepository.Stack(createdPair).ConfigureAwait(false);
// create answer
var resultPair = new SyncBase
{
Id = wordTranslation.Id,
ServerId = createdPair.UserWordPairId
};
return(resultPair);
}
public async void DeleteAsync_IfDependencyDoesntExists()
{
//Arrange
int originalId = 1;
int translationId = 2;
WordTranslation transl = new WordTranslation()
{
OriginalWordId = originalId,
TranslationWordId = translationId
};
IQueryable <WordTranslation> wordTranslations = new List <WordTranslation>
{
transl
}.AsQueryable <WordTranslation>();
var mockSet = GenerateMockDbSet <WordTranslation>(wordTranslations);
_repo.Setup(r => r.GetAll()).Returns(mockSet.Object);
_uow.Setup(x => x.SaveAsync()).ReturnsAsync(1);
_repo.Setup(r => r.Delete(originalId, translationId)).Verifiable();
//Act
var actual = await _service.DeleteAsync(originalId, translationId);
//Assert
Assert.IsTrue(actual);
_factory.Verify(x => x.GetUnitOfWork(), Times.Exactly(2));
_uow.Verify(x => x.WordTranslationRepository, Times.Exactly(2));
_repo.Verify(x => x.GetAll(), Times.Once());
_uow.Verify(x => x.SaveAsync(), Times.Once);
_repo.VerifyAll();
}
WordTranslation GetDerivedTranslation(string derivedWord)
{
Load(derivedWord);
WordTranslation derivedTrans = new WordTranslation(derivedWord);
derivedTrans.translation = GetDefinition(derivedWord);
return(derivedTrans);
}
public WordTranslationModel Map(WordTranslation WordTranslation)
{
WordTranslationModel wordTranslationModel = new WordTranslationModel();
wordTranslationModel.Id = WordTranslation.Id;
wordTranslationModel.TranslationWord = WordTranslation.TranslationWord.Value;
return(wordTranslationModel);
}
public int Add(WordTranslation wordTranslation)
{
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
uow.WordTranslationRepository.AddOrUpdate(wordTranslation);
uow.Save();
return(wordTranslation.Id);
}
}
public async Task CopywordsuitesForTeacherByIdAsync_ReturnsBool_Positive()
{
//Arrange
int teacherId = 1;
int wordSuiteId = 2;
int wordSuiteOwnerId = 3;
int saveAsyncPositiveResult = 1;
Mock <IUserRepository> _usersRepo = new Mock <IUserRepository>();
Mock <IWordProgressRepository> _wordProgressRepo = new Mock <IWordProgressRepository>();
_uow.Setup(u => u.UserRepository).Returns(_usersRepo.Object);
_uow.Setup(u => u.WordProgressRepository).Returns(_wordProgressRepo.Object);
WordSuite workSuite = new WordSuite
{
Id = wordSuiteId,
OwnerId = wordSuiteOwnerId
};
User teacherWhoShare = new User
{
Id = wordSuiteOwnerId
};
WordTranslation wordTranslation = new WordTranslation();
IQueryable <WordProgress> wordProgresses = new List <WordProgress>
{
new WordProgress
{
WordSuiteId = wordSuiteId,
WordTranslation = wordTranslation
}
}.AsQueryable <WordProgress>();
var mockSet = GenerateMockDbSet <WordProgress>(wordProgresses);
_repo.Setup(r => r.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(workSuite);
_usersRepo.Setup(u => u.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(teacherWhoShare);
_wordProgressRepo.Setup(r => r.GetAll()).Returns(mockSet.Object);
_wordProgressRepo.Setup(r => r.Add(It.IsAny <IEnumerable <WordProgress> >()));
_repo.Setup(r => r.Add(It.IsAny <WordSuite>()));
_uow.Setup(u => u.SaveAsync()).ReturnsAsync(saveAsyncPositiveResult);
//Act
var actual = await _service.CopyWordsuitesForTeacherByIdAsync(teacherId, wordSuiteId);
bool expected = true;
//Assert
_repo.Verify(r => r.Add(It.Is <WordSuite>((ws => ws.OwnerId == teacherId))));
_repo.Verify(r => r.GetByIdAsync(It.IsAny <int>()), Times.Once);
_usersRepo.Verify(u => u.GetByIdAsync(It.IsAny <int>()), Times.Once);
_wordProgressRepo.Verify(r => r.GetAll(), Times.Once);
_wordProgressRepo.Verify(r => r.Add(It.IsAny <IEnumerable <WordProgress> >()), Times.Once);
_repo.Verify(r => r.Add(It.IsAny <WordSuite>()), Times.Once);
_uow.Verify(u => u.SaveAsync(), Times.Once);
Assert.AreEqual(actual, expected);
}
public int Add(WordTranslation wordTranslation)
{
using (var context = new WorldOfWordsDatabaseContext())
{
context.WordTranslations.Add(wordTranslation);
context.SaveChanges();
return(wordTranslation.Id);
}
}
public WordTranslationModel Map(WordTranslation WordTranslation)
{
WordTranslationModel wordTranslationModel = new WordTranslationModel();
wordTranslationModel.Id = WordTranslation.Id;
wordTranslationModel.OriginalWordDesc = WordTranslation.OriginalWord.Description;
wordTranslationModel.TranslationWord = WordTranslation.TranslationWord.Value;
return(wordTranslationModel);
}
public int Add(WordTranslation wordTranslation)
{
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
//var ids = wordTranslation.Tags.Select(tag => tag.Id);
//wordTranslation.Tags = uow.TagRepository.GetAll().Where(t => ids.Contains(t.Id)).ToList();
uow.WordTranslationRepository.AddOrUpdate(wordTranslation);
uow.Save();
return(wordTranslation.Id);
}
}
/// <summary>
/// Получает изображение для слова с переводом
/// </summary>
/// <param name="id">идентификатор слова с переводом, для которого нужно получить изображение</param>
/// <returns>массив байт представляющий изображение</returns>
public byte[] GetImageById(long id)
{
byte[] result = Adapter.ReadByContext(c => {
IQueryable <WordTranslation> wordTranslationsQuery = (from wt in c.WordTranslation
where wt.Id == id
select wt);
WordTranslation wordTranslation = wordTranslationsQuery.FirstOrDefault();
return(wordTranslation != null ? wordTranslation.Image : null);
});
return(result);
}
public async Task <int> AddAsync(WordTranslationImportModel wordTranslation)
{
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
WordTranslation wordToAdd = wordTranslationMapper.Map(wordTranslation);
uow.WordTranslationRepository.AddOrUpdate(wordToAdd);
await uow.SaveAsync();
return(wordToAdd.Id);
}
}
public WordTranslationImportModel MapToImportModel(WordTranslation wordTranslation)
{
return(new WordTranslationImportModel()
{
OriginalWord = wordTranslation.OriginalWord.Value,
OriginalWordId = wordTranslation.OriginalWordId,
Transcription = wordTranslation.OriginalWord.Transcription,
Description = wordTranslation.OriginalWord.Description,
TranslationWord = wordTranslation.TranslationWord.Value,
TranslationWordId = wordTranslation.TranslationWordId
});
}
/// <summary>
/// Convert UserWorkPair to WordTranslation
/// </summary>
/// <param name="uwp"></param>
/// <returns></returns>
public static WordTranslation ToWordTranslations(this UserWordPair uwp)
{
Word foreign = uwp.WordPair.WordForeign;
Word native = uwp.WordPair.WordNative;
WordTranslation addedWord = uwp.IsInvertPair
? new WordTranslation(native.Content, foreign.Content)
: new WordTranslation(foreign.Content, native.Content);
addedWord.ServerId = uwp.UserWordPairId;
return(addedWord);
}
private static bool TryParseWordTranslation(string source, out WordTranslation wordTranslation)
{
wordTranslation = null;
string[] words = source.Split(WORDS_SPLIT).RemoveEmpty();
;
if (words.Length != 2)
{
return(false);
}
wordTranslation = new WordTranslation(words[0], words[1]);
return(true);
}
private static WordTranslation GetWordTranslation(StudyLanguageContext context,
Word sourceWord,
Word translationWord)
{
IQueryable <WordTranslation> wordsWithTranslationsQuery = (from wt in context.WordTranslation
where
wt.WordId1 == sourceWord.Id &&
wt.WordId2 == translationWord.Id
select wt);
WordTranslation wordTranslation = wordsWithTranslationsQuery.FirstOrDefault();
return(wordTranslation);
}
public WordTranslationModel Map(WordTranslation wordTranslation)
{
if (wordTranslation == null)
{
throw new ArgumentNullException("wordTranslation");
}
return(new WordTranslationModel()
{
Id = wordTranslation.Id,
OriginalWord = wordTranslation.OriginalWord.Value,
TranslationWord = wordTranslation.TranslationWord.Value
});
}
public Task <WordPair> AddPairAsync(WordTranslation wordTranslation)
{
var firstWordForeign = new Word
{
Content = wordTranslation.WordForeign
};
var secondWordNative = new Word
{
Content = wordTranslation.WordNative
};
return(wordPairRepository.Stack(firstWordForeign, secondWordNative));
}
WordTranslation GetInitialTranslation(string word)
{
Load(word);
if (HasInitialForm())
{
word = GetInitialWord();
Load(word);
}
WordTranslation initial = new WordTranslation(word);
initial.translation = GetDefinition(word);
return(initial);
}
public WordTranslationImportModel MapToImportModel(WordTranslation wordTranslation)
{
return(new WordTranslationImportModel()
{
OriginalWord = wordTranslation.OriginalWord.Value,
OriginalWordId = wordTranslation.OriginalWordId,
Transcription = wordTranslation.OriginalWord.Transcription,
Description = wordTranslation.OriginalWord.Description,
TranslationWord = wordTranslation.TranslationWord.Value,
TranslationWordId = wordTranslation.TranslationWordId,
LanguageId = wordTranslation.OriginalWord.LanguageId,
PartOfSpeechId = wordTranslation.OriginalWord.PartOfSpeechId,
Comment = wordTranslation.OriginalWord.Comment
});
}
public void IncrementProgressOfOriginalWord_True()
{
//Arrange
int wordSuiteId = 5;
string originalWord = "test";
Word _word = new Word()
{
Value = "test"
};
WordTranslation _wordTranslation = new WordTranslation()
{
OriginalWordId = 2,
OriginalWord = _word,
};
WordProgress _wordProgress = new WordProgress()
{
IsStudentWord = false,
WordTranslationId = 2,
Progress = 4,
WordSuite = null,
WordSuiteId = 5,
WordTranslation = _wordTranslation
};
IQueryable <WordProgress> _queryable = new List <WordProgress>
{
_wordProgress
}.AsQueryable();
_uow.Setup(u => u.WordProgressRepository).Returns(_progressRepository.Object);
_progressRepository.Setup(p => p.GetAll()).Returns(_queryable);
_progressRepository.Setup(p => p.AddOrUpdate(_wordProgress));
_uow.Setup(u => u.Save()).Verifiable();
//Act
bool result = new WordProgressService(_factory.Object).IncrementProgressOfOriginalWord(wordSuiteId, originalWord);
//Assert
_factory.Verify(f => f.GetUnitOfWork(), Times.Once);
_uow.Verify(u => u.WordProgressRepository, Times.Exactly(2));
_progressRepository.Verify(p => p.GetAll(), Times.Exactly(1));
_progressRepository.Verify(p => p.AddOrUpdate(_wordProgress), Times.Exactly(1));
_uow.Verify(u => u.Save(), Times.Once);
_uow.VerifyAll();
Assert.IsTrue(result);
}
public int Add(WordTranslation wordTranslation)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
var ids = wordTranslation.Tags.Select(tag => tag.Id);
wordTranslation.Tags = uow.TagRepository.GetAll().Where(t => ids.Contains(t.Id)).ToList();
uow.WordTranslationRepository.AddOrUpdate(wordTranslation);
uow.Save();
return(wordTranslation.Id);
}
//using (var context = new WorldOfWordsDatabaseContext())
//{
// context.WordTranslations.Add(wordTranslation);
// context.SaveChanges();
// return wordTranslation.Id;
//}
}
/// <summary>
/// Gets the meaning.
/// </summary>
/// <returns>The meaning.</returns>
/// <param name="sourceText">Word for translation.</param>
/// <param name="targetLanguage">Target language.</param>
public string GetMeaning(string sourceText, Languages targetLanguage)
{
sourceText = sourceText.ToLower();
Word word = Database.GetDB().Find(x => x.word.Equals(sourceText));
if (word == null)
{
return(sourceText);
}
WordTranslation wordTranslation = word.wordTranslation.Find(x => x.country == targetLanguage);
if (wordTranslation == null)
{
return(sourceText);
}
return(ArabicTranslation(wordTranslation.meaning, targetLanguage));
}
private static WordTranslation Create(byte[] image,
int?rating,
StudyLanguageContext context,
Word sourceWord,
Word translationWord)
{
WordTranslation wordTranslation =
context.WordTranslation.Add(new WordTranslation
{
WordId1 = sourceWord.Id, WordId2 = translationWord.Id, Image = image, Rating = rating
});
context.WordTranslation.Add(wordTranslation);
context.SaveChanges();
return(wordTranslation);
}
public async Task <WordTranslationFullStringsModel> GetWordFullInformationStringsAsync(string word, int originalLangId, int translationLangId)
{
WordTranslationFullStringsModel infoWord = new WordTranslationFullStringsModel
{
OriginalWord = word
};
using (var uow = unitOfWorkFactory.GetUnitOfWork())
{
WordTranslation wordTr = await uow.WordTranslationRepository.GetAll()
.Where(x => x.OriginalWord.Value == word && x.OriginalWord.LanguageId == originalLangId &&
x.TranslationWord.LanguageId == translationLangId)
.FirstOrDefaultAsync();
infoWord.Description = wordTr.OriginalWord.Description;
infoWord.Transcription = wordTr.OriginalWord.Transcription;
infoWord.PartOfSpeech = wordTr.OriginalWord.PartOfSpeech.Name;
infoWord.Comment = wordTr.OriginalWord.Comment;
List <string> translations = uow.WordTranslationRepository.GetAll()
.Where(x => x.OriginalWord.Value == word && x.OriginalWord.LanguageId == originalLangId &&
x.TranslationWord.LanguageId == translationLangId)
.Select(x => x.TranslationWord.Value)
.ToList();
infoWord.Translations = translations.Count > 0 ? translations : null;
List <string> synonyms = uow.WordTranslationRepository.GetAll()
.Where(x => x.OriginalWord.Value == word && x.OriginalWord.LanguageId == originalLangId &&
x.TranslationWord.LanguageId == originalLangId)
.Select(x => x.TranslationWord.Value)
.ToList();
infoWord.Synonims = synonyms.Count > 0 ? synonyms : null;
List <string> tags = wordTr.OriginalWord.Tags.Select(x => x.Name).ToList();
infoWord.Tags = tags.Count > 0 ? tags : null;
}
return(infoWord);
}
public void Map_WordTranslationAndTrainingWordTranslationModelAreEqual()
{
var initial = new WordTranslation()
{
OriginalWord = new Word
{
Value = "Sunday"
},
TranslationWord = new Word
{
Value = "неділя"
}
};
var expected = new WordTranslationModel()
{
OriginalWord = "Sunday",
TranslationWord = "неділя"
};
var actual = (new TrainingWordTranslationMapper()).Map(initial);
Assert.AreEqual(expected.OriginalWord, actual.OriginalWord);
Assert.AreEqual(expected.TranslationWord, actual.TranslationWord);
}
public WordTranslation(WordTranslation wordTranslation) : base(wordTranslation)
{
WordForeign = wordTranslation.WordForeign;
WordNative = wordTranslation.WordNative;
}
private static void AssertCollectionElement(IEnumerator <WordTranslation> enumerate, WordTranslation addedWord)
{
Assert.Equal(enumerate.Current.WordForeign, addedWord.WordForeign);
Assert.Equal(enumerate.Current.WordNative, addedWord.WordNative);
Assert.Equal(enumerate.Current.Id, addedWord.Id);
Assert.Equal(enumerate.Current.ServerId, addedWord.ServerId);
}
public WordWithTranslation GetOrCreate(PronunciationForUser source,
PronunciationForUser translation,
byte[] image,
WordType wordType = WordType.Default,
int?rating = null)
{
//TODO: проверять корректность параметров
WordWithTranslation result = null;
Adapter.ActionByContext(context => {
IEnumerable <Word> sourceWords = FindWords(context, new List <PronunciationForUser> {
source
});
IEnumerable <Word> translateWords = FindWords(context, new List <PronunciationForUser> {
translation
});
Word sourceWord = GetOrAddWord(source, wordType, sourceWords, context);
Word translationWord = GetOrAddWord(translation, wordType, translateWords, context);
context.SaveChanges();
if (sourceWord == null || IdValidator.IsInvalid(sourceWord.Id) || translationWord == null ||
IdValidator.IsInvalid(translationWord.Id))
{
//все слова добавлены - если нужно, добавить связь между новым словом и переводом для него
LoggerWrapper.LogTo(LoggerName.Errors).ErrorFormat(
"WordsQuery.GetOrCreate can't add text {0} with translation {1}, image {2}, wordType {3}, rating {4}",
source.Text, translation.Text,
image != null ? image.Length.ToString(CultureInfo.InvariantCulture) : "<NULL>", wordType, rating);
result = null;
return;
}
WordTranslation wordTranslation = GetWordTranslation(context, sourceWord, translationWord);
if (wordTranslation != null)
{
//обновить возможно изменившийся рейтинг и изображение
wordTranslation.Image = image;
wordTranslation.Rating = rating;
context.SaveChanges();
}
else
{
wordTranslation = Create(image, rating, context, sourceWord, translationWord);
}
if (IdValidator.IsValid(wordTranslation.Id))
{
result = new WordWithTranslation(sourceWord)
{
Id = wordTranslation.Id
};
result.AddTranslation(translationWord);
}
else
{
LoggerWrapper.LogTo(LoggerName.Errors).ErrorFormat(
"WordsQuery.GetOrCreate can't add/get wordTranslation for text {0} with translation {1}, image {2}, wordType {3}, rating {4}",
source.Text, translation.Text,
image != null ? image.Length.ToString(CultureInfo.InvariantCulture) : "<NULL>", wordType, rating);
}
});
return(result);
}
