public ActionResult Remove(string removeId = "", string authorizeRemove = "")
{
string message;
if (!string.IsNullOrWhiteSpace(authorizeRemove) && removeId.Equals(authorizeRemove))
{
ApplicationUser authedUser = UserManager.FindById(User.Identity.GetUserId());
IDictataPhrase obj = ConfigDataCache.Get <IDictataPhrase>(new ConfigDataCacheKey(typeof(IDictataPhrase), removeId, ConfigDataType.Dictionary));
if (obj == null)
{
message = "That does not exist";
}
else if (obj.Remove(authedUser.GameAccount, authedUser.GetStaffRank(User)))
{
LoggingUtility.LogAdminCommandUsage("*WEB* - RemoveConstants[" + removeId + "]", authedUser.GameAccount.GlobalIdentityHandle);
message = "Delete Successful.";
}
else
{
message = "Error; Removal failed.";
}
}
else
{
message = "You must check the proper remove or unapprove authorization radio button first.";
}
return(RedirectToAction("Index", new { Message = message }));
}
private bool CheckForExistingPhrase(IDictataPhrase newPhrase)
{
//Check for existing phrases with the same word set
IEnumerable <IDictataPhrase> maybePhrases = ConfigDataCache.GetAll <IDictataPhrase>();
return(maybePhrases.Any(phrase => phrase.Words.All(word => newPhrase.Words.Any(newWord => newWord.Equals(word)))));
}
private static int GetSynonymRanking(IDictataPhrase word, LexicalContext context)
{
return((word.Positional == context.Position ? 5 : 0) +
(word.Tense == context.Tense ? 5 : 0) +
(word.Perspective == context.Perspective ? 5 : 0) +
((context.GenderForm == null || word.Feminine == context.GenderForm?.Feminine) ? 10 : 0) +
(context.Semantics.Any() ? word.Semantics.Count(wrd => context.Semantics.Contains(wrd)) * 10 : 0));
}
public static IDictataPhrase GetSynonymPhrase(IDictataPhrase basePhrase, LexicalContext context)
{
if (basePhrase == null)
{
return(basePhrase);
}
return(FocusFindPhrase(basePhrase.PhraseSynonyms.ToList(), context, basePhrase));
}
public static IDictata GetSynonym(IDictataPhrase basePhrase, LexicalContext context)
{
if (basePhrase == null)
{
return(null);
}
return(FocusFindWord(basePhrase.Synonyms.ToList(), context, basePhrase));
}
public override object Convert(object input)
{
string stringInput = input.ToString();
if (string.IsNullOrWhiteSpace(stringInput))
{
return(null);
}
IDictataPhrase returnValue = ConfigDataCache.Get <IDictataPhrase>(new ConfigDataCacheKey(typeof(IDictataPhrase), stringInput, ConfigDataType.Dictionary));
return(returnValue);
}
public ActionResult Edit(string id, string ArchivePath = "")
{
IDictataPhrase obj = ConfigDataCache.Get <IDictataPhrase>(new ConfigDataCacheKey(typeof(IDictataPhrase), id, ConfigDataType.Dictionary));
if (obj == null)
{
string message = "That does not exist";
return(RedirectToAction("Index", new { Message = message }));
}
AddEditDictionaryPhraseViewModel vModel = new AddEditDictionaryPhraseViewModel(ArchivePath, obj)
{
AuthedUser = UserManager.FindById(User.Identity.GetUserId())
};
return(View("~/Views/GameAdmin/DictionaryPhrase/Edit.cshtml", vModel));
}
private static IDictataPhrase GetRelatedPhrase(IDictataPhrase basePhrase, IEnumerable <IDictataPhrase> possibleWords, int severityModifier, int eleganceModifier, int qualityModifier)
{
Dictionary <IDictataPhrase, int> rankedPhrases = new Dictionary <IDictataPhrase, int>();
foreach (IDictataPhrase word in possibleWords)
{
int rating = 0;
rating += Math.Abs(basePhrase.Severity + severityModifier - word.Severity);
rating += Math.Abs(basePhrase.Elegance + eleganceModifier - word.Elegance);
rating += Math.Abs(basePhrase.Quality + qualityModifier - word.Quality);
rankedPhrases.Add(word, rating);
}
KeyValuePair <IDictataPhrase, int> closestPhrase = rankedPhrases.OrderBy(pair => pair.Value).FirstOrDefault();
return(closestPhrase.Key ?? basePhrase);
}
public ActionResult Add(AddEditDictionaryPhraseViewModel vModel)
{
ApplicationUser authedUser = UserManager.FindById(User.Identity.GetUserId());
IDictataPhrase newObj = vModel.DataObject;
string message;
if (newObj.Save(authedUser.GameAccount, authedUser.GetStaffRank(User)))
{
LoggingUtility.LogAdminCommandUsage("*WEB* - AddDictataPhrase[" + newObj.UniqueKey + "]", authedUser.GameAccount.GlobalIdentityHandle);
message = "Creation Successful.";
}
else
{
message = "Error; Creation failed.";
}
return(RedirectToAction("Index", new { Message = message }));
}
private static IDictataPhrase FocusFindPhrase(IEnumerable <IDictataPhrase> possiblePhrases, LexicalContext context, IDictataPhrase basePhrase)
{
if (context.Language == null)
{
context.Language = basePhrase.Language;
}
possiblePhrases = possiblePhrases.Where(phrase => phrase != null && phrase.Language == context.Language && phrase.SuitableForUse);
if (context.Severity + context.Elegance + context.Quality == 0)
{
List <Tuple <IDictataPhrase, int> > rankedPhrases = new List <Tuple <IDictataPhrase, int> >
{
new Tuple <IDictataPhrase, int>(basePhrase, GetSynonymRanking(basePhrase, context))
};
rankedPhrases.AddRange(possiblePhrases.Select(phrase => new Tuple <IDictataPhrase, int>(phrase, GetSynonymRanking(phrase, context))));
return(rankedPhrases.OrderByDescending(pair => pair.Item2).Select(pair => pair.Item1).FirstOrDefault());
}
return(GetRelatedPhrase(basePhrase, possiblePhrases, context.Severity, context.Elegance, context.Quality));
}
private static IDictata FocusFindWord(IEnumerable <IDictata> possibleWords, LexicalContext context, IDictataPhrase basePhrase)
{
if (context.Language == null)
{
context.Language = basePhrase.Language;
}
possibleWords = possibleWords.Where(word => word != null && word.Language == context.Language && word.GetLexeme().SuitableForUse);
if (context.Severity + context.Elegance + context.Quality == 0)
{
List <Tuple <IDictata, int> > rankedWords = new List <Tuple <IDictata, int> >();
int baseRanking = GetSynonymRanking(basePhrase, context);
rankedWords.AddRange(possibleWords.Select(word => new Tuple <IDictata, int>(word, GetSynonymRanking(word, context))));
if (baseRanking > rankedWords.Max(phrase => phrase.Item2))
{
return(null);
}
return(rankedWords.OrderByDescending(pair => pair.Item2).Select(pair => pair.Item1).FirstOrDefault());
}
return(GetRelatedWord(basePhrase, possibleWords, context.Severity, context.Elegance, context.Quality));
}
public ActionResult Edit(string id, AddEditDictionaryPhraseViewModel vModel)
{
string message = string.Empty;
ApplicationUser authedUser = UserManager.FindById(User.Identity.GetUserId());
IDictataPhrase obj = ConfigDataCache.Get <IDictataPhrase>(new ConfigDataCacheKey(typeof(IDictataPhrase), id, ConfigDataType.Dictionary));
if (obj == null)
{
message = "That does not exist";
return(RedirectToAction("Index", new { Message = message }));
}
obj.Severity = vModel.DataObject.Severity;
obj.Quality = vModel.DataObject.Quality;
obj.Elegance = vModel.DataObject.Elegance;
obj.Tense = vModel.DataObject.Tense;
obj.Synonyms = vModel.DataObject.Synonyms;
obj.Antonyms = vModel.DataObject.Antonyms;
obj.PhraseSynonyms = vModel.DataObject.PhraseSynonyms;
obj.PhraseAntonyms = vModel.DataObject.PhraseAntonyms;
obj.Language = vModel.DataObject.Language;
obj.Words = vModel.DataObject.Words;
obj.Feminine = vModel.DataObject.Feminine;
obj.Positional = vModel.DataObject.Positional;
obj.Perspective = vModel.DataObject.Perspective;
obj.Semantics = vModel.DataObject.Semantics;
if (obj.Save(authedUser.GameAccount, authedUser.GetStaffRank(User)))
{
foreach (IDictata syn in obj.Synonyms)
{
if (!syn.PhraseSynonyms.Any(dict => dict == obj))
{
System.Collections.Generic.HashSet <IDictataPhrase> synonyms = syn.PhraseSynonyms;
synonyms.Add(obj);
syn.PhraseSynonyms = synonyms;
syn.GetLexeme().Save(authedUser.GameAccount, authedUser.GetStaffRank(User));
}
}
foreach (IDictata ant in obj.Antonyms)
{
if (!ant.PhraseAntonyms.Any(dict => dict == obj))
{
System.Collections.Generic.HashSet <IDictataPhrase> antonyms = ant.PhraseAntonyms;
antonyms.Add(obj);
ant.PhraseAntonyms = antonyms;
ant.GetLexeme().Save(authedUser.GameAccount, authedUser.GetStaffRank(User));
}
}
foreach (IDictataPhrase syn in obj.PhraseSynonyms)
{
if (!syn.PhraseSynonyms.Any(dict => dict == obj))
{
System.Collections.Generic.HashSet <IDictataPhrase> synonyms = syn.PhraseSynonyms;
synonyms.Add(obj);
syn.PhraseSynonyms = synonyms;
syn.Save(authedUser.GameAccount, authedUser.GetStaffRank(User));
}
}
foreach (IDictataPhrase ant in obj.PhraseAntonyms)
{
if (!ant.PhraseAntonyms.Any(dict => dict == obj))
{
System.Collections.Generic.HashSet <IDictataPhrase> antonyms = ant.PhraseAntonyms;
antonyms.Add(obj);
ant.PhraseAntonyms = antonyms;
ant.Save(authedUser.GameAccount, authedUser.GetStaffRank(User));
}
}
LoggingUtility.LogAdminCommandUsage("*WEB* - EditDictataPhrase[" + obj.UniqueKey + "]", authedUser.GameAccount.GlobalIdentityHandle);
message = "Edit Successful.";
}
else
{
message = "Error; Edit failed.";
}
return(RedirectToAction("Index", new { Message = message }));
}
