/// <summary>
/// Cette fonction va comparer les validations que nous avons obtenue avec les Tag voulue du mot en entrée et nous en retourner les métrics.
/// </summary>
/// <param name="validationList"> La liste des mot reconnue apres annalyse de l'algorithme sur un fichier. </param>
/// <param name="fileWord"> Le mot et le nom du fichier qui à été annalysé pour obtenir ces Tags voulue. </param>
/// <returns> Les métrics de cette annalyse. </returns>
public Metrics GetAlgorithmMetrics(List <bool> validationList, FileWord fileWord)
{
List <bool> wordTagList = HandJoint.Instance.TagDico[fileWord.Word][fileWord.FileName];
if (validationList?.Any() != true || validationList.Count != wordTagList.Count)
{
return(Metrics.Zero);
}
Metrics metrics = Metrics.Zero;
for (int i = 0; i < wordTagList.Count; i++)
{
if (validationList[i] && wordTagList[i])
{
metrics.TP++;
}
if (validationList[i] && !wordTagList[i])
{
metrics.FN++;
}
if (!validationList[i] && wordTagList[i])
{
metrics.FP++;
}
if (!validationList[i] && !wordTagList[i])
{
metrics.TN++;
}
}
return(metrics);
}
private static async Task<FileWord[]> SaveEntities(
Func<IRepository> repositoryFactory,
FileWord[] fileWords,
bool doNotSaveParentEntities)
{
var repo = repositoryFactory();
var filesToSave =
doNotSaveParentEntities
? Enumerable.Empty<File>()
: fileWords.Select(w => w.File).Distinct().Where(f => f.FileId < 1).ToArray();
var wordsToSave =
doNotSaveParentEntities
? Enumerable.Empty<Word>()
: fileWords.Select(w => w.Word).Distinct().Where(w => w.WordId < 1).ToArray();
foreach (var word in fileWords)
{
if (word.File.FileId > 0)
{
word.FileId = word.File.FileId;
word.File = null; // Set to null as we share those entities between repositories
}
if (word.Word.WordId > 0)
{
word.WordId = word.Word.WordId;
word.Word = null; // Set to null as we share those entities between repositories
}
}
await repo.SaveEntitiesAsync(fileWords, filesToSave, wordsToSave);
return fileWords;
}
public FileWord ReadFileWordUsingWord(FileWord model)
{
Session.Clear();
ISQLQuery query = Session.CreateSQLQuery(
" SELECT *" +
" FROM TBL_FILE_WORD" +
" WHERE USR_ID = :userId" +
" AND FILE_ID = :fileId" +
" AND FILE_WD = :fileWord");
query.SetParameter("userId", model.UserId);
query.SetParameter("fileId", model.FileId);
query.SetParameter("fileWord", model.Word);
query.AddEntity(typeof(FileWord));
return((FileWord)query.UniqueResult());
/*
* return Session.QueryOver<FileWord>()
* .Where(m
* => (m.UserId == model.UserId)
* && (m.FileId == model.FileId)
* && (m.Word == model.Word))
* .SingleOrDefault<FileWord>();
*/
}
public void ShouldTruncateAllDataOnRequest()
{
var repo = new Repository();
var file = new File {
Path = "TestPath", Name = "TestFile1.txt"
};
var word = new Word {
Term = Guid.NewGuid().ToString()
};
var fileWord = new FileWord {
File = file, Word = word
};
repo.SaveEntitiesAsync(new[] { fileWord }, new[] { file }, new[] { word }).Wait();
using (var context = new FileWordsDataflowDbContext())
{
Assert.IsTrue(context.Files.Any() && context.Words.Any() && context.FileWords.Any());
}
repo.TruncateDataAsync().Wait();
using (var context = new FileWordsDataflowDbContext())
{
Assert.IsTrue(!context.Files.Any() && !context.Words.Any() && !context.FileWords.Any());
}
}
public FileWord CreateFileWord(FileWord model)
{
FileWord rtn;
Session.Clear();
rtn = Session.Save(model) as FileWord;
Session.Flush();
return(rtn);
}
private void AddFile(InfoExcel infoExcel, string path)
{
FileWord fileWord = new FileWord(path);
fileWord.AddContent(TextContent.CongHoa, "Heading 1");
fileWord.AddContentNewLine(TextContent.DocLap, "Heading 2");
fileWord.AddContentNewLine(TextContent.HopDong, "Heading 3");
fileWord.AddContentNewLine(TextContent.SoHopDong);
fileWord.Save(@"D:\abc.doc");
fileWord.Close();
}
public FileWord ReadFileWord(FileWord model)
{
Session.Clear();
return(Session.QueryOver <FileWord>()
.Where(m
=> (m.UserId == model.UserId) &&
(m.FileId == model.FileId) &&
(m.FileWordId == model.FileWordId))
.SingleOrDefault <FileWord>());
}
public void DeleteFileWordAll(FileWord model)
{
builder.Clear();
builder
.AppendFormat(" DELETE FROM TBL_FILE_WORD")
.AppendFormat(" WHERE USR_ID = '{0}'", model.UserId)
.AppendFormat(" AND FILE_ID = '{1}'", model.FileId);
Session.Clear();
Session.Delete(builder.ToString());
Session.Flush();
}
public void ShouldFillIdsOfSavedEntities()
{
var repo = new Repository();
var file = new File {
Path = "TestPath", Name = "TestFile1.txt"
};
var word = new Word {
Term = Guid.NewGuid().ToString()
};
var fileWord = new FileWord {
File = file, Word = word
};
using (CreateTransaction())
{
repo.SaveEntitiesAsync(new[] { fileWord }, new[] { file }, new[] { word }).Wait();
}
Assert.IsTrue(file.FileId > 0);
Assert.IsTrue(word.WordId > 0);
Assert.IsTrue(fileWord.FileWordId > 0 && fileWord.FileId > 0 && fileWord.WordId > 0);
}
/// <summary>
/// Cette fonction va exécuter l'algorithme sur le fileContent.
/// </summary>
/// <param name="fileContent"> Contenu du fichier qui contients tous les handjoints enregistrés et à comparer. </param>
/// <param name="nbHandJoint"> Nombre de handJoints dans le fileContent que nous allons annalyser. </param>
/// <param name="fileWord"> Le mot qui devra etre reconue dans le fichier. </param>
/// <returns> Les métrics de l'analyse sur tous les handJoints. </returns>
public Metrics AlgorithmOnWord(string fileContent, int nbHandJoint, FileWord fileWord)
{
List <bool> validationList = new List <bool>();
for (int i = 0; i < nbHandJoint; i++)
{
List <Vector3> handJoint = FileReader.GetHandJoint(fileContent, i, 100);
List <Vector3> oneHandJoint = HandJoint.Instance.WordDico[fileWord.Word];
if (IsThisWord(oneHandJoint, handJoint, 200))
{
//Debug.Log("OK");
validationList.Add(true);
}
else
{
//Debug.Log("NO");
validationList.Add(false);
}
}
return(GetAlgorithmMetrics(validationList, fileWord));
}
public void ShouldReturnCorrectFileWordStatsInOrder()
{
var repo = new Repository();
repo.TruncateDataAsync().Wait();
var file = new File {
Path = "TestPath", Name = "TestFile1.txt"
};
var wordA = new Word {
Term = "A"
};
var fileWordA = new FileWord {
File = file, Word = wordA, Row = 3
};
var wordB = new Word {
Term = "B"
};
var fileWordB1 = new FileWord {
File = file, Word = wordB, Row = 1
};
var fileWordB2 = new FileWord {
File = file, Word = wordB, Row = 2
};
repo.SaveEntitiesAsync(
new[] { fileWordB2, fileWordB1, fileWordA }, new[] { file }, new[] { wordB, wordA }).Wait();
var stats = repo.GetFileWordStatsAsync(0, 2).Result;
Assert.AreEqual("A", stats[0].Word);
Assert.AreEqual(1, stats[0].Occurrences);
Assert.AreEqual("B", stats[1].Word);
Assert.AreEqual(2, stats[1].Occurrences);
Assert.AreEqual(1, stats[1].FirstRow);
}
/// <summary>
/// Cette fonction va exécuter l'algoritme pour tous les fichiers indiqués dans files.
/// </summary>
/// <param name="files"> La liste des fichiers à annalysé avec au mot recherché.</param>
/// <param name="generateFile"> Indique si nous devons générer un fichier. </param>
/// <param name="generateFileWord"> Indique le mot et le fichier pour lequel nous générons le fichier. </param>
/// <param name="generateFileIndex"> Indique l'index du handJoint du fichier à utiliser pour générer le fichier. </param>
/// <returns> Un dictionnaire de métrics pour chaque mots annalysés </returns>
public Dictionary <EHandJointWord, List <Metrics> > RunAlgorithmOnFiles(List <FileWord> files, bool generateFile, FileWord generateFileWord, int generateFileIndex)
{
if (files == null || files.Count == 0)
{
return(null);
}
string filePath;
string fileContent;
int nbHandJoint;
List <string> lines = new List <string>();
Metrics metrics;
Dictionary <EHandJointWord, List <Metrics> > wordsMetrics = new Dictionary <EHandJointWord, List <Metrics> >();
foreach (FileWord fileWord in files)
{
filePath = string.Format("{0}/{1}.txt", _assetPath, fileWord.FileName);
using (StreamReader reader = new StreamReader(filePath))
{
fileContent = reader.ReadToEnd();
}
lines = fileContent.Split('\n').ToList();
nbHandJoint = lines.Where(l => l.Contains("START")).Count();
// Ici nous pouvons générer un fichier qui contiendra une list<Vector3> des jointures d'un HandJoint.
if (generateFile && fileWord.Equals(generateFileWord))
{
List <Vector3> handJoint = FileReader.GetHandJoint(fileContent, generateFileIndex, 100);
filePath = string.Format("{0}/GeneratedList.cs", _assetPath);
GenerateListFileFromHandJoint(handJoint, filePath);
}
metrics = AlgorithmOnWord(fileContent, nbHandJoint, fileWord);
if (!wordsMetrics.ContainsKey(fileWord.Word))
{
wordsMetrics.Add(fileWord.Word, new List <Metrics>());
}
wordsMetrics[fileWord.Word].Add(metrics);
}
return(wordsMetrics);
}
public void DeleteFileWord(FileWord model)
{
Session.Clear();
Session.Delete(model);
Session.Flush();
}
public void UpdateFileWord(FileWord model)
{
Session.Clear();
Session.Update(model);
Session.Flush();
}
private void HandleFlwdCommand(String argument)
{
if (!isLogin)
{
SendResponse(ProtocolResponse.NotLoggedIn, "로그인 후 사용하세요.");
return;
}
logger.Info(argument);
logger.Info("단어 전송을 위해 파일 정보 읽기를 시작합니다.");
String[] split = argument.Split(',');
FileModel mFile = new FileModel();
mFile.UserId = userId;
mFile.UniqueId = split[0];
mFile = fileDao.ReadFileUsingUniqueId(mFile);
logger.Info(mFile.ToString());
if (mFile == null)
{
logger.Info("연관된 파일이 없습니다.");
SendResponse(ProtocolResponse.FileUnavailable, "연관된 파일이 없습니다.");
return;
}
logger.Info("단어를 파싱합니다.");
FileWord mFileWord = new FileWord();
mFileWord.UserId = mFile.UserId;
mFileWord.FileId = mFile.FileId;
logger.Info(mFile.ToString());
fileWordDao.DeleteFileWordAll(mFileWord); // 2014-07-25 ADD by KS
foreach (String word in split[1].Trim().Split(' '))
{
mFileWord.Word = word;
logger.Info(word);
logger.Info("1111");
mFileWord = fileWordDao.ReadFileWordUsingWord(mFileWord);
logger.Info("2222");
if (mFileWord == null)
{
mFileWord = new FileWord();
logger.Info("3333");
mFileWord.FileId = mFile.FileId;
logger.Info("333311111111111");
mFileWord.UserId = mFile.UserId;
logger.Info("33332222222222222");
mFileWord.FileWordId = fileWordDao.ReadMaxFileWordId(mFile) + 1;
logger.Info("33333333333333333");
mFileWord.Word = word;
logger.Info("3333444444444444");
mFileWord.WordCount = 1;
logger.Info("33335555555555555");
if (mFileWord.FileWordId == -1)
{
break;
}
logger.Info("4444");
fileWordDao.CreateFileWord(mFileWord);
logger.Info("5555");
}
else
{
mFileWord.WordCount += 1;
logger.Info("6666");
fileWordDao.UpdateFileWord(mFileWord);
logger.Info("7777");
}
logger.Info(word);
}
logger.Info("파일 내용 저장이 종료되었습니다.");
SendResponse(ProtocolResponse.CommandOkay, "파일 내용 저장이 종료되었습니다.");
}
