public static SearchResult <T> Find <T>(IEnumerable <T> collection, string input, Func <T, ISearchableProperty> searchProperties)
{
var normalizedInput = input.ToLower();
var lev = new Fastenshtein.Levenshtein(normalizedInput);
var lowestDistance = int.MaxValue;
var currentWinner = default(T);
foreach (var item in collection)
{
foreach (var searchProperty in searchProperties(item).AsStrings)
{
var termToMatchAgainst = searchProperty.ToLower();
if (termToMatchAgainst == normalizedInput)
{
return(new SearchResult <T>(item, 0));
}
var distance = lev.DistanceFrom(termToMatchAgainst);
if (distance >= lowestDistance)
{
continue;
}
lowestDistance = distance;
currentWinner = item;
}
}
return(new SearchResult <T>(currentWinner, lowestDistance));
}
public Task <Guid> Handle(UpdateTreatmentCommand request, CancellationToken cancellationToken)
{
var currentTreatment = _databaseContext.Treatment.FirstOrDefault(x => x.Id == request.Id);
var treatments = _mapper.Map <List <TreatmentModel> >(_databaseContext.Treatment.ToList());
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(request.Description);
foreach (var treatmentItem in treatments)
{
treatmentItem.ClosedDescriptionProbability = lev.DistanceFrom(treatmentItem.Description);
}
var treatment = treatments.Where(x => x.ClosedDescriptionProbability <= 7).OrderByDescending(x => x.ClosedDescriptionProbability).FirstOrDefault();
if (treatment == null)
{
treatment = new TreatmentModel()
{
Type = request.Type, Description = request.Description, Name = request.Name,
};
_databaseContext.Treatment.Add(treatment);
_databaseContext.SaveChanges();
}
//else
// _databaseContext.Relationship.Add(new Relationship()
// {
// FromType = ObjectType.Treatment,
// FromId = treatment.Id,
// ToType = ObjectType.TreatmentPayload,
// ToId = treatmentPayload.Id
// });
_databaseContext.SaveChanges();
return(Task.FromResult(treatment.Id));
}
private string GetClosestActualTemtemName(string input, List <string> list)
{
if (input.IndexOf("\n") != -1)
{
input = input.Substring(0, input.IndexOf("\n"));
}
if (input.IndexOf(" ") != -1)
{
input = input.Substring(0, input.IndexOf(" "));
}
//If our input is an empty string, return an empty string meaning the result is invalid
if (input.Length == 0)
{
return("");
}
//These values here are purely nonsensical high values and serve no other purpose
int minScore = 20000;
int minIndex = 20000;
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(input);
foreach (string element in list)
{
int score = lev.DistanceFrom(element);
if (score < minScore)
{
minScore = score;
minIndex = list.IndexOf(element);
}
}
return(list[minIndex]);
}
private void HandleChatMessage(string message, string username, StreamWriter writer)
{
var time = DateTime.UtcNow;
var lev = new Fastenshtein.Levenshtein(message);
float score = 0f;
for (int i = 0; i < _stringBuffer.Length; i++)
{
string item = _stringBuffer[i];
if (string.IsNullOrEmpty(item))
{
score += 100;
}
else
{
score += lev.DistanceFrom(item);
}
}
if (message.Length > _messageLength &&
score >= _stringBuffer.Length &&
score / _stringBuffer.Length - _outLiers < _granularity &&
(time - _lastMessage).TotalMilliseconds < _seconds * 1000)
{
// We have a winner!
Console.WriteLine($"Score : {score}");
Suspend(username, writer);
}
_lastMessage = time;
AddNewMessage(message);
Console.WriteLine($"{username} : {message}");
}
private static void AddToTree(string s)
{
var node = new DistanceTree.Node(s, null);
List <DistanceTree.Node> neighbors;
var radius = Levenshtein.MAX_RADIUS;
var levenshtein = new Fastenshtein.Levenshtein(s);
do
{
neighbors = Levenshtein.tree.Select(n =>
{
n.Cache = levenshtein.Distance(n.Content);
return(n.Cache <= radius);
}).ToList();
radius++;
} while (neighbors.Count == 0);
var edges = neighbors.Select(x => new DistanceTree.Edge(node, x, x.Cache));
node.Edges = edges.ToList();
Levenshtein.tree.Add(node);
Levenshtein.NodeDictionary.Add(s, node);
}
public static string BestGuess <TItem>(string target, IEnumerable <TItem> items, Func <TItem, string> selector, int maximumGuessDistance = 7, int maximumGuesses = 4)
{
var lev = new Fastenshtein.Levenshtein(target);
var orderedItems = items
.Select(item => (Item: item, Text: selector(item), Distance: lev.DistanceFrom(selector(item))))
.OrderBy(tuple => tuple.Distance)
.ToList();
if (!orderedItems.Any())
{
return(string.Empty);
}
var best = orderedItems.First();
if (best.Distance > maximumGuessDistance)
{
return(string.Empty);
}
var guesses = orderedItems
.Where(tuple => tuple.Distance <= best.Distance + 1)
.OrderBy(tuple => tuple.Distance)
.ThenByDescending(tuple => tuple.Text.StartsWith(target, StringComparison.InvariantCultureIgnoreCase))
.ThenByDescending(tuple => tuple.Text.EndsWith(target, StringComparison.InvariantCultureIgnoreCase))
.ToList();
if (guesses.Count > maximumGuesses)
{
guesses = orderedItems
.Where(tuple => tuple.Distance == best.Distance)
.OrderByDescending(tuple => tuple.Text.StartsWith(target, StringComparison.InvariantCultureIgnoreCase))
.ThenByDescending(tuple => tuple.Text.EndsWith(target, StringComparison.InvariantCultureIgnoreCase))
.ToList();
}
if (!guesses.Any() || guesses.Count > maximumGuesses)
{
return(string.Empty);
}
switch (guesses.Count)
{
case 1:
return($"Did you mean '{guesses.Single().Text}'?");
case 2:
return($"Did you mean '{guesses[0].Text}' or '{guesses[1].Text}'?");
default:
return($"Did you mean '{string.Join("', or '", guesses.Select(tuple => tuple.Text))}'?");
}
}
private void SearchButton_Click(object sender, RoutedEventArgs e)
{
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(SearchTermBox.Text);
List <Dive> sorted = dives.OrderBy(o => lev.DistanceFrom(o.DiveData)).ToList();
dives = sorted;
DiveListBox.Items.Clear();
foreach (Dive dive in dives)
{
DiveListBox.Items.Add(dive);
}
}
public List <string> GetSimilarItem(string word, string mode)
{
var lev = new Fastenshtein.Levenshtein(word.Format());
var distancelist = new SortedSet <StringInfo>();
var str = word.Substring(0, 1);
switch (mode)
{
case "wm":
foreach (var sale in translateApi.Sale)
{
if (sale.Zh.StartsWith(str))
{
var distance = lev.DistanceFrom(sale.Zh.Format());
distancelist.Add(new StringInfo {
LevDistance = distance, Name = sale.Zh
});
}
}
break;
case "rm":
foreach (var weapon in weapons)
{
if (weapon.StartsWith(str))
{
var distance = lev.DistanceFrom(weapon.Format());
distancelist.Add(new StringInfo {
LevDistance = distance, Name = weapon
});
}
}
break;
/*
* case "wiki":
* foreach (var wiki in wikiwords)
* {
* if (wiki.StartsWith(str) || Regex.IsMatch(word, @"[a-z]"))
* {
* var distance = lev.DistanceFrom(wiki.Format());
* distancelist.Add(new StringInfo { LevDistance = distance, Name = wiki });
* }
* }
* break;
*/
//木大
}
return(distancelist.Where(dis => dis.LevDistance != 0).Take(5).Select(info => info.Name).ToList());
}
public List <string> GetSimilarItem(string word)
{
var lev = new Fastenshtein.Levenshtein(word);
var distancelist = new SortedSet <StringInfo>();
foreach (var sale in translateApi.Sale)
{
var distance = lev.DistanceFrom(sale.Zh.Format());
distancelist.Add(new StringInfo {
LevDistance = distance, Name = sale.Zh
});
}
return(distancelist.Where(dis => dis.LevDistance != 0).Take(5).Select(info => info.Name).ToList());
}
protected override void Execute(CodeActivityContext context)
{
var dicString = new Dictionary <string, double>();
var listStrSouce = CandidateStringList.Get(context);
var strTarget = TargetText.Get(context);
var lev = new Fastenshtein.Levenshtein(strTarget);
var intStrLength = strTarget.Length;
if (String.IsNullOrEmpty(strTarget))
{
throw (new ArgumentException("Target Text is null or empty"));
}
//Calculate Normalized Edit Distance
foreach (string strItem in listStrSouce)
{
if (String.IsNullOrEmpty(strItem))
{
throw (new ArgumentException("CandidateStringList contains null or empty"));
}
dicString[strItem] = ((double)lev.DistanceFrom(strItem) / (double)Math.Max(intStrLength, strItem.Length));
}
//Sort
string[] sortedKeys = new string[dicString.Count];
double[] sortedValues = new double[dicString.Count];
dicString.Keys.CopyTo(sortedKeys, 0);
dicString.Values.CopyTo(sortedValues, 0);
Array.Sort(sortedValues, sortedKeys);
//Check if matched
if (sortedKeys[0] == strTarget)
{
IsMatched.Set(context, true);
}
else
{
IsMatched.Set(context, false);
}
SortedTextArray.Set(context, sortedKeys);
SortedNormalizedEditDistanceArray.Set(context, sortedValues);
}
public static byte[] ImageByWord(string id)
{
// Поиск в базе
string pathToImgBase = @"Images\ElementsImages";
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(id.ToLower());
var fls = Directory.GetFiles(pathToImgBase).Select(n => new { name = Path.GetFileNameWithoutExtension(n), path = n, dist = lev.DistanceFrom(Path.GetFileNameWithoutExtension(n).ToLower()) }).OrderBy(n => n.dist).ToList();
var fod = fls.FirstOrDefault();
if (fod?.dist <= 2)
{
return(StaticMetods.pathToImage(fod.path));
}
else
{
var tryes = 0;
bool isSuccess = false;
byte[] img = null;
while (!isSuccess && tryes < 10)
{
try
{
string html = GetHtmlCode(id);
List <string> urls = GetUrls(html).ToList();
int randomUrl = rnd.Next(0, urls.Count - 1);
string luckyUrl = urls[randomUrl];
img = GetImage(luckyUrl);
isSuccess = true;
}
catch
{
tryes++;
}
}
return(img);
}
}
protected override void OnPlayerCommandText(BasePlayer player, CommandTextEventArgs e)
{
base.OnPlayerCommandText(player, e);
if (e.Success == false)
{
var commandManager = Services.GetService <ICommandsManager>();
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(e.Text);
var similarCommands = commandManager.Commands
.OrderBy(command => lev.DistanceFrom(command.ToString()))
.Take(3);
player.SendClientMessage(
$"Nie znaleziono komendy: {e.Text}. Podobne komendy: {String.Join(", ", similarCommands)}?");
e.Success = true;
return;
}
}
private string GetClosestActualTemtemName(string input, List <string> list)
{
//These values here are purely nonsensical high values and serve no other purpose
int minScore = 20000;
int minDistance = 20000;
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(input);
foreach (string element in list)
{
int score = lev.DistanceFrom(element);
if (score < minScore)
{
minScore = score;
minDistance = list.IndexOf(element);
}
}
return(list[minDistance]);
}
private async Task EnrichWithSeriesDetailsId(List <EpisodeFile> newEpisodes)
{
var functionCache = new FunctionCache <string, Domain.Models.Details.Search.SeriesResult[]>(_detailsApi.SearchTvShows);
foreach (var episodeFile in newEpisodes)
{
var searchResults = await functionCache.Invoke(episodeFile.Name);
if (searchResults == null || !searchResults.Any())
{
episodeFile.SeriesDetailsId = null;
continue;
}
var actual = new Fastenshtein.Levenshtein(episodeFile.Name);
var selectedResult = searchResults.OrderBy(sr => actual.DistanceFrom(sr.Name)).First();
episodeFile.SeriesDetailsId = selectedResult.Id;
}
}
public static string ReadEmbeddedResource(string name)
{
var assembly = typeof(ResourceUtils).Assembly;
var prefix = assembly.GetName().Name + ".Resources.";
var resourceName = prefix + name;
var stream = assembly.GetManifestResourceStream(resourceName);
if (stream == null)
{
const int numSuggestionsToShow = 3;
var lev = new Fastenshtein.Levenshtein(name);
var numResources = assembly.GetManifestResourceNames().Length;
var validResourceNames = assembly.GetManifestResourceNames()
.Select(resName => resName.Substring(prefix.Length))
.OrderBy(lev.DistanceFrom)
.Take(numSuggestionsToShow)
.ToArray();
var suggestions = string.Join(", ", validResourceNames
.Select(name => $"\"{name}\""));
var numSuggestionsNotShown = numResources - numSuggestionsToShow;
var moreText = numSuggestionsNotShown > 0
? $" plus {numSuggestionsNotShown} more"
: "";
throw new Exception(
$"No resource found for name {name}. Did you mean one of these? {suggestions}{moreText}."
);
}
using (stream)
using (var reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
public async Task <DbFilmDetails[]> FindFilmDetails(IEnumerable <FilmFile> newFilm, Library library)
{
var allDetails = new Dictionary <int, DbFilmDetails>();
var functionCache = new FunctionCache <int, string, DbFilmDetails>(FetchFilmDetails);
foreach (var filmFile in newFilm)
{
var searchResults = await _detailsApi.SearchMovies(filmFile.Title, filmFile.Year);
if (!searchResults.Any())
{
searchResults = await _detailsApi.SearchMovies(filmFile.Title, 0);
}
if (!searchResults.Any())
{
filmFile.FilmDetailsId = null;
continue;
}
var actual = new Fastenshtein.Levenshtein(filmFile.Title);
var selectedResult = searchResults.OrderBy(sr => actual.DistanceFrom(sr.Title)).First();
var details = await functionCache.Invoke(selectedResult.Id, library.Language);
if (details == null)
{
continue;
}
filmFile.FilmDetailsId = details.Id;
allDetails[details.Id] = details;
}
return(allDetails.Values.ToArray());
}
private ProjectResource GuessProject(IReadOnlyCollection <ProjectResource> projects, string guess)
{
var leven = new Fastenshtein.Levenshtein(guess);
var topFive = projects.OrderBy(p => leven.Distance(p.Name)).Take(5).ToList();
var i = 0;
WriteLine($"Found 5 projects similar to {Colors.Bold(guess)}:");
foreach (var project in topFive)
{
WriteLine($"{Colors.Cyan($"[{++i}]")} {project.Name}");
}
Write($"Use number {Colors.Cyan("[ ]")} or hit enter to search for another project name\rUse number {Colors.Cyan("[")}");
if (int.TryParse(Console.ReadLine()?.Trim(), out var r))
{
return(topFive[r - 1]);
}
else
{
Write($"Search for project with name similar to: ");
var name = Console.ReadLine();
return(GuessProject(projects, name));
}
}
private void ProcessAnimation(GltfFile modelFile, GltfFile animFile, Animation animation, Dictionary <string, int> modelNodeIndexByName, string outputModelFolder)
{
var animData = animFile.Data;
var modelData = modelFile.Data;
// Load all animation buffers into memory
// TODO: This could be done lazily!
FetchBuffers(animData, animFile.Path);
foreach (var channel in animation.Channels)
{
var nodeIndex = channel.Target?.Node;
if (nodeIndex.HasValue)
{
var nodeName = animData.Nodes[nodeIndex.Value].Name;
if (!_allModelNodeNames.Contains(nodeName))
{
Log.WriteLine($"WARNING: Clip node '{nodeName}' not found in any model. Similar node names are:");
using (Log.Indented())
{
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(nodeName);
Log.WriteLine(string.Join(", ", _allModelNodeNames.OrderBy(lev.DistanceFrom).Take(3)));
}
}
}
}
int tc = 0;
int rc = 0;
int sc = 0;
int wc = 0;
// Keep only those animation channels that animate the current model,
// and are different from the initial scene
AnimationChannel[] clipChannels = animation
.Channels
.Where(channel =>
{
var nodeIndex = channel?.Target?.Node;
if (!nodeIndex.HasValue)
{
return(false);
}
var node = animData.Nodes[nodeIndex.Value];
if (!modelNodeIndexByName.ContainsKey(node.Name))
{
return(false);
}
var sampler = animation.Samplers[channel.Sampler];
var outputAccessor = animData.Accessors[sampler.Output];
// We assume the exporter already reduced constant curves to a single key.
if (outputAccessor.Count != 1)
{
return(true);
}
// We don't handle sparse data yet, keep it
if (!outputAccessor.BufferView.HasValue)
{
return(true);
}
var mesh = node.Mesh.HasValue ? animData.Meshes[node.Mesh.Value] : null;
var outputValues = GetComponentAtIndex(animData, outputAccessor, 0);
switch (channel.Target.Path)
{
case AnimationChannelTarget.PathEnum.translation:
return(AreDifferent(ref tc, outputValues, node.Translation ?? DefaultTranslation, 1e-3f));
case AnimationChannelTarget.PathEnum.rotation:
return(AreDifferent(ref rc, outputValues, node.Rotation ?? DefaultRotation, 1e-4f));
case AnimationChannelTarget.PathEnum.scale:
return(AreDifferent(ref sc, outputValues, node.Scale ?? DefaultScale, 1e-4f));
case AnimationChannelTarget.PathEnum.weights:
return(AreDifferent(ref wc, outputValues, node.Weights ?? mesh?.Weights, 1e-3f));
default:
return(true);
}
})
.ToArray();
if (clipChannels.Length == 0)
{
Log.WriteLine($"NOTE: Animation '{animation.Name}' is not used by model '{modelFile.Path}'");
return;
}
if (tc + rc + sc + wc > 0)
{
Log.WriteLine($"Skipped {tc} translation, {rc} rotation, {sc} scaling and {wc} weight redundant animation channels");
}
// Keep only those samplers used by any channel
AnimationSampler[] clipSamplers = clipChannels
.Select(channel => animation.Samplers[channel.Sampler])
.Distinct()
.ToArray();
AnimationChannelTarget[] clipTargets = clipChannels
.Select(channel => channel.Target)
.ToArray();
Accessor[] clipSamplerInputs = clipSamplers.Select(sampler => animData.Accessors[sampler.Input]).ToArray();
Accessor[] clipSamplerOutputs = clipSamplers.Select(sampler => animData.Accessors[sampler.Output]).ToArray();
Accessor[] clipAccessors = clipSamplerInputs.Concat(clipSamplerOutputs).Distinct().ToArray();
Remapper <Accessor> newAccessors = modelData.Accessors.Concat(clipAccessors).RemapFrom(animData.Accessors);
Remapper <AnimationSampler> newSamplers = clipSamplers.RemapFrom(animation.Samplers);
Remapper <AnimationChannel> newChannels = clipChannels.RemapFrom(animation.Channels);
// Remap sampler indices
foreach (var sampler in clipSamplers)
{
sampler.Input = newAccessors.Remap(sampler.Input);
sampler.Output = newAccessors.Remap(sampler.Output);
}
// Remap channel indices
foreach (var channel in clipChannels)
{
channel.Sampler = newSamplers.Remap(channel.Sampler);
}
// Remap animation channel targets
foreach (var target in clipTargets)
{
// ReSharper disable once PossibleInvalidOperationException
var clipNode = animData.Nodes[(int)target.Node];
var nodeIndex = modelNodeIndexByName[clipNode.Name];
target.Node = nodeIndex;
}
animation.Channels = newChannels.OutputItems;
animation.Samplers = newSamplers.OutputItems;
var clipBufferViews = clipAccessors
.Select(a => a.BufferView)
.Where(bv => bv.HasValue)
.Select(bv => bv.Value)
.Distinct()
.Select(i => animData.BufferViews[i])
.ToArray();
var newBufferViews = modelData.BufferViews.Concat(clipBufferViews)
.RemapFrom(animData.BufferViews);
// Remap clip accessor indices
foreach (var accessor in clipAccessors)
{
if (accessor.BufferView.HasValue)
{
accessor.BufferView = newBufferViews.Remap(accessor.BufferView.Value);
}
}
var clipBuffers = clipBufferViews
.Select(bv => bv.Buffer)
.Distinct()
.Select(i => animData.Buffers[i])
.ToArray();
var newBuffers = modelData.Buffers.Concat(clipBuffers).RemapFrom(animData.Buffers);
// Remap buffer view indices
foreach (var bufferView in clipBufferViews)
{
bufferView.Buffer = newBuffers.Remap(bufferView.Buffer);
}
// TODO: Animation indices don't need to be remapped?
modelData.Animations = (modelData.Animations ?? Array.Empty <Animation>()).Append(animation).ToArray();
modelData.Accessors = newAccessors.OutputItems;
modelData.BufferViews = newBufferViews.OutputItems;
modelData.Buffers = newBuffers.OutputItems;
}
public Phone[] QueryPhonesByName(string phoneName)
{
//List<Phone> similarPhones = new List<Phone> { };
List <Phone> matchedPhones = new List <Phone> {
};
SortedDictionary <double, List <Phone> > similarPhones =
new SortedDictionary <double, List <Phone> > {
};
Phone[] allPhones = this._context.Phones.ToArray();
Fastenshtein.Levenshtein lev;
foreach (Phone phone in allPhones)
{
double minDistance = Math.Max(phoneName.Length, phone.Name.Length);
string[] words = phone.Name.Split(" ");
foreach (string q in phoneName.Split(" "))
{
lev = new Fastenshtein.Levenshtein(q);
foreach (string word in words)
{
int tempDistance = lev.DistanceFrom(word);
if (tempDistance == Math.Max(q.Length, word.Length))
{
continue;
}
minDistance = Math.Min(minDistance, tempDistance);
}
}
lev = new Fastenshtein.Levenshtein(phoneName);
minDistance += (lev.DistanceFrom(phone.Name) / 10.0);
//Arbitrary number chosen for similarity necessary
//create distance to list of phone mapping
if (minDistance < 3)
{
if (similarPhones.ContainsKey(minDistance))
{
similarPhones[minDistance].Add(phone);
}
else
{
similarPhones.Add(minDistance, new List <Phone> {
phone
});
}
}
}
//foreach (Phone phone in matchedPhones)
//{
// lev = new Fastenshtein.Levenshtein(phoneName);
// int distance = lev.DistanceFrom(phone.Name);
// if (similarPhones.ContainsKey(distance))
// {
// similarPhones[distance].Add(phone);
// }
// else
// {
// similarPhones.Add(distance, new List<Phone> { phone });
// }
//}
List <Phone> sortedPhones = new List <Phone> {
};
foreach (List <Phone> phones in similarPhones.Values)
{
sortedPhones.AddRange(phones);
}
return(sortedPhones.ToArray());
}
protected override void Execute(CodeActivityContext context)
{
List <string> listStrSrc = CandidateStringList.Get(context);
int intListCount = listStrSrc.Count;
if (intListCount % 2 == 0 || intListCount < 3)
{
throw (new ArgumentException("Number of list item must be odd number and no less than 3"));
}
Dictionary <string, int> dicStringCount = new Dictionary <string, int>();
Dictionary <string, double> dicRMSE = new Dictionary <string, double>();
//Check CandidateStringList
int i = 0;
while (i < listStrSrc.Count)
{
if (String.IsNullOrEmpty(listStrSrc[i]))
{
throw (new ArgumentException("Empty string is not allowed in CandidateStringList."));
}
i++;
}
//Main Calculation loop
i = 0;
double[] dblSumOfSquare = new double[intListCount * intListCount];
while (i < intListCount)
{
//For check matching
if (dicStringCount.ContainsKey(listStrSrc[i]))
{
dicStringCount[listStrSrc[i]]++;
}
else
{
dicStringCount[listStrSrc[i]] = 1;
}
//Calculate Edit Distance
int j = 0;
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(listStrSrc[i]);
while (j < intListCount)
{
if (i != j)
{
double dblNormalizedEditDistance = ((double)lev.DistanceFrom(listStrSrc[j])) / (double)Math.Max(listStrSrc[i].Length, listStrSrc[j].Length);
dblSumOfSquare[j + i * intListCount] = Math.Pow(dblNormalizedEditDistance, 2);
}
j++;
}
i++;
}
// Calculate RMSE
i = 0;
while (i < intListCount)
{
if (!dicRMSE.ContainsKey(listStrSrc[i]))
{
dicRMSE[listStrSrc[i]] = 0;
int j = 0;
while (j < intListCount)
{
if (i != j)
{
dicRMSE[listStrSrc[i]] += dblSumOfSquare[j + i * intListCount];
}
j++;
}
dicRMSE[listStrSrc[i]] = Math.Sqrt(dicRMSE[listStrSrc[i]] / (double)(intListCount - 1));
}
i++;
}
//Check matching count
string[] sortedKeysCount = new string[dicStringCount.Count];
int[] sortedValuesCount = new int[dicStringCount.Count];
dicStringCount.Keys.CopyTo(sortedKeysCount, 0);
dicStringCount.Values.CopyTo(sortedValuesCount, 0);
Array.Sort(sortedValuesCount, sortedKeysCount);
Array.Reverse(sortedValuesCount);
Array.Reverse(sortedKeysCount);
int intCountMode = sortedValuesCount[0];
string strCandidateFromMatching = sortedKeysCount[0];
if (intCountMode == intListCount)
{
Unanimous.Set(context, strCandidateFromMatching);
}
else
{
Unanimous.Set(context, string.Empty);
}
if (intCountMode > (intListCount >> 1))
{
Majority.Set(context, strCandidateFromMatching);
}
else
{
Majority.Set(context, string.Empty);
}
//Sort RMSE
string[] sortedKeys = new string[dicRMSE.Count];
double[] sortedValues = new double[dicRMSE.Count];
dicRMSE.Keys.CopyTo(sortedKeys, 0);
dicRMSE.Values.CopyTo(sortedValues, 0);
Array.Sort(sortedValues, sortedKeys);
SortedTextArray.Set(context, sortedKeys);
RMSEArray.Set(context, sortedValues);
}
public Task <TreatmentModel> Handle(CreateTreatmentCommand request, CancellationToken cancellationToken)
{
var requestPayload = JObject.Parse(request.Payload ?? "{}");
requestPayload.Add(new JProperty("Status", "pending-approval"));
if (requestPayload.ContainsKey("database"))
{
var query = requestPayload.SelectToken("database").SelectToken("quert").Value <string>();
if (query.Contains("UPDATE") || query.Contains("TRUNCATE") || query.Contains("DELETE") || query.Contains("ALTER") || query.Contains("CREATE") || query.Contains("INSERT") || query.Contains("DROP"))
{
throw new Exception("FORBIDDEN_KEY");
}
}
var treatmentPayload = new TreatmentPayload()
{
Payload = JsonConvert.SerializeObject(requestPayload)
};
_databaseContext.TreatmentPayload.Add(treatmentPayload);
_databaseContext.SaveChanges();
var treatments = _mapper.Map <List <TreatmentModel> >(_databaseContext.Treatment.ToList());
Fastenshtein.Levenshtein lev = new Fastenshtein.Levenshtein(request.Description);
foreach (var treatmentItem in treatments)
{
treatmentItem.ClosedDescriptionProbability = lev.DistanceFrom(treatmentItem.Description);
}
var treatment = treatments.Where(x => x.ClosedDescriptionProbability <= 7 && x.Type?.ToLower() == request.Type.ToLower()).OrderByDescending(x => x.ClosedDescriptionProbability).FirstOrDefault();
if (treatment == null)
{
treatment = new TreatmentModel()
{
Type = request.Type, Description = request.Description, Name = request.Name
};
_databaseContext.Treatment.Add(treatment);
_databaseContext.SaveChanges();
}
var treatmentModel = _mapper.Map <TreatmentModel>(treatment);
treatmentModel.Payload = treatmentPayload;
if (request.RiskId.HasValue)
{
_databaseContext.Relationship.Add(new Relationship()
{
FromType = ObjectType.Risk,
FromId = request.RiskId.Value,
ToType = ObjectType.TreatmentPayload,
ToId = treatmentPayload.Id
});
}
_databaseContext.Relationship.Add(new Relationship()
{
FromType = ObjectType.Treatment,
FromId = treatment.Id,
ToType = ObjectType.TreatmentPayload,
ToId = treatmentPayload.Id
});
_databaseContext.SaveChanges();
return(Task.FromResult(treatmentModel));
}
