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); }