public async Task <ActionResult> Edit(ClassificationViewModels model)
{
Classification _ObjClass = model._ModelObj;
ClassificationScheme _objScheme = cms_db.GetObjScheme(_ObjClass.ClassificationSchemeId);
_ObjClass.LstModDT = DateTime.Now;
_ObjClass.LstModUID = long.Parse(User.Identity.GetUserId());
if (model.IsEnabledbool == true)
{
_ObjClass.IsEnabled = 1;
}
if (model.IsEnabledbool == false)
{
_ObjClass.IsEnabled = 0;
}
int rs = await cms_db.EditClass(_ObjClass);
MediaContent OldDefaultImg = cms_db.GetObjDefaultMediaByContentIdvsType(_ObjClass.ClassificationId, (int)EnumCore.ObjTypeId.danh_muc);
MediaContent NewDefaultImg = cms_db.GetObjMediaContent(model.ImgdefaultId);
int UpdateImage = await this.UpdateImageForClassifi(NewDefaultImg, OldDefaultImg, _ObjClass.ClassificationId);
int rs2 = await cms_db.CreateUserHistory(long.Parse(User.Identity.GetUserId()), Request.ServerVariables["REMOTE_ADDR"],
(int)EnumCore.ActionType.Create, "Create", _ObjClass.ClassificationId, _ObjClass.ClassificationNM, "Classification", (int)EnumCore.ObjTypeId.danh_muc);
if (rs == (int)EnumCore.Result.action_true && rs2 == (int)EnumCore.Result.action_true)
{
return(RedirectToAction("Index", new { page = 1, SchemeId = _ObjClass.ClassificationSchemeId, ScheNM = _objScheme.ClassificationSchemeNM, classId = _ObjClass.ParentClassificationId.ToString() }));
}
return(RedirectToAction("Index", new { page = 1, SchemeId = _ObjClass.ClassificationSchemeId, ScheNM = _objScheme.ClassificationSchemeNM, classId = _ObjClass.ParentClassificationId.ToString() }));
}
public async Task <ActionResult> Edit(ClassificationSchemeViewModels model)
{
ClassificationScheme _ObjClassScheme = model._ModelObj;
if (model.IsSystemVM == true)
{
_ObjClassScheme.IsSystem = 1;
}
else
{
_ObjClassScheme.IsSystem = 0;
}
_ObjClassScheme.LstModDT = DateTime.Now;
_ObjClassScheme.LstModUID = long.Parse(User.Identity.GetUserId());
int rs = await cms_db.EditClassScheme(_ObjClassScheme);
int rs2 = await cms_db.CreateUserHistory(long.Parse(User.Identity.GetUserId()), Request.ServerVariables["REMOTE_ADDR"],
(int)EnumCore.ActionType.Update, "Update", model.ClassificationSchemeId, model.ClassificationSchemeNM, "ClassificationScheme", (int)EnumCore.ObjTypeId.danh_muc);
if (rs == (int)EnumCore.Result.action_true && rs2 == (int)EnumCore.Result.action_true)
{
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public async Task <int> AddClassScheme(ClassificationScheme ObjClassScheme)
{
if (!string.IsNullOrEmpty(ObjClassScheme.ClassificationSchemeNM))
{
db.ClassificationSchemes.Add(ObjClassScheme);
return(await db.SaveChangesAsync());
}
return(0);
}
public async Task <int> EditClassScheme(ClassificationScheme ObjClassScheme)
{
try
{
db.Entry(ObjClassScheme).State = EntityState.Modified;
return(await db.SaveChangesAsync());
}
catch (Exception ex)
{
return(0);
}
}
public void Contains(
char lhs,
char rhs,
bool contains
)
{
var map = _super.Keys.ToDictionary(
vertex => vertex,
vertex => new Classifier(
Guid.Empty,
vertex.ToString()));
var classificationScheme = new ClassificationScheme(_super.Select(classifier => map[classifier]));
Assert.That(classificationScheme[map[lhs]].Contains(classificationScheme[map[rhs]]), Is.EqualTo(contains));
}
/// <summary>
///
/// </summary>
/// <param name="filename">The configuration filename</param>
/// <returns></returns>
public static ClassificationScheme Load(string filename)
{
ClassificationScheme scheme = new ClassificationScheme();
Dictionary <string, Category> dictionary = new Dictionary <string, Category>();
try {
FileStream stream = File.OpenRead(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filename));
XmlDocument document = XmlUtility.NonValidatingParse(stream);
foreach (XmlElement element in DOM.GetChildElements(document.DocumentElement))
{
if (element.LocalName.Equals("category"))
{
Category category;
string attribute = element.GetAttribute("id");
string name = element.GetAttribute("name");
string str3 = element.GetAttribute("abstract");
string str4 = element.GetAttribute("superClasses");
ExprNode expression = LoadExpr(DOM.GetFirstChild(element));
bool concrete = (expression != null) && ((str3 == null) || !str3.Equals("true"));
if ((str4 != null) && (str4.Length != 0))
{
string[] strArray = str4.Split(new char[] { ' ' });
Category[] parents = new Category[strArray.Length];
for (int i = 0; i < strArray.Length; i++)
{
parents [i] = dictionary [strArray [i]];
}
category = new XmlCategory(scheme, name, concrete, parents, expression);
}
else
{
category = new XmlCategory(scheme, name, concrete, expression);
}
if ((attribute != null) && (attribute.Length != 0))
{
dictionary [attribute] = category;
}
}
stream.Close();
}
return(scheme);
}
catch (Exception exception) {
log.Fatal("Failed to load classification from " + filename, exception);
}
return(null);
}
public async Task Get()
{
var super = _super.Select(
vertex => new Classifier(
Guid.NewGuid(),
vertex.ToString()));
var classificationScheme = new ClassificationScheme(super);
using (var scope = _container.BeginLifetimeScope())
{
var session = scope.Resolve <ISession>();
await session.SaveAsync(classificationScheme);
await classificationScheme.VisitAsync(
async classificationSchemeClassifier =>
{
await session.SaveAsync(classificationSchemeClassifier.Classifier);
await session.SaveAsync(classificationSchemeClassifier);
},
null);
await session.FlushAsync();
}
ClassificationScheme retrieved = null;
using (var scope = _container.BeginLifetimeScope())
retrieved = await scope.Resolve <IDomainObjectService <Guid, ClassificationScheme> >().GetAsync(classificationScheme.Id);
Assert.That(retrieved, Is.Not.Null);
Assert.That(retrieved, Is.EqualTo(classificationScheme));
Assert.That(retrieved.Classifiers.ToHashSet().SetEquals(classificationScheme.Classifiers));
var map = classificationScheme.Classifiers.ToDictionary(classificationSchemeClassifier => classificationSchemeClassifier.Id);
foreach (var retrievedClassificationSchemeClassifier in retrieved.Classifiers)
{
var classificationSchemeClassifier = map[retrievedClassificationSchemeClassifier.Id];
Assert.That(retrievedClassificationSchemeClassifier, Is.EqualTo(classificationSchemeClassifier));
Assert.That(retrievedClassificationSchemeClassifier.Classifier, Is.EqualTo(classificationSchemeClassifier.Classifier));
Assert.That(retrievedClassificationSchemeClassifier.Super, Is.EqualTo(classificationSchemeClassifier.Super));
Assert.That(retrievedClassificationSchemeClassifier.Sub.ToHashSet().SetEquals(classificationSchemeClassifier.Sub));
}
}
public async Task <ActionResult> Create(ClassificationSchemeViewModels model)
{
ClassificationScheme _ObjClassScheme = model._ModelObj;
_ObjClassScheme.CrtdUID = long.Parse(User.Identity.GetUserId());
_ObjClassScheme.CrtdDT = DateTime.Now;
int rs = await cms_db.AddClassScheme(_ObjClassScheme);
int rs2 = await cms_db.CreateUserHistory(long.Parse(User.Identity.GetUserId()), Request.ServerVariables["REMOTE_ADDR"], (int)EnumCore.ActionType.Create, "Create",
_ObjClassScheme.ClassificationSchemeId, _ObjClassScheme.ClassificationSchemeNM, "ClassificationScheme", (int)EnumCore.ObjTypeId.danh_muc);
if (rs == (int)EnumCore.Result.action_true && rs2 == (int)EnumCore.Result.action_true)
{
return(RedirectToAction("Index"));
}
return(RedirectToAction("Create"));
}
public void NewClassificationScheme()
{
var super = _super.Select(
vertex => new Classifier(
Guid.Empty,
vertex.ToString()));
var sub = super.Transpose();
var classificationScheme = new ClassificationScheme(super);
Assert.That(classificationScheme.Classifiers.Count, Is.EqualTo(_super.Count));
Func <Classifier, ClassificationSchemeClassifier> map = classifier => classificationScheme[classifier];
Func <ClassificationSchemeClassifier, Classifier> inverseMap =
classificationSchemeClassifier => classificationSchemeClassifier != null ? classificationSchemeClassifier.Classifier : default;
Assert.That(super.Keys.All(
c =>
map.PreservesStructure(
classifier => super[classifier].FirstOrDefault(),
classificationSchemeClassifier => classificationSchemeClassifier.Super,
c) &&
map.PreservesStructure(
classifier => sub[classifier],
classificationSchemeClassifier => classificationSchemeClassifier.Sub,
c)), Is.True);
Assert.That(classificationScheme.Classifiers.All(
csc =>
inverseMap.PreservesStructure(
classificationSchemeClassifier => classificationSchemeClassifier.Super,
classifier => super[classifier].FirstOrDefault(),
csc) &&
inverseMap.PreservesStructure(
classificationSchemeClassifier => classificationSchemeClassifier.Sub,
classifier => sub[classifier],
csc)), Is.True);
Assert.That(classificationScheme.Classifiers
.Where(classificationSchemeClassifier => classificationSchemeClassifier.Super != null)
.All(classificationSchemeClassifier => classificationSchemeClassifier.Super.Contains(classificationSchemeClassifier)));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
id = 1;
}
ClassificationScheme _obj = cms_db.GetObjScheme(id.Value);
ClassificationSchemeViewModels model = new ClassificationSchemeViewModels(_obj);
if (_obj.IsSystem == 1)
{
model.IsSystemVM = true;
}
else
{
model.IsSystemVM = false;
}
model.ParentList = new SelectList(cms_db.GetLstClassificationScheme(), "ClassificationSchemeId", "ClassificationSchemeNM");
return(View(model));
}
public ClassificationSchemeViewModels(ClassificationScheme model)
{
_ModelObj = model;
}
public ClassificationSchemeViewModels()
{
_ModelObj = new ClassificationScheme();
}
/// <summary>
/// Constructs a manager for the given scheme
/// </summary>
public ClassifierManager(ClassificationScheme classificationScheme)
{
this.Settings = classificationScheme.Settings;
this.Classifier = classificationScheme.Classifier.GetFactory()().AsOnlineClassifier();
}
async Task IEtl.ExecuteAsync()
{
var descriptions = (await _csvExtractor.ExtractAsync("NAICS2017Descriptions.csv")).ToDictionary(
record => record[0],
record => record[2] == "NULL" ? null : record[2]);
var crossReferences = (
from crossReference in await _csvExtractor.ExtractAsync("NAICS2017CrossReferences.csv")
group crossReference[1] by crossReference[0] into crossReferencesGroupedByCode
select crossReferencesGroupedByCode).ToDictionary(
grouping => grouping.Key,
grouping => grouping.ToList());
var emptyCrossReferences = new List <string>();
var classifiers = await _csvExtractor.ExtractAsync(
"NAICS2017.csv",
record =>
{
var components = record[1].Split('-');
var start = int.Parse(components[0]);
var end = components.Length == 1 ? start : int.Parse(components[1]);
var range = new Range <int>(start, end);
if (!crossReferences.TryGetValue(
record[1],
out var classifierCrossReferences))
{
classifierCrossReferences = emptyCrossReferences;
}
return(new NaicsClassifier(
Guid.NewGuid(),
record[2],
range,
descriptions[record[1]],
classifierCrossReferences));
});
var parents = new NaicsClassifier[7];
var super = new Dictionary <Classifier, IList <Classifier> >();
var empty = new List <Classifier>();
// Take advantage of the fact that a parent appears directly before its children in the CSV file.
foreach (var classifier in classifiers)
{
var length = classifier.CodeRange.Start.ToString().Length;
var parent = parents[length - 1];
super[classifier] = parent == null ? empty : new List <Classifier> {
parent
};
parents[length] = classifier;
}
var classificationScheme = new ClassificationScheme(
_classificationSchemeId,
super);
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
await session.SaveAsync(classificationScheme);
await classificationScheme.VisitAsync(
async classificationSchemeClassifier =>
{
await session.SaveAsync(classificationSchemeClassifier.Classifier);
await session.SaveAsync(classificationSchemeClassifier);
});
await transaction.CommitAsync();
}
}
public async Task Get()
{
var super = _super.Select(
vertex => new Classifier(
Guid.NewGuid(),
vertex.ToString()));
var classificationScheme = new ClassificationScheme(super);
using (var scope = _container.BeginLifetimeScope())
{
var session = scope.Resolve <ISession>();
await session.SaveAsync(classificationScheme);
await classificationScheme.VisitAsync(
async classificationSchemeClassifier =>
{
await session.SaveAsync(classificationSchemeClassifier.Classifier);
await session.SaveAsync(classificationSchemeClassifier);
},
null);
await session.FlushAsync();
}
Web.Model.ClassificationScheme classificationSchemeModel = null;
using (var scope = _container.BeginLifetimeScope())
{
var controller = scope.Resolve <ClassificationSchemeController>();
var actionResult = await controller.GetAsync(classificationScheme.Id);
Assert.That(actionResult, Is.Not.Null);
Assert.That(actionResult, Is.InstanceOf <OkObjectResult>());
var okObjectResult = (OkObjectResult)actionResult;
Assert.That(okObjectResult.Value, Is.InstanceOf <Web.Model.ClassificationScheme>());
classificationSchemeModel = (Web.Model.ClassificationScheme)okObjectResult.Value;
Assert.That(classificationSchemeModel.Id, Is.EqualTo(classificationScheme.Id));
}
var classificationSchemeClassifierMap = classificationScheme.Classifiers.ToMap(
classificationSchemeModel.Classifiers);
var classifierMap = classificationScheme.Classifiers.Select(classificationSchemeClassifier => classificationSchemeClassifier.Classifier).ToMap(
classificationSchemeModel.Classifiers.Select(classificationSchemeClassifier => classificationSchemeClassifier.Classifier));
foreach (var classificationSchemeClassifier in classificationScheme.Classifiers)
{
var classificationSchemeClassifierModel = classificationSchemeClassifierMap(classificationSchemeClassifier);
Assert.That(
classificationSchemeClassifierModel.Classifier, Is.EqualTo(classifierMap(classificationSchemeClassifier.Classifier)));
Assert.That(
classificationSchemeClassifierModel.Super,
Is.EqualTo(classificationSchemeClassifierMap(classificationSchemeClassifier.Super)));
Assert.That(
classificationSchemeClassifierModel.Sub.ToHashSet().SetEquals(
classificationSchemeClassifier.Sub.Select(sub => classificationSchemeClassifierMap(sub))), Is.True);
}
Assert.That(classificationScheme.Classifiers.All(
csc =>
classificationSchemeClassifierMap.PreservesStructure(
classificationSchemeClassifier => classificationSchemeClassifier.Super,
classificationSchemeClassifier => classificationSchemeClassifier.Super,
csc) &&
classificationSchemeClassifierMap.PreservesStructure(
classificationSchemeClassifier => classificationSchemeClassifier.Sub,
classificationSchemeClassifier => classificationSchemeClassifier.Sub,
csc) &&
classificationSchemeClassifierMap(csc).Classifier == classifierMap(csc.Classifier)), Is.True);
}
private void BuildView(ClassificationScheme classificationScheme)
{
this.SuspendLayout();
this.Text = classificationScheme.Settings.Name;
var table = GUIUtils.CreateTable(new double[] { .33, .33, .33 }, Direction.Horizontal);
// classifier
var classifierSettings = new DerivedTypeConfigurationPanel(typeof(IClassifier), classificationScheme.Classifier);
this.getClassifier = () => (IClassifier)classifierSettings.GetConfiguredObject();
table.Controls.Add(classifierSettings, 0, 0);
// general settings
var generalSettings = new ConfigurationPanel(classificationScheme.Settings);
table.Controls.Add(generalSettings, 1, 0);
// bin selection
var panel = new Panel()
{
Dock = DockStyle.Fill
};
var binList = new CheckedListBox()
{
Dock = DockStyle.Fill, CheckOnClick = true
};
binList.AddContextMenu();
this.ToolTip.SetToolTip(binList, "Select which time bins from each trial will be used to train the classifier");
var timeBins = GeneralClassifierSettings.MAX_BINS
.CountTo()
.Select(i => new TimeBin(i)
{
Checked = classificationScheme.Settings.SelectedBins.Contains(i)
})
.ToIArray();
binList.ItemCheck += (sender, args) => ((TimeBin)binList.Items[args.Index]).Checked = (args.NewValue == CheckState.Checked);
Action <int> refreshBinList = (binWidth) =>
{
// ensure the right number of items
int binCount = GeneralClassifierSettings.GetBinCount(binWidth);
if (binList.Items.Count < binCount)
{
binList.Items.AddRange(timeBins.SubView(binList.Items.Count, binCount - binList.Items.Count).ToArray());
}
else
{
for (int i = binList.Items.Count - 1; i >= binCount; i--)
{
binList.Items.RemoveAt(i);
}
}
// ensure correct width and uncheck all
TimeBin timeBin;
for (int i = 0; i < binCount; i++)
{
timeBin = (TimeBin)binList.Items[i];
timeBin.BinWidth = binWidth;
binList.SetItemChecked(i, timeBin.Checked);
}
binList.Invalidate();
};
refreshBinList(classificationScheme.Settings.BinWidthMillis);
var binWidthProp = typeof(GeneralClassifierSettings).GetProperty("BinWidthMillis");
var nameProp = typeof(GeneralClassifierSettings).GetProperty("Name");
if (binWidthProp == null || nameProp == null)
{
throw new Exception("Failed to find properties!");
}
generalSettings.PropertyChanged += args =>
{
if (args.Property.Equals(binWidthProp))
{
refreshBinList((int)args.Getter());
}
else if (args.Property.Equals(nameProp))
{
this.Text = args.Getter().ToString();
}
};
this.getSettings = () =>
{
var settings = (GeneralClassifierSettings)generalSettings.GetConfiguredObject();
settings.SelectedBins = binList.CheckedIndices.Cast <int>().ToIArray();
return(settings);
};
panel.Controls.Add(binList);
panel.Controls.Add("Time Bins".ToLabel());
var saveButton = GUIUtils.CreateFlatButton("Save", (b) =>
{
this.saveDialog.FileName = this.Text;
if (this.saveDialog.ShowDialog() != DialogResult.OK)
{
return;
}
bool saved = this.ClassificationScheme.TrySerializeToFile(this.saveDialog.FileName);
GUIUtils.Alert((saved ? "Saved" : "Failed to save")
+ " classifier info to " + this.saveDialog.FileName,
(saved ? MessageBoxIcon.Information : MessageBoxIcon.Error));
string directory = Path.GetDirectoryName(this.saveDialog.FileName);
if (Directory.Exists(directory))
{
this.saveDialog.InitialDirectory = directory;
}
});
saveButton.Dock = DockStyle.Bottom;
panel.Controls.Add(saveButton);
table.Controls.Add(panel, 2, 0);
this.Controls.Add(table);
this.ResumeLayout(false);
}
public XmlCategory(ClassificationScheme scheme, string name, bool concrete, Category [] parents, ExprNode expression)
: base(scheme, name, concrete, parents)
{
this.expression = expression;
}
/// <summary>
/// Construct a <b>RefinableCategory</b> with the given name.
/// </summary>
/// <param name="scheme">The owning <see cref="ClassificationScheme"/>.</param>
/// <param name="name">The name of this <b>RefinableCategory</b>.</param>
protected RefinableCategory(ClassificationScheme scheme, string name)
: base(scheme, name, true)
{
}
/// <summary>
/// Construct a <b>RefinableCategory</b> that is a sub-classification of other
/// <see cref="Category"/> instances.
/// </summary>
/// <param name="scheme">The owning <see cref="ClassificationScheme"/>.</param>
/// <param name="name">The name of this <b>RefinableCategory</b>.</param>
/// <param name="parents">The parent <see cref="Category"/> instances.</param>
protected RefinableCategory(ClassificationScheme scheme, string name, Category [] parents)
: base(scheme, name, true, parents)
{
}
/// <summary>
/// Construct a tab set to the specified scheme
/// </summary>
public ClassificationSchemeTab(ClassificationScheme classificationScheme)
: base()
{
this.BuildView(classificationScheme);
}
