public VariableWordNavigationsViewModel(VariableWord variableWord)
{
//Items = new ObservableCollection<VariableWordNavigationViewModel>();
//var variableWordNavigation = new VariableWordNavigation(variableWord);
//var variableWordNavigationViewModel = new VariableWordNavigationViewModel(variableWordNavigation);
//Items.Add(variableWordNavigationViewModel);
//SelectedItem = Items[0];
}
public VariableWordViewModel(VariableWord variableWord, IRepository dataRepository)
{
_variableWord = variableWord;
_repository = dataRepository;
Value = _variableWord.SingularValue;
_variableWordNavigation = new VariableWordNavigation(_variableWord);
VariableWordNavigation = new VariableWordNavigationViewModel(_variableWordNavigation, _repository);
}
public static bool SontAccordes(VariableWord motVariable1, VariableWord motVariable2)
{
if (motVariable1.Gender == motVariable2.Gender && motVariable1.Number == motVariable2.Number)
{
return(true);
}
else
{
return(false);
}
}
// Renvoie true si les deux mots entrés en paramètre sont accordés, sinon false.
public static bool SontAccordes(VariableWord motVariable, ConjugatedVerb verbeConjugue)
{
if (verbeConjugue.GetGender() == motVariable.Gender && verbeConjugue.Number == motVariable.Number)
{
return(true);
}
else
{
return(false);
}
}
public IEnumerable <VariableWord> GetVariableWords(List <string> words)
{
var variableWords = new List <VariableWord>();
using (var con = new SqlConnection(connectionString))
{
con.Open();
using (SqlCommand cmd = new SqlCommand("stp_Search", con)
{
CommandType = CommandType.StoredProcedure
})
{
using (var table = new DataTable())
{
table.Columns.Add("Value", typeof(string));
foreach (var word in words)
{
table.Rows.Add(word);
}
var pList = new SqlParameter("@TvpWords", SqlDbType.Structured);
pList.TypeName = "dbo.tvp_OneVarchar";
pList.Value = table;
cmd.Parameters.Add(pList);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var defualtWord = reader["InputValue"].ToString();
var variableWord = new VariableWord(defualtWord)
{
Id = Convert.ToInt32(reader["Id"]),
SingularValue = reader["SingularValue"].ToString(),
PluralValue = reader["SingularValue"].ToString(),
Definition = reader["Definition"].ToString()
};
variableWords.Add(variableWord);
}
if (reader.NextResult())
{
while (reader.Read())
{
var s = new Synonym
{
WordId = Convert.ToInt32(reader["WordId"]),
Id = Convert.ToInt32(reader["Id"]),
Value = reader["Value"].ToString(),
Similarity = Convert.ToInt32(reader["Similarity"]),
Rank = Convert.ToInt32(reader["Rank"])
};
var variableWord = variableWords.FirstOrDefault(v => v.Id == s.WordId);
if (variableWord != null)
{
variableWord.Synonyms.Add(s);
}
}
}
}
}
}
}
return(variableWords);
}
// Lie les noms et les compléments du nom et place le résultat dans phraseFonction.
private static void LierNomsComplNom(List <Word> phrase, List <Word[]> phraseFonction)
{
for (ushort indiceMotCourant = 0; indiceMotCourant < phrase.Count; indiceMotCourant++)
{
Word mot = phrase[indiceMotCourant];
bool quiSujet = true;
// Si on tombe sur un nom ou nom propre...
if ((mot.Nature == "nom" || mot.Nature == "nom propre") && indiceMotCourant < phrase.Count - 1)
{
VariableWord nomComplete = (VariableWord)mot;
ushort indiceMotTeste = (ushort)(indiceMotCourant + 1);
// On cherche un éventuel complément du nom, qui se situe toujours après le nom.
// Le complément du nom est la plupart du temps précédé d'une préposition.
// Ainsi, pour savoir si le nom possède un complément du nom, on regarde si une
// préposition se trouve après lui.
if (phrase[indiceMotTeste].Nature == "préposition")
{
Word laPreposition = phrase[indiceMotTeste];
if (indiceMotTeste < phrase.Count - 1)
{
indiceMotTeste++;
// Si le mot suivant la préposition est et nom, un nom propre, un pronom, un verbe infinitif, ou un adverbe,
// la préposition se rattache à ce mot suivant.
if (new string[] { "nom", "nom propre", "pronom", "verbe infinitif", "adverbe" }.Contains(phrase[indiceMotTeste].Nature))
{
phraseFonction.Add(new Word[] { laPreposition, new LinkBetweenWord("PREP"), phrase[indiceMotTeste] });
}
// On supprime la préposition de la phrase et vu que cela décale les mots vers la gauche, on fait indiceMotTeste-=2
// pour retomber sur le nom complément.
phrase.RemoveAt(indiceMotTeste - 1);
indiceMotTeste--;
if (phrase[indiceMotTeste].ToString() == "qui")
{
indiceMotTeste--;
quiSujet = false;
}
// On traite le cas où le nom complément peut être suivi d'un pronom relatif (qui que quoi dont où -quel)
// qui se rattache au nom complément (et non pas au nom complété). La seule façon de savoir si le pronom
// relatif "QUI" (sujet) se rattache au nom complément ou au nom complété est de regarder les accords avec
// le verbe dans la suite de la phrase, pour voir à quel nom entre le nom complément et le nom complété
// conjugue le verbe. Si les deux noms sont du même genre/nombre... on ne peut devenir que grâce au sens de la phrase !
// Pour les autres pronoms relatifs (que COD, quoi, dont (= de qui) COI, auquel (= de qui) COI, où CCL),
// ils se rattachent la plupart du temps au nom qui se trouve juste avant (donc le nom complément) s'il
// n'y a pas de virgule pour les séparer.
// Le pronom relatif ne peut se rattacher qu'à un nom, on vérifie donc que le mot soit un nom.
// On vérifie également qu'on ne se situe pas au dernier mot, et donc qu'il y a encore des mots après...
// Enfin, on regarde si le mot suivant est un pronom.
if ((phrase[indiceMotTeste].Nature == "nom" || phrase[indiceMotTeste].Nature == "nom propre") &&
indiceMotTeste < phrase.Count - 1 && phrase[indiceMotTeste + 1].Nature == "pronom")
{
Name nomComplement = (Name)phrase[indiceMotTeste];
Pronoun pronom = (Pronoun)phrase[indiceMotTeste + 1];
// On vérifie que le pronom soit de type relatif.
if (pronom.Type.Contains("relatif"))
{
// Si le pronom relatif est "qui"...
#region Cas où le pronom relatif est "qui"
if (pronom.ToString() == "qui")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complément.
if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
// Sinon, si le verbe n'est pas à un temps composé, on regarde s'il s'agit du verbe être et
// on cherche s'il est suivi d'un adjectif, accordable...
#region Cas où le verbe n'est pas à un temps composé, on cherche un adjectif à la suite.
else if (verbeConjugue.Action == "être" && i < phrase.Count - 1)
{
// On ne cherche l'adjectif que 4 positions plus loin dans la phrase.
for (int j = i + 1; j < i + 5; j++)
{
// Si on trouve un adjectif...
if (phrase[j].Nature == "adjectif")
{
// Si cet adjectif est accordé avec le nom complément...
if (SontAccordes(nomComplement, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Sinon, si cet adjectif est accordé avec le nom complété...
else if (SontAccordes(nomComplete, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// On sort du for après le premier adjectif trouvé.
break;
}
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "que"...
#region Cas où le pronom relatif est "que"
else if (pronom.ToString() == "que")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire avoir, et que le nom complément est accordé avec le participe passé,
// le pronom relatif remplace le nom complément (car avec avoir, le participe passé s'accorde avec le COD
// si ce dernier se situe avant le verbe).
if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "dont", "auquel", "où"...
#region Cas où le pronom relatif est "dont", "auquel", "où"
else if (new string[] { "dont", "auquel", "où" }.Contains(pronom.ToString()))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
#endregion
}
}
}
}
// TODO: Traiter les rares cas où le complément du nom n'est pas séparé du nom par une préposition.
}
}
}
