public void UpdateShouldSaveTheProfile()
{
//ARRANGE
var id = Guid.NewGuid();
var model = new WordEntity {
Id = id
};
var profileToUpdate = new WordEntity();
var logic = new Mock <IWordLogic>();
logic
.Setup(x => x.Get(id))
.Returns(profileToUpdate)
.Verifiable("Should get the word to update");
logic
.Setup(x => x.Update(profileToUpdate))
.Verifiable("Should save the changes");
var controller = new WordController(logic.Object, null);
//ACT
var result = controller.Update(model) as RedirectToRouteResult;
//ASSERT
logic.Verify();
Assert.NotNull(result);
Assert.AreEqual("Index", result.RouteValues["Action"]);
}
private async Task <WordEntity> GetWordByPhrase(string phrase)
{
_sqlConnection.Open();
SqlCommand cmd = new SqlCommand()
{
Connection = _sqlConnection,
CommandType = CommandType.Text,
CommandText = "select * from Words where Word = @word"
};
cmd.Parameters.Add(new SqlParameter("@word", phrase));
SqlDataReader reader = await cmd.ExecuteReaderAsync();
var entity = new WordEntity();
if (reader.HasRows)
{
while (reader.Read())
{
entity =
new WordEntity()
{
ID = int.Parse(reader["ID"].ToString()),
Word = reader["Word"].ToString(),
Category = reader["Category"].ToString(),
SortedWord = reader["SortedWord"].ToString()
};
break;
}
}
return(entity);
}
public async ValueTask <WordEntity> SelectWordById(int id)
{
sqlConnection.Open();
SqlCommand cmd = new SqlCommand
{
Connection = sqlConnection,
CommandType = CommandType.Text,
CommandText = "select * from Words where ID = @wordIdToGet"
};
cmd.Parameters.Add(new SqlParameter("@wordIdToGet", id));
SqlDataReader reader = await cmd.ExecuteReaderAsync();
WordEntity anagram = null;
if (reader.HasRows)
{
while (reader.Read())
{
anagram = new WordEntity
{
Category = reader["Category"].ToString(),
Word = reader["Word"].ToString(),
SortedWord = reader["SortedWord"].ToString(),
ID = int.Parse(reader["ID"].ToString()),
};
break;
}
}
reader.Close();
sqlConnection.Close();
return(anagram);
}
public void Update(WordEntity entity)
{
WordEntity word = Get(entity.Id);
word.Word = entity.Word;
Context.SaveChanges();
}
/// <summary>
/// 获取类别的自定义词汇
/// </summary>
/// <param name="subject">类别代号</param>
/// <param name="language">语种</param>
/// <returns>词汇列表</returns>
public async Task <List <WordEntity> > GetSubjectCustomWordsList(int subject, int language)
{
HttpRequestMessage customWordMessage = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri($"https://gartic.io/req/subject?subject={subject}&language={language}"),
};
customWordMessage.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36");
customWordMessage.Headers.Add("Connection", "keep-alive");
customWordMessage.Headers.Add("Accept", "application/json, text/plain, */*");
customWordMessage.Headers.Add("Cookie", Cookie);
customWordMessage.Headers.Add("Referer", "https://gartic.io/create");
HttpResponseMessage responseMessage = client.Send(customWordMessage);
string content = await responseMessage.Content.ReadAsStringAsync();
Regex wordReg = new Regex("(?<=\\[\")[^\"]+");
Regex codeReg = new Regex("(?<=,)\\d(?=])");
MatchCollection wordCol = wordReg.Matches(content);
MatchCollection codeCol = codeReg.Matches(content);
List <WordEntity> wordEntities = new List <WordEntity>();
for (int i = 0; i < wordCol.Count; i++)
{
WordEntity entity = new WordEntity(wordCol[i].Value, Convert.ToInt32(codeCol[i].Value));
wordEntities.Add(entity);
}
return(wordEntities);
}
public IHttpActionResult PutWordEntity(int id, WordEntity wordEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != wordEntity.Id)
{
return(BadRequest());
}
if (wordEntity.Closed)
{
wordEntity.CloseUtc = DateTime.UtcNow;
}
else
{
wordEntity.ModifyUtc = DateTime.UtcNow;
}
//db.Entry(wordEntity).State = EntityState.Modified;
var oldEntity = jsonDb.Word.Single(o => o.Id == id);
oldEntity.KnowTimes = wordEntity.KnowTimes;
oldEntity.FromWord = wordEntity.FromWord;
oldEntity.ToWord = wordEntity.ToWord;
oldEntity.CloseUtc = wordEntity.CloseUtc;
oldEntity.ModifyUtc = wordEntity.ModifyUtc;
oldEntity.Closed = wordEntity.Closed;
jsonDb.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// 设置词存储类型
/// </summary>
/// <param name="words"></param>
/// <param name="info"></param>
protected virtual void SetWordSaveType(Dictionary <string, WordEntity> words, KeyEntity info)
{
if (words.ContainsKey(info.Name))
{
var word = words[info.Name];
if (word.Count == long.MaxValue)
{
return;
}
word.Count++;
word.SaveType = SaveType.Modify;
word.SetProperty(it => it.Count);
}
else
{
var word = new WordEntity
{
Name = info.Name,
Pinyin = GetPinyin(info.Name),
Count = 1,
IsForbid = false,
SaveType = SaveType.Add
};
words.Add(info.Name, word);
}
}
public void InsertAdditionalWord(string word, string category)
{
var additionalWord = new WordEntity
{
Word1 = word,
Category = category
};
_context.Word.Add(additionalWord);
_context.SaveChanges();
}
public IHttpActionResult GetWordEntity(int id)
{
WordEntity wordEntity = jsonDb.Word.Single(o => o.Id == id);
// WordEntity wordEntity = db.Word.Find(id);
if (wordEntity == null)
{
return(NotFound());
}
return(Ok(wordEntity));
}
public bool RemoveWord(string word)
{
WordEntity wordEntity = _wordRepository.GetByWord(word);
if (wordEntity == null)
{
return(false);
}
_wordRepository.Remove(wordEntity);
return(true);
}
public async Task <bool> AddWordToDataSet(string word, string languagePart)
{
var sortedWord = String.Concat(word.ToLower().OrderBy(c => c));
var wordModel = new WordEntity()
{
Word = word,
Category = languagePart,
SortedWord = sortedWord
};
await _context.Word.AddAsync(wordModel).ConfigureAwait(false);
return(true);
}
public IHttpActionResult DeleteWordEntity(int id)
{
WordEntity wordEntity = jsonDb.Word.Single(o => o.Id == id);
if (wordEntity == null)
{
return(NotFound());
}
jsonDb.Word.Remove(wordEntity);
jsonDb.SaveChanges();
return(Ok(wordEntity));
}
public IHttpActionResult PostWordEntity(WordEntity wordEntity)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
wordEntity.CreateUtc = DateTime.UtcNow;
wordEntity.ModifyUtc = DateTime.UtcNow;
wordEntity.CreateUser = "******";
wordEntity.Id = jsonDb.Word.Max(o => o.Id) + 1;
jsonDb.Word.Add(wordEntity);
jsonDb.SaveChanges();
return CreatedAtRoute("DefaultApi", new { id = wordEntity.Id }, wordEntity);
}
public void AddFromFile(Dictionary <string, DictionaryEntry> dictionary, string connString)
{
using (var db = new AnagramContext(connString))
{
for (int i = 0; i < dictionary.Count; i++)
{
var item = dictionary.ElementAt(i);
var word = new WordEntity {
Word = item.Key, OrderedWord = item.Value.Word, Category = item.Value.Antecedent
};
db.WordEntities.Add(word);
}
db.SaveChanges();
}
}
public IHttpActionResult PostWordEntity(WordEntity wordEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
wordEntity.CreateUtc = DateTime.UtcNow;
wordEntity.ModifyUtc = DateTime.UtcNow;
wordEntity.CreateUser = "******";
wordEntity.Id = jsonDb.Word.Max(o => o.Id) + 1;
jsonDb.Word.Add(wordEntity);
jsonDb.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = wordEntity.Id }, wordEntity));
}
public async Task <bool> Update([FromBody] WordRequestEntity entity)
{
var updatedEntity = new WordEntity
{
originalword = entity.word,
packageId = entity.packageId,
description = entity.description,
ownSentence = entity.ownSentence,
synonym = entity.synonym,
_id = new MongoDB.Bson.ObjectId(entity.id)
};
var result = await hubRepository.Update(updatedEntity);
return(result);
}
public bool AddWord(string word)
{
WordEntity wordEntity = _wordRepository.GetByWord(word);
if (wordEntity != null)
{
return(false);
}
wordEntity = new WordEntity()
{
Word = word,
SortedWord = string.Concat(word.ToLower().OrderBy(x => x))
};
_wordRepository.Add(wordEntity);
return(true);
}
public bool EditWord(string oldWord, string newWord)
{
WordEntity oldWordEntity = _wordRepository.GetByWord(oldWord);
if (oldWordEntity == null)
{
return(false);
}
oldWordEntity.Word = newWord;
oldWordEntity.SortedWord = string.Concat(newWord.ToLower().OrderBy(x => x));
_wordRepository.Update(oldWordEntity);
return(true);
}
// CODE FIRST
public void InsertWordTableData(List <WordEntity> fileColumns)
{
var enity = new WordEntity();
foreach (var item in fileColumns)
{
var wordEntity = new WordEntity
{
Id = item.Id,
Word1 = item.Word1,
Category = item.Category
};
_context.Word.Add(wordEntity);
//_context.SaveChanges();
}
//_context.Word.Add(wordEntity);
_context.SaveChanges();
}
public async Task AddNewWord(Anagram anagram)
{
if (anagram == null || string.IsNullOrEmpty(anagram.Category) ||
string.IsNullOrEmpty(anagram.Word))
{
throw new Exception("Cannot add Word, because Word is empty");
}
var sortedword = String.Concat(anagram.Word.OrderBy(x => x));
var entity = new WordEntity
{
Category = anagram.Category,
SortedWord = sortedword,
Word = anagram.Word
};
await _context.Words.AddAsync(entity);
}
public void AddWord_ShouldNotAddExistingDictionaryWord()
{
RequestedWord = "labas";
WordEntity wordEntity = new WordEntity()
{
Id = 1,
Word = "labas",
SortedWord = "aabls"
};
_wordRepository.GetByWord(RequestedWord).Returns(wordEntity);
var result = _modificationService.AddWord(RequestedWord);
_wordRepository.Received().GetByWord(RequestedWord);
_wordRepository.DidNotReceive().Add(wordEntity);
result.ShouldBeFalse();
}
public async Task <bool> AddWordToDataSet(string word, string languagePart)
{
var foundWord = await _wordRepository.GetWordByName(word);
if (foundWord != null)
{
return(false);
}
var sortedWord = String.Concat(word.ToLower().OrderBy(c => c));
var wordEntity = new WordEntity()
{
Word = word,
Category = languagePart,
SortedWord = sortedWord
};
await _wordRepository.AddWordToDataSet(wordEntity);
return(true);
}
// CODE FIRST
public List <WordEntity> GetWordEntityFromFile()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile(@"./appsettings.json")
.Build();
var path = configuration["Settings:FileName"];
if (!File.Exists(path))
{
throw new Exception($"Data file {path} does not exist!");
}
var wordModelList = new Dictionary <string, string>();
using (StreamReader reader = new StreamReader(path))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string word = line.Split('\t').First();
string PartOfSpeech = line.Split('\t').ElementAt(1);
var wordModel = new WordEntity()
{
Word1 = word,
Category = PartOfSpeech
};
if (!wordModelList.ContainsKey(word))
{
wordModelList.Add(wordModel.Word1, wordModel.Category);
}
}
}
var returnList = wordModelList.Select(pair => new WordEntity()
{
Word1 = pair.Key,
Category = pair.Value
}).ToList();
return(returnList);
}
public void RemoveWord_ShouldReturnFalseIfWordDoesNotExists()
{
RequestedWord = "labas";
WordEntity wordEntity = new WordEntity()
{
Id = 1,
Word = "labas",
SortedWord = "aabls"
};
_wordRepository.GetByWord(RequestedWord).ReturnsNull();
var result = _modificationService.RemoveWord(RequestedWord);
result.ShouldBeFalse();
_wordRepository.Received().GetByWord(RequestedWord);
_wordRepository.DidNotReceive().Remove(wordEntity);
}
public void RemoveWord_ShouldRemoveExistingWordAndReturnTrue()
{
RequestedWord = "labas";
WordEntity wordEntity = new WordEntity()
{
Id = 1,
Word = "labas",
SortedWord = "aabls"
};
_wordRepository.GetByWord(RequestedWord).Returns(wordEntity);
var result = _modificationService.RemoveWord(RequestedWord);
result.ShouldBeTrue();
_wordRepository.Received().GetByWord(RequestedWord);
_wordRepository.Received().Remove(wordEntity);
}
public async Task <List <WordEntity> > GetAllWords()
{
if (!File.Exists(FilePath))
{
throw new Exception($"File '{FilePath}' does not exist!");
}
string[] lines = await File.ReadAllLinesAsync(FilePath);
string previousWord = string.Empty;
var result = new List <WordEntity>();
foreach (string line in lines)
{
var lineParts = line.Split('\t');
string word = lineParts[0].ToLower().Trim();
string wordCase = lineParts[1].ToLower().Trim();
//if same line found skip to the next one
if (word == previousWord)
{
continue;
}
//sorting string chars alphabetical order
var sortedWord = String.Concat(word.OrderBy(x => x));
sortedWord = sortedWord.ToLower();
var entity = new WordEntity
{
Category = wordCase,
SortedWord = sortedWord,
Word = word
};
result.Add(entity);
previousWord = word;
}
return(result);
}
public void CreateShouldSaveTheProfile()
{
//ARRANGE
var model = new WordEntity();
var logic = new Mock <IWordLogic>();
logic
.Setup(x => x.Create(model))
.Verifiable("Should save the new word.");
var controller = new WordController(logic.Object, null);
//ACT
var result = controller.Create(model) as RedirectToRouteResult;
//ASSERT
logic.Verify();
Assert.NotNull(result);
Assert.AreEqual("Index", result.RouteValues["Action"]);
}
public void EditWord_ShouldReturnFalseIfWordToEditDoesNotExists()
{
RequestedWord = "labas";
string newWord = "lab";
WordEntity oldWordEntity = new WordEntity()
{
Id = 1,
Word = "labas",
SortedWord = "aabls"
};
_wordRepository.GetByWord(RequestedWord).ReturnsNull();
var result = _modificationService.EditWord(oldWordEntity.Word, newWord);
_wordRepository.Received().GetByWord(RequestedWord);
_wordRepository.DidNotReceive().Update(oldWordEntity);
result.ShouldBeFalse();
}
public async Task GetAnagramsSuccessWhenDataOkAndSingleAndMultipleWordAnagramsFound()
{
Settings.AnagramsToGenerate = 5;
var entity = new WordEntity()
{
Word = "rokas", SortedWord = "akors"
};
var entity2 = new WordEntity()
{
Word = "ro", SortedWord = "or"
};
var entity3 = new WordEntity()
{
Word = "kas", SortedWord = "aks"
};
var list = new List <WordEntity>()
{
entity, entity2, entity3
};
_wordRepoMock.GetAllWords().Returns(list);
_wordRepoMock.GetSelectedWordAnagrams(Arg.Any <string>()).Returns(new List <WordEntity> {
entity
});
await _cachedWordServiceMock.AddCachedWord(Arg.Any <string>(), Arg.Any <List <string> >());
var result = await _anagramSolver.GetAnagrams("oskar");
await _wordRepoMock.Received().GetAllWords();
await _wordRepoMock.Received().GetSelectedWordAnagrams(Arg.Any <string>());
await _cachedWordServiceMock.Received().AddCachedWord(Arg.Any <string>(), Arg.Any <List <string> >());
Assert.AreEqual(list.Count, result.Count);
Assert.AreEqual(list[0].Word, result[0]);
Assert.AreEqual($"{list[1].Word} {list[2].Word}", result[1]);
Assert.AreEqual($"{list[2].Word} {list[1].Word}", result[2]);
}
public void EditWord_ShouldEditExistingWordAndReturnTrue()
{
string newWord = "lab";
RequestedWord = "labas";
WordEntity oldWordEntity = new WordEntity()
{
Id = 1,
Word = "labas",
SortedWord = "aabls"
};
_wordRepository.GetByWord(RequestedWord).Returns(oldWordEntity);
var result = _modificationService.EditWord(oldWordEntity.Word, newWord);
_wordRepository.Received().GetByWord(RequestedWord);
_wordRepository.Received().Update(oldWordEntity);
result.ShouldBeTrue();
}
public IHttpActionResult PutWordEntity(int id, WordEntity wordEntity)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != wordEntity.Id)
{
return BadRequest();
}
if (wordEntity.Closed)
wordEntity.CloseUtc = DateTime.UtcNow;
else
wordEntity.ModifyUtc = DateTime.UtcNow;
//db.Entry(wordEntity).State = EntityState.Modified;
var oldEntity = jsonDb.Word.Single(o => o.Id == id);
oldEntity.KnowTimes = wordEntity.KnowTimes;
oldEntity.FromWord = wordEntity.FromWord;
oldEntity.ToWord = wordEntity.ToWord;
oldEntity.CloseUtc = wordEntity.CloseUtc;
oldEntity.ModifyUtc = wordEntity.ModifyUtc;
oldEntity.Closed = wordEntity.Closed;
jsonDb.SaveChanges();
return StatusCode(HttpStatusCode.NoContent);
}
void IWordsRepository.AddWord(WordEntity word)
{
throw new NotImplementedException();
}
