public IActionResult Update(int id, [FromBody] WordDto wordDto)
{
var model = Mapper.Map <Word>(wordDto);
var result = _wordService.Update(model);
return(Ok());
}
private void ChangeSelectedWord()
{
_words.MoveNext();
if (_words.Current == null)
{
NextButton.Visible = false;
return;
}
var word = _words.Current;
if (word.IsStatusSuccess)
{
_wordDto = word as WordDto;
var definitions = _wordDto?.Results
.Select(result => result.Definition).ToArray() ?? Array.Empty <object>();
Definitions.Items.AddRange(definitions);
Word.Text = _wordDto.Word;
}
else
{
_wordDto = null;
Word.Text += ((ErrorDto)word).Message;
}
}
public void InsertWord(WordDto aWord)
{
var mappedWord = Mapper.Map <WordDto, Word>(aWord);
unitOfWork.GetGenericWordRepository().Insert(mappedWord);
unitOfWork.Save();
}
public void UpdateWord(WordDto wordDto)
{
var word = _mapper.Map <Word>(wordDto);
_unitOfWork.Repository <Word>().Update(word);
_unitOfWork.SaveChanges();
}
public static Word ToBasseWord(this WordDto dto)
{
var word = dto.ToBaseWord();
return(word);
}
public GameTranslationDto GetTranslationGameFromRusToEng(int userId)
{
List <Word> words = WordsForGameTranslation(userId);
if (words.Count < 4)
{
return(new GameTranslationDto());
}
int a = 0, b = 0, c = 0, d = 0;
while (a == b || a == c || a == d || b == c || b == d || c == d)
{
a = _random.Next(0, words.Count);
b = _random.Next(0, words.Count);
c = _random.Next(0, words.Count);
d = _random.Next(0, words.Count);
}
var result = new GameTranslationDto
{
Translation = new List <string>()
};
var wordDto = new WordDto(a, userId, _unitOfWork);
result.Word = wordDto;
result.Translation.Add(words[b].English);
result.Translation.Add(words[c].English);
result.Translation.Add(words[d].English);
return(result);
}
public async Task <PostWordResponseModel> PostWord(WordDto word, int courseId)
=> await $"{url}api/Word/PostWord"
.PostJsonAsync(new PostWordRequestModel {
Word = word,
CourseId = courseId.ToString()
})
.ReceiveJson <PostWordResponseModel>();
public void UpdateWord(WordDto wordDto)
{
using (DictionaryRepository repository = new DictionaryRepository())
{
repository.WORD.UpdateWord(wordDto);
}
}
public void Add(WordDto wordDto)
{
using (var context = new UserContext())
{
context.Words.Attach(wordDto);
context.Words.AddOrUpdate(wordDto);
context.SaveChanges();
}
}
public static Word ToWord(this WordDto dto)
{
var word = dto.ToBaseWord();
word.Parents = dto.Parents.ToWords();
word.Children = dto.Childrens.ToWords();
return(word);
}
public IActionResult Insert([FromBody] WordDto wordDto)
{
var word = Mapper.Map <Word>(wordDto);
var time = DateTime.Now.ToString("yyyyMMddhhmmss");
NpoiHeplper.Init(_configuration["Template"], $@"{_configuration["UploadPath"]}{time}.docx");
word.RemotePath = $"{_configuration["Host"]}{time}.docx";
word.LocalPath = $"{_configuration["UploadPath"]}{time}.docx";
return(Ok(_wordService.Insert(word)));
}
public void Update(WordDto wordDto)
{
using (var context = new UserContext())
{
var newWordDto = context.Words.FirstOrDefault(x => x.Id == wordDto.Id);
newWordDto.Name = wordDto.Name;
newWordDto.Translation = wordDto.Translation;
newWordDto.Example = wordDto.Example;
context.SaveChanges();
}
}
public async Task <WordDto> GetById(WordDto word)
{
var entity = await _db.Words.FirstOrDefaultAsync(x => x.Id == word.Id);
if (entity == null)
{
throw new ApiException("Word not found");
}
return(entity.ToEntityDto <WordDto, Word>());
}
public static Word ToEntity(this WordDto dto)
{
return(new Word
{
Id = dto.Id,
Name = dto.Name,
Description = dto.Description,
//Classifiers = dto.Classifiers?.Select(e => e.ToEntity()).ToList(),
//Quotes = dto.Quotes?.Select(e => e.ToEntity()).ToList()
});
}
public ActionResult UpdateWord(WordDto wordDto)
{
if (wordDto.WordId == Guid.Empty)
{
wordService.CreateWord(wordDto);
}
else
{
wordService.UpdateWord(wordDto);
}
return(RedirectToAction("WordList"));
}
private static Word ToBaseWord(this WordDto dto)
{
return(new Word()
{
IdWord = dto.Id,
Translation = dto.Translation,
Name = dto.Name,
Example = dto.Example,
CountRepeat = dto.CountRepeat,
LastRepeatDate = dto.LastRepeatDate
});
}
public static Word ToWord(this WordDto dto)
{
return(new Word
{
Name = dto.Name,
Id = dto.Id,
Description = dto.Description,
CreationTime = dto.CreationTime,
Classifiers = dto.Classifiers.Select(w => w.ToClassifier()).ToList()
});
}
public IResult DeleteWord(WordDto wordDto)
{
using WordBookContext db = new();
Word deletedWord = db.Words.Where(w => w.WordId == wordDto.WordId).SingleOrDefault();
if (deletedWord == null)
{
return(new ErrorResult(Messages.WordNotFound));
}
db.Words.Remove(deletedWord);
db.SaveChanges();
return(new SuccessResult(Messages.WordDeleted));
}
public void UpdateWord(WordDto wordDto)
{
WORD word = DataSet.FirstOrDefault(w => w.ID == wordDto.WordId);
if (word != null)
{
word.TYPE_WORD_ID = wordDto.TypeWordId;
word.TEXT = wordDto.WordText.Trim();
word.PRONOUNCE = wordDto.Pronounce;
word.SOUND = wordDto.Sound;
Repository.SaveChanges();
}
}
public async Task <WordDto> DeleteWord(WordDto word)
{
var entity = await _db.Words.FirstOrDefaultAsync(x => x.Id == word.Id);
if (entity == null)
{
throw new ApiException("Word not found");
}
_db.Words.Remove(entity);
await _db.SaveChangesAsync();
return(entity.ToEntityDto <WordDto, Word>());
}
private void SetWordAndSound(string line, List <WordTranslationDto> wordTranslationDtos, bool isFirstLanguage = true)
{
string[] chStr = new string[2] {
"w: ", "s: "
};
string[] lines = line.Split(chStr, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length > 1)
{
string wordName = string.IsNullOrWhiteSpace(lines[0]) ? lines[1] : lines[0];
string sound = string.IsNullOrWhiteSpace(lines[0]) ? lines[2] : lines[1];
WordDto word = WordInsertInListAdd(wordName, sound, isFirstLanguage);
SetWordTranslation(_wordDtos[_wordDtos.IndexOf(word)], wordTranslationDtos, isFirstLanguage);
}
}
public void AddOrUpdateWord(WordDto word)
{
if (word.Id > 0)
{
//update
mWordRepository.Update(Mapper.Map <Word>(word), null);
HandleWordRootRelation(word.Id, word.RootRelations);
}
else
{
//add
int id = mWordRepository.InsertAndGetId(Mapper.Map <Word>(word), null);
HandleWordRootRelation(id, word.RootRelations);
}
}
public async Task InsertWord(WordDto wordDto)
{
var words = new List <Word>();
var word = _mapper.Map <Word>(wordDto);
words.Add(word);
var wordsFromSynonyms = wordDto.Synonyms.Select(s => new Word()
{
Term = s, Synonyms = wordDto.Term
});
words.AddRange(wordsFromSynonyms);
await _wordRepository.InsertWord(words);
}
async void ShowEditWord(WordDto word)
{
var parameters = new ModalParameters();
parameters.Add(nameof(EditWord.Word), word);
parameters.Add("CourseId", course.Id);
var modal = Modal.Show <EditWord>(word == null ? "Add Word" : "Edit Word", parameters);
var result = await modal.Result;
if (!result.Cancelled && (bool)result.Data)
{
await GetCourseDetails();
StateHasChanged();
}
}
public WordDto FindDetailWord(Guid wordId)
{
WordDto wordDto = new WordDto();
WORD word = DataSet.FirstOrDefault(w => w.ID == wordId && !w.DELETED);
if (word != null)
{
wordDto.WordId = wordId;
wordDto.WordText = word.TEXT;
wordDto.TypeWordId = word.TYPE_WORD_ID;
wordDto.TypeWordText = word.TYPE_WORD.TYPE_TEXT;
wordDto.Pronounce = word.PRONOUNCE;
wordDto.Sound = word.SOUND;
wordDto.MeaningList = Repository.MEANING.FindMeaningListHaveExample(wordId);
}
return(wordDto);
}
public IActionResult Update([FromBody] WordDto word)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_wordService.UpdateWord(word);
return(Ok());
}
catch (Exception e)
{
Log(e.Message);
return(BadRequest(e));
}
}
public async Task <ActionResult <int> > AddWord(WordDto wordDto)
{
var roleName = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.Role)?.Value.ToString();
if (roleName != RoleNames.Admin.ToString())
{
return(Unauthorized());
}
var word = new Word {
Name = wordDto.Name, LetterCount = wordDto.Name.Length
};
_context.Set <Word>().Add(word);
await _context.SaveChangesAsync();
return(Ok(word.Id));
}
public static string CheckUrlIsAValidImageInWord(WordDto aWord)
{
using (var wc = new WebClient())
{
try
{
wc.DownloadData(aWord.Image);
}
catch (Exception)
{
aWord.Image =
"http://t1.gstatic.com/images?q=tbn:ANd9GcRI4C4XDT85bAGvjFK2x6BF5J12CxqFFWVz0JuLiJKSFySzdxD9kBGBl1pL";
}
}
return(aWord.Image);
}
private void SetWordTranslation(WordDto word, List <WordTranslationDto> wordTranslationDtos, bool isFirstLanguage = true)
{
if (isFirstLanguage)
{
wordTranslationDtos.Add(
new WordTranslationDto
{
Id = -1,
LanguageFromWord = word.Language,
WordSource = word,
IsAdd = true
});
}
else
{
if (wordTranslationDtos.Any(x => x.WordTranslationValue == null))
{
for (int i = 0; i < wordTranslationDtos.Count; i++)
{
if (wordTranslationDtos[i].WordTranslationValue == null)
{
wordTranslationDtos[i].WordTranslationValue = word;
wordTranslationDtos[i].LanguageToWord = word.Language;
}
}
}
else
{
List <WordDto> wordTempList = new List <WordDto>();
wordTempList = wordTranslationDtos.Select(x => x.WordSource).Distinct().ToList();
for (int i = 0; i < wordTempList.Count; i++)
{
wordTranslationDtos.Add(
new WordTranslationDto
{
Id = -1,
LanguageFromWord = wordTempList[i].Language,
WordSource = wordTempList[i],
LanguageToWord = word.Language,
WordTranslationValue = word,
IsAdd = true
});
}
}
}
}
public async Task <IActionResult> Put([FromBody] WordDto entity)
{
if (ModelState.IsValid)
{
try
{
await Task.Run(() => service.Update(mapper.Map <WordDto, Word>(entity)));
await service.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
}
return(Ok());
}
