public async Task <IActionResult> CreateClassifier(Classifiers classifiers)
{
db.Classifiers.Add(classifiers);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public IEnumerable <DownloadEntry> GetDownloadsEntries(string classifier = null)
{
List <DownloadEntry> entries = new List <DownloadEntry>();
if (Artifact != null)
{
entries.Add(Artifact);
}
if (classifier == null || Classifiers == null)
{
return(entries);
}
if (Classifiers.ContainsKey(classifier))
{
Classifiers[classifier].IsNatives = true;
entries.Add(Classifiers[classifier]);
}
else
{
throw new KeyNotFoundException($"A specified classifier is not presented in list: '{classifier}'.");
}
return(entries);
}
private void OnGetClassifiers(Classifiers classifiers)
{
if (classifiers != null)
{
bool bFound = false;
foreach (var classifier in classifiers.classifiers)
{
if (!string.IsNullOrEmpty(m_ClassifierName) && !classifier.name.ToLower().StartsWith(m_ClassifierName.ToLower()))
{
continue;
}
if (classifier.language != m_Language)
{
continue;
}
m_NaturalLanguageClassifier.GetClassifier(classifier.classifier_id, OnGetClassifier);
bFound = true;
}
if (!bFound)
{
Log.Error("NaturalLanguageClassifierWidget", "No classifiers found that match {0}", m_ClassifierName);
}
}
}
private void OnCheckService(Classifiers classifiers)
{
if (m_Callback != null)
{
m_Callback(SERVICE_ID, classifiers != null);
}
}
private Classifiers ListClassifiers(bool?verbose = null)
{
Console.WriteLine("\nAttempting to ListClassifiers()");
Classifiers result = null;
try
{
result = _service.ListClassifiers(verbose: verbose);
}
catch (Exception e)
{
if (_listClassifiersRetries > 0)
{
_listClassifiersRetries--;
ListClassifiers(verbose);
}
else
{
throw e;
}
}
if (result != null)
{
Console.WriteLine("ListClassifiers() succeeded:\n{0}", JsonConvert.SerializeObject(result, Formatting.Indented));
}
else
{
Console.WriteLine("Failed to ListClassifiers()");
}
return(result);
}
private void OnGetClassifiersResp(RESTConnector.Request req, RESTConnector.Response resp)
{
Classifiers classifiers = new Classifiers();
if (resp.Success)
{
try
{
fsData data = null;
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = classifiers;
r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("NLC", "GetClassifiers Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((GetClassifiersReq)req).Callback != null)
{
((GetClassifiersReq)req).Callback(resp.Success ? classifiers : null);
}
}
/// <summary>
/// Retrieve a list of custom classifiers.
/// </summary>
/// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return a brief list of classifiers. (optional)</param>
/// <returns><see cref="Classifiers" />Classifiers</returns>
public Classifiers ListClassifiers(bool?verbose = null)
{
if (string.IsNullOrEmpty(VersionDate))
{
throw new ArgumentNullException("versionDate cannot be null.");
}
Classifiers result = null;
try
{
var request = this.Client.GetAsync($"{this.Endpoint}/v3/classifiers");
request.WithArgument("api_key", ApiKey);
request.WithArgument("version", VersionDate);
if (verbose != null)
{
request.WithArgument("verbose", verbose);
}
result = request.As <Classifiers>().Result;
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
return(result);
}
public IEnumerable<DownloadEntry> GetDownloadsEntries(OperatingSystem os)
{
List<DownloadEntry> result = new List<DownloadEntry>();
if (os == OperatingSystem.OTHER || Classifiers == null) {
result.Add(Artifact);
return result;
}
result.Add(Artifact);
string dictEntry;
switch (os) {
case OperatingSystem.WINDOWS:
dictEntry = "natives-windows";
break;
case OperatingSystem.LINUX:
dictEntry = "natives-linux";
break;
case OperatingSystem.MACOS:
dictEntry = "natives-osx";
break;
default:
throw new ArgumentOutOfRangeException(nameof(os), os, null);
}
if (Classifiers.ContainsKey(dictEntry)) {
Classifiers[dictEntry].IsNative = true;
result.Add(Classifiers[dictEntry]);
} else if (Classifiers.ContainsKey(dictEntry + (IntPtr.Size == 8 ? "-64" : "-32"))) {
Classifiers[dictEntry + (IntPtr.Size == 8 ? "-64" : "-32")].IsNative = true;
result.Add(Classifiers[dictEntry + (IntPtr.Size == 8 ? "-64" : "-32")]);
}
return result;
}
private void StackPanel_MouseDown(object sender, MouseButtonEventArgs e)
{
Border border = (Border)((StackPanel)sender).Parent;
if (isStackPanelSelected(border))
{
border.BorderBrush = Brushes.White;
Classifiers.Remove(((StackPanel)sender).Name);
}
else
{
int classifersCount = Classifiers.Count;
if (classifersCount < 6)
{
border.BorderBrush = Brushes.Green;
Classifiers.Add(((StackPanel)sender).Name);
if (classifersCount + 1 == 6)
{
txtBlkInfo.Text = String.Format(DONEMSG, classifersCount + 1);
}
else
{
txtBlkInfo.Text = String.Format(ACTIVEMSG, classifersCount + 1, 6 - classifersCount);
}
}
else
{
border.BorderBrush = Brushes.Red;
txtBlkInfo.Text = DESELECTMSG;
}
}
}
public void addClassifier(EClass classifier)
{
if (!ClassifierIDs.Contains(classifier.EaElement.ElementID))
{
ClassifierIDs.Add(classifier.EaElement.ElementID);
Classifiers.Add(classifier);
}
}
/// <summary>
/// Edit the currently selected classifier (defined by the
/// <seealso cref="SelectedIndex">SelectedIndex</seealso>
/// property).
/// <para>
/// Private method that implements the <c>ICommand</c> <seealso cref="Edit">
/// Edit</seealso> through a <c>DelegateCommand</c>.
/// </para>
/// </summary>
/// <param name="obj">Delegate object data - unused.</param>
private void EditClassifier(object obj)
{
var classifier = Classifiers.ElementAt(SelectedIndex);
if (classifier != null)
{
editClassifyingService.Edit(classifier);
}
}
/// <summary>
/// Predicts the given Label from the object.
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public object Predict(object o)
{
var current = Generator.Descriptor.Convert(o, false).ToVector();
var predictions = Classifiers.Select(s => new Tuple <object, double>(s.Key, s.Value.PredictRaw(current)))
.OrderByDescending(or => or.Item2).ToArray();
return(predictions.FirstOrDefault().Item1);
}
private void OnGetClassifiers(Classifiers classifiers)
{
m_Refreshing = false;
m_Classifiers = classifiers;
foreach (var c in m_Classifiers.classifiers)
{
m_NLC.GetClassifier(c.classifier_id, OnGetClassifier);
}
}
private void btnClearAll_Click(object sender, RoutedEventArgs e)
{
foreach (String classifier in Classifiers)
{
Border border = getBorder(classifier);
border.BorderBrush = Brushes.White;
txtBlkInfo.Text = SELECTMSG;
}
Classifiers.Clear();
}
private void OnGetClassifiers(Classifiers classifiers, string data)
{
Log.Debug("ExampleNaturalLanguageClassifier", "Natural Language Classifier - GetClassifiers Response: {0}", data);
foreach (Classifier classifier in classifiers.classifiers)
{
_classifierIds.Add(classifier.classifier_id);
}
_getClassifiersTested = true;
}
private void OnGetClassifiers(Classifiers classifiers, Dictionary <string, object> customData)
{
Log.Debug("ExampleNaturalLanguageClassifier.OnGetClassifiers()", "Natural Language Classifier - GetClassifiers Response: {0}", customData["json"].ToString());
foreach (Classifier classifier in classifiers.classifiers)
{
_classifierIds.Add(classifier.classifier_id);
}
_getClassifiersTested = true;
}
private void LoadKeywordClassifiers()
{
var data = new KeywordsSpreadsheet().LoadData().ToList();
data.ForEach(x => Classifiers.Save(x));
data.Single(x => x.SubCategory == SubCategories.HealthBeauty.DoctorsDentist)
.AddKeyword(CompanyNames.StJohnOfGod.ToLowerInvariant());
data.Single(x => x.SubCategory == SubCategories.Kids.Childcare)
.AddKeyword(CompanyNames.Kidz.ToLowerInvariant());
}
/// <summary>
/// Edits the classifier.
/// </summary>
/// <returns>The classifier.</returns>
/// <param name="id">Identifier.</param>
public async Task <IActionResult> EditClassifier(int?id)
{
if (id != null)
{
Classifiers classifiers = await db.Classifiers.FirstOrDefaultAsync(p => p.id_class == id);
if (classifiers != null)
{
return(View(classifiers));
}
}
return(NotFound());
}
public async Task <IActionResult> DeleteClassifier(int?id)
{
if (id != null)
{
Classifiers classifiers = new Classifiers {
id_class = id.Value
};
db.Entry(classifiers).State = EntityState.Deleted;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(NotFound());
}
public void InsertClassifier(Classifiers ieraksts)
{
if (ieraksts.Id == 0)
{
db.InsertAsync(ieraksts).ContinueWith(t =>
{
Console.WriteLine("New customer ID: {0}", ieraksts.Id);
});
}
else
{
db.UpdateAsync(ieraksts);
}
}
public void removeClassifier(EClass classifier)
{
EClass todelete = null;
foreach (EClass eClass in Classifiers)
{
if (eClass.EaElement.ElementID == classifier.EaElement.ElementID)
{
todelete = eClass;
}
}
Classifiers.Remove(todelete);
ClassifierIDs.Remove(classifier.EaElement.ElementID);
}
//[TestMethod]
public void ListClassifiers_RC_Success()
{
Classifiers listClassifiersResult = null;
try
{
listClassifiersResult = _service.ListClassifiers();
}
catch
{
Assert.Fail("Failed to list classifier - out of retries!");
}
Assert.IsNotNull(listClassifiersResult);
}
public HttpResponseMessage SearchByXmlId(string xmlId, string domain, int langId, int siteLangId, int limit = 25)
{
try
{
// tmp fix for using terms with letters in the term service
xmlId = new string(xmlId.Where(Char.IsDigit).ToArray());
}
catch
{
}
var classifierId = Classifiers.GetClassifierIdByXmlId(xmlId);
return(SearchByClassifierId(classifierId, domain, langId, siteLangId, limit));
}
/// <summary>
/// Move the currently selected classifier (defined by the
/// <seealso cref="SelectedIndex">SelectedIndex</seealso>
/// property) to earlier in the ordered list.
/// <para>
/// Private method that implements the <c>ICommand</c> <seealso cref="OrderEarlier">
/// OrderEarlier</seealso> through a <c>DelegateCommand</c>.
/// </para>
/// </summary>
/// <param name="obj">Delegate object data - unused.</param>
private void MoveItemUp(object obj)
{
if (selectedIndex != -1)
{
lock (this)
{
Debug.Assert(selectedIndex >= 0, "SelectedIndex must be valid, e.g. >= 0");
Debug.Assert(Classifiers.Count > 1, "Can only move item if more than one.");
lock (Classifiers)
{
Classifiers.Swap(selectedIndex, selectedIndex - 1);
}
}
}
}
/// <summary>
/// Retrieve a list of classifiers.
/// </summary>
/// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return
/// a brief list of classifiers. (optional)</param>
/// <param name="customData">Custom data object to pass data including custom request headers.</param>
/// <returns><see cref="Classifiers" />Classifiers</returns>
public Classifiers ListClassifiers(bool?verbose = null, Dictionary <string, object> customData = null)
{
if (string.IsNullOrEmpty(VersionDate))
{
throw new ArgumentNullException("versionDate cannot be null.");
}
Classifiers result = null;
try
{
IClient client;
if (_tokenManager == null)
{
client = this.Client;
}
else
{
client = this.Client.WithAuthentication(_tokenManager.GetToken());
}
var restRequest = client.GetAsync($"{this.Endpoint}/v3/classifiers");
restRequest.WithArgument("version", VersionDate);
if (verbose != null)
{
restRequest.WithArgument("verbose", verbose);
}
if (customData != null)
{
restRequest.WithCustomData(customData);
}
restRequest.WithHeader("X-IBMCloud-SDK-Analytics", "service_name=watson_vision_combined;service_version=v3;operation_id=ListClassifiers");
result = restRequest.As <Classifiers>().Result;
if (result == null)
{
result = new Classifiers();
}
result.CustomData = restRequest.CustomData;
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
return(result);
}
public override void OnNavigatingTo(NavigationParameters parameters)
{
base.OnNavigatingTo(parameters);
if (parameters.ContainsKey("Id"))
{
var id = (int)parameters["Id"];
if (id == 0)
{
Equipment = new Classifiers();
}
else
{
Equipment = App.Database.GetClassifier(id);
RaisePropertyChanged(nameof(Equipment));
}
}
}
/// <summary>
/// Predict all given Labels across all classifiers for the current object.
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public IEnumerable <object> PredictClasses(object o)
{
var current = Generator.Descriptor.ToVector(o);
var prediction = Classifiers.Select(s => new Tuple <object, double>(s.Key, s.Value.PredictRaw(current)))
.OrderByDescending(or => or.Item2);
var sum = prediction.Sum(s => s.Item2);
foreach (var predict in prediction)
{
if (predict.Item2 >= 0.5)
{
yield return(predict.Item1);
}
}
}
/// <summary>
/// Retrieve a list of classifiers.
/// </summary>
/// <param name="verbose">Specify `true` to return details about the classifiers. Omit this parameter to return
/// a brief list of classifiers. (optional)</param>
/// <param name="customData">Custom data object to pass data including custom request headers.</param>
/// <returns><see cref="Classifiers" />Classifiers</returns>
public Classifiers ListClassifiers(bool?verbose = null, Dictionary <string, object> customData = null)
{
if (string.IsNullOrEmpty(VersionDate))
{
throw new ArgumentNullException("versionDate cannot be null.");
}
Classifiers result = null;
try
{
IClient client;
if (_tokenManager == null)
{
client = this.Client;
}
else
{
client = this.Client.WithAuthentication(_tokenManager.GetToken());
}
var restRequest = client.GetAsync($"{this.Endpoint}/v3/classifiers");
restRequest.WithArgument("version", VersionDate);
restRequest.WithArgument("api_key", ApiKey);
if (verbose != null)
{
restRequest.WithArgument("verbose", verbose);
}
if (customData != null)
{
restRequest.WithCustomData(customData);
}
result = restRequest.As <Classifiers>().Result;
if (result == null)
{
result = new Classifiers();
}
result.CustomData = restRequest.CustomData;
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
return(result);
}
private void OnGetClassifiers(Classifiers classifiers)
{
if (classifiers != null)
{
foreach (var classifier in classifiers.classifiers)
{
if (!string.IsNullOrEmpty(m_ClassifierName) && !classifier.name.StartsWith(m_ClassifierName))
{
continue;
}
if (classifier.language != m_Language)
{
continue;
}
m_NLC.GetClassifier(classifier.classifier_id, OnGetClassifier);
}
}
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
int selectedClassifiersCount = Classifiers.Count;
if (selectedClassifiersCount < 6)
{
int missing = 6 - selectedClassifiersCount;
List <StackPanel> panels = theGrid.Children.OfType <StackPanel>().ToList();
int index = 0;
while (selectedClassifiersCount < 6)
{
var tempBorder = panels[index].Children.OfType <Border>().FirstOrDefault();
var stackPanel = (StackPanel)tempBorder.Child;
Classifiers.Add(stackPanel.Name);
index++;
selectedClassifiersCount++;
}
}
}
