public Schema Associate(Schema schema1, Schema schema2)
{
Schema associationSchema = GetAssociationSchema(schema1, schema2);
InstantiateSchema(associationSchema);
return associationSchema;
}
public CreateAssociationDlg(Model model, Schema fromSchema)
{
this.model = model;
this.fromSchema = fromSchema;
InitializeComponent();
PopulateSemanticTypes();
}
protected void AddConcreteTypes(TreeNode tn, Schema schema)
{
schema.ConcreteTypes.ForEach(ct =>
{
AddConcreteTypeToNode(tn, ct);
});
}
public void Process(ISemanticProcessor proc, IMembrane membrane, ST_AddNewSubtype data)
{
TreeNode sttn = selectedNode;
Schema parentSchema = (Schema)sttn.Parent.Tag;
Schema schema = new Schema() { Name = data.Name, Alias = data.Alias, Parent = parentSchema };
parentSchema.Subtypes.Add(schema);
AddSchemaNode(sttn, schema);
}
/// <summary>
/// Recurses into subtypes to create a flat view of the semantic hierarchy.
/// </summary>
public static DataTable InitializeSemanticColumns(Schema schema, out List<ConcreteType> semanticColumns)
{
DataTable dt = new DataTable();
dt.TableName = schema.Name;
semanticColumns = new List<ConcreteType>();
dt.Columns.Add("_id");
PopulateSemanticColumns(dt, schema, semanticColumns);
return dt;
}
protected void ShowCollection(Schema schema)
{
Helpers.Try(() =>
{
List<BsonDocument> docs = model.Db.GetAll(schema.Name);
DataTable dt = InitializeCollectionColumns(schema);
PopulateCollectionTable(dt, docs, schema);
Program.serviceManager.Get<ISemanticProcessor>().ProcessInstance<CollectionViewMembrane, ST_Data>(data => data.Table = dt);
});
}
public void Process(ISemanticProcessor proc, IMembrane membrane, ST_Data data)
{
schema = data.Schema;
DataView dv = new DataView(data.Table);
dgView.FindForm().BeginInvoke(() =>
{
dgView.DataSource = dv;
dgView.Columns[0].Visible = false; // Hide the ID field.
label.Text = "Semantic Type: " + data.Table.TableName;
});
}
public static string GetSchemaNodeText(Schema schema)
{
string ret = schema.Name;
if (schema.IsAliased)
{
ret = ret + " (" + schema.Alias + ")";
}
return ret;
}
/// <summary>
/// Initializes the columns of a table with the concrete types for collection associated with the schema,
/// therefore no sub-types are parsed.
/// </summary>
protected DataTable InitializeCollectionColumns(Schema schema)
{
DataTable dt = new DataTable();
dt.TableName = schema.Name;
foreach (ConcreteType ct in schema.ConcreteTypes)
{
dt.Columns.Add(ct.Name);
}
return dt;
}
public static void PopulateSemanticColumns(DataTable dt, Schema schema, List<ConcreteType> columns)
{
foreach (ConcreteType ct in schema.ConcreteTypes)
{
dt.Columns.Add(ct.Alias);
columns.Add(ct);
}
foreach (Schema st in schema.Subtypes)
{
PopulateSemanticColumns(dt, st, columns);
}
}
protected void PopulateCollectionTable(DataTable dt, List<BsonDocument> docs, Schema schema)
{
foreach (BsonDocument doc in docs)
{
DataRow row = dt.NewRow();
foreach (ConcreteType ct in schema.ConcreteTypes)
{
row[ct.Name] = doc[ct.Name];
}
dt.Rows.Add(row);
}
}
public void Process(ISemanticProcessor proc, IMembrane membrane, ST_AddSchema data)
{
Schema schema = new Schema() { Name = data.Name, Alias = data.Alias };
model.Schemata.Add(schema);
TreeNode tn = new TreeNode(Helpers.GetSchemaNodeText(schema));
tn.Tag = schema;
tn.Nodes.Add("Concrete Types");
tn.Nodes.Add("Subtypes");
tv.FindForm().BeginInvoke(() =>
{
tv.Nodes[0].Nodes.Add(tn);
});
}
/// <summary>
/// Recurse into subtypes to populate all concrete data.
/// </summary>
public static void PopulateSemanticTable(DataTable dt, List<BsonDocument> docs, Schema schema)
{
foreach (BsonDocument doc in docs)
{
DataRow row = dt.NewRow();
if (doc.Contains("_id"))
{
row["_id"] = doc["_id"];
}
PopulateConcreteTypes(row, doc, schema);
dt.Rows.Add(row);
}
}
protected void InstantiateMonthLookup(SemanticDatabase sd, Schema schema)
{
sd.Insert(schema, BsonDocument.Parse("{month: 1, monthName: 'January', monthAbbr: 'Jan'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 2, monthName: 'February', monthAbbr: 'Feb'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 3, monthName: 'March', monthAbbr: 'Mar'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 4, monthName: 'April', monthAbbr: 'Apr'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 5, monthName: 'May', monthAbbr: 'May'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 6, monthName: 'June', monthAbbr: 'Jun'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 7, monthName: 'July', monthAbbr: 'Jul'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 8, monthName: 'August', monthAbbr: 'Aug'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 9, monthName: 'September', monthAbbr: 'Sep'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 10, monthName: 'October', monthAbbr: 'Oct'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 11, monthName: 'November', monthAbbr: 'Nov'}"));
sd.Insert(schema, BsonDocument.Parse("{month: 12, monthName: 'December', monthAbbr: 'Dec'}"));
}
/// <summary>
/// Treeview selection.
/// </summary>
public void AfterSelectEvent(object sender, TreeViewEventArgs e)
{
Helpers.Try(() =>
{
object item = e.Node.Tag;
if (item is Schema)
{
currentSchema = (Schema)item;
ShowCollection(currentSchema);
}
else if (item is ConcreteType)
{
}
});
}
/// <summary>
/// Treeview selection.
/// </summary>
public void AfterSelectEvent(object sender, TreeViewEventArgs e)
{
Helpers.Try(() =>
{
object item = e.Node.Tag;
if (item is Schema)
{
currentSchema = (Schema)item;
string plan = model.Db.ShowPlan(currentSchema);
Program.serviceManager.Get<ISemanticProcessor>().ProcessInstance<PlanViewMembrane, ST_Plan>(p => p.Plan = plan);
ResetBuffers();
ShowSemanticData(currentSchema);
}
else if (item is ConcreteType)
{
}
});
}
public static void PopulateConcreteTypes(DataRow row, BsonDocument doc, Schema schema)
{
foreach (ConcreteType ct in schema.ConcreteTypes)
{
if (doc.Contains(ct.Alias))
{
row[ct.Alias] = doc[ct.Alias];
}
else if (doc.Contains(ct.Name))
{
row[ct.Alias] = doc[ct.Name];
}
else
{
row[ct.Alias] = " --- ";
}
}
foreach (Schema st in schema.Subtypes)
{
PopulateConcreteTypes(row, doc, st);
}
}
public void Update(Schema schema)
{
this.schema = schema;
string fwdName = schema.Name + "_";
string revName = "_" + schema.Name;
List<string> collections = model.Db.GetCollections();
List<string> forwardAssoc = collections.Where(n => n.BeginsWith(fwdName) && !n.EndsWith("Association")).ToList();
List<string> reverseAssoc = collections.Where(n => n.EndsWith(revName)).ToList();
// Update forward and reverse navigation buttons.
Program.serviceManager.Get<ISemanticProcessor>().ProcessInstance<AssociationViewMembrane, ST_Associations>(data =>
{
data.ForwardSchemaNames = forwardAssoc;
data.ReverseSchemaNames = reverseAssoc;
});
List<string> fullList = new List<string>();
fullList.AddRange(forwardAssoc);
fullList.AddRange(reverseAssoc);
DataTable dt = Helpers.FillTable(fullList, "Associations");
dataView = new DataView(dt);
view.DataSource = dataView;
}
/// <summary>
/// Add ID's of the source from/to records so we can use the "to" ID's for filtering records when the user moves schema to the main schema view for further navigation.
/// </summary>
protected void AddSchemaFromToIds(DataTable dt, List<BsonDocument> docs, Schema fromSchema, Schema toSchema)
{
string fromSchemaId = fromSchema.Name + "Id";
string toSchemaId = model.ToSchema.Name + "Id";
dt.Columns.Add(fromSchemaId);
dt.Columns.Add(toSchemaId);
for (int i = 0; i < dt.Rows.Count; i++)
{
dt.Rows[i][fromSchemaId] = docs[i][fromSchemaId];
dt.Rows[i][toSchemaId] = docs[i][toSchemaId];
}
}
// TODO: Mostly duplicate code
public void Process(ISemanticProcessor proc, IMembrane membrane, ST_AssociatedData data)
{
model.ToData = data.Table;
schema = data.Schema;
DataView dv = new DataView(data.Table);
dgView.FindForm().BeginInvoke(() =>
{
dgView.DataSource = dv;
dgView.Columns[0].Visible = false; // Hide the ID field.
dgView.Columns[dgView.Columns.Count - 1].Visible = false; // Also hide the last two ID fields, which are the ID's of the master and detail records.
dgView.Columns[dgView.Columns.Count - 2].Visible = false; // Also hide the last two ID fields, which are the ID's of the master and detail records.
label.Text = "Semantic Type: " + data.Table.TableName;
});
}
/// <summary>
/// Delete an entry in the association schema where the doc contains the _id of the association record to delete.
/// </summary>
public void DeleteAssociation(Schema schema, BsonDocument doc)
{
// For example, person_phoneNumber
List<BsonDocument> recs = GetAll(schema.Name, doc["_id"].ToString(), true);
Assert.That(recs.Count == 1, "Association record does not exist.");
BsonDocument rootRec = recs[0];
Assert.That(rootRec["_ref"].ToString().to_i() == 1, "Deleting an association record that is itself associated is not supported.");
// For example, person_phoneNumber_Association
string rootAssociation = schema.Name + "_Association";
string rootAssociationId = rootRec[rootAssociation + "Id"].ToString();
List<BsonDocument> rootAssociationRecs = GetAll(rootAssociation, rootAssociationId, true);
Assert.That(rootAssociationRecs.Count == 1, "Expected one and only one entry for " + rootAssociation + " where _id = " + rootAssociationId);
BsonDocument rootAssociationRec = rootAssociationRecs[0];
string associationId = rootAssociationRec["associationId"].ToString();
// For example, person_phoneNumber_Assocation references the "assocation" collection.
List<BsonDocument> associationRecs = GetAll("association", associationId, true);
Assert.That(associationRecs.Count == 1, "Expected one and only one entry for 'association' where _id = " + associationId);
BsonDocument associationRec = associationRecs[0];
string fwdAssocNameId = associationRec["forwardAssociationNameId"].ToString();
string revAssocNameId = associationRec["reverseAssociationNameId"].ToString();
// Drill into the forward/reverse AssociationName collections
List<BsonDocument> fwdRefNamesRecs = GetAll("forwardAssociationName", fwdAssocNameId, true);
Assert.That(fwdRefNamesRecs.Count == 1, "Expected one and only one name record with _id = " + fwdAssocNameId);
BsonDocument fwdRefNameRec = fwdRefNamesRecs[0];
int fwdRefNameCount = fwdRefNameRec["_ref"].ToString().to_i();
string fwdNameId = fwdRefNameRec["nameId"].ToString();
List<BsonDocument> revRefNamesRecs = GetAll("reverseAssociationName", revAssocNameId, true);
Assert.That(revRefNamesRecs.Count == 1, "Expected one and only one name record with _id = " + revAssocNameId);
BsonDocument revRefNameRec = revRefNamesRecs[0];
int revRefNameCount = revRefNameRec["_ref"].ToString().to_i();
string revNameId = revRefNameRec["nameId"].ToString();
// Drill into the name collection.
List<BsonDocument> fwdNameRecs = GetAll("name", fwdNameId, true);
Assert.That(fwdNameRecs.Count == 1, "Expected one and only one name record with _id = " + fwdNameId);
BsonDocument fwdNameRec = fwdNameRecs[0];
string fwdName = fwdNameRec["name"].ToString();
List<BsonDocument> revNameRecs = GetAll("name", revNameId, true);
Assert.That(revNameRecs.Count == 1, "Expected one and only one name record with _id = " + revNameId);
BsonDocument revNameRec = revNameRecs[0];
string revName = revNameRec["name"].ToString();
// We now have all the pieces needed to traverse back up the hierarchy.
Schema nameSchema = GetNameSchema();
InternalDelete(nameSchema, BsonDocument.Parse("{name: '" + fwdName + "'}"));
InternalDelete(nameSchema, BsonDocument.Parse("{name: '" + revName + "'}"));
// The rest have no concrete types, so we can't use InternalDelete because we haven't really implemented Delete correctly to handle cascading (downward) deletes. A big TODO to understand this correctly.
DecrementRefCountOrDelete("forwardAssociationName", fwdRefNameRec, fwdRefNameCount);
DecrementRefCountOrDelete("reverseAssociationName", revRefNameRec, revRefNameCount);
DecrementRefCountOrDelete("association", associationRec, associationRec["_ref"].ToString().to_i());
DecrementRefCountOrDelete(rootAssociation, rootAssociationRec, rootAssociationRec["_ref"].ToString().to_i());
DecrementRefCountOrDelete(schema.Name, rootRec, rootRec["_ref"].ToString().to_i());
}
protected string InternalInsert(Schema schema, BsonDocument doc)
{
string id = null;
if (schema.IsConcreteType)
{
int refCount;
BsonDocument currentObject = GetConcreteObjects(schema, doc);
if (currentObject.Elements.Count() == 0)
{
id = null; // nothing to insert!
}
else
{
BsonDocument dealiasedDocument = DeAliasDocument(schema, currentObject);
if (IsDuplicate(schema.Name, dealiasedDocument, out id, out refCount))
{
IncrementRefCount(schema.Name, id, refCount);
}
else
{
BsonDocument withRef = AddRef1(dealiasedDocument);
id = InsertRecord(schema, withRef);
}
}
}
else
{
BsonDocument currentObject = GetConcreteObjects(schema, doc);
BsonDocument subjobj = RemoveCurrentConcreteObjects(schema, doc);
InsertRecurseIntoSubtypes(schema, currentObject, subjobj);
int refCount;
if (currentObject.Elements.Count() == 0)
{
id = null; // nothing to insert!
}
else
{
BsonDocument dealiasedDocument = DeAliasDocument(schema, currentObject);
if (IsDuplicate(schema.Name, dealiasedDocument, out id, out refCount))
{
IncrementRefCount(schema.Name, id, refCount);
}
else
{
BsonDocument withRef = AddRef1(dealiasedDocument);
id = InsertRecord(schema, withRef);
}
}
}
return id;
}
protected void InstantiateTestPersonRecords(SemanticDatabase sd, Schema schema)
{
sd.Insert(schema, BsonDocument.Parse("{firstName: 'Marc', lastName: 'Clifton'}"));
sd.Insert(schema, BsonDocument.Parse("{firstName: 'April', lastName: 'Jones'}"));
}
protected void InstantiateTestDateRecords(SemanticDatabase sd, Schema schema)
{
sd.Insert(schema, BsonDocument.Parse("{month: 8, day: 19, year: 1962}"));
sd.Insert(schema, BsonDocument.Parse("{month: 4, day: 1, year: 2016}"));
}
protected void AddConcreteTypes(Schema schema, TreeNode cttn)
{
foreach (ConcreteType ct in schema.ConcreteTypes)
{
TreeNode ctNode = cttn.Nodes.Add(Helpers.GetConcreteTypeText(ct));
ctNode.Tag = ct;
}
}
protected void OnShowReverseAssociatedData(object sender, EventArgs e)
{
try
{
showForward = false;
// TODO: If we make this a separate view class, it can maintain the from/to/assoc Schema variables itself instead of hold them in the main form class!
string assocName = (string)((Button)sender).Tag;
string fromSchemaName = assocName.LeftOf("_");
string toSchemaName = assocName.RightOf("_");
model.FromSchema = model.GetSchema(fromSchemaName);
model.ToSchema = model.GetSchema(toSchemaName);
model.IsReverseAssociation = true;
assocSchema = model.Db.GetAssociationSchema(model.FromSchema, model.ToSchema);
ShowReverseAssociatedData();
EnableMoveUp();
}
catch (Exception ex)
{
Helpers.Log(ex.Message);
ClearAssociationData();
}
}
/// <summary>
/// Recurse into subtypes, adding only uniquely named schemas.
/// </summary>
protected void AddSchema(Schema schema, List<Schema> schemas)
{
schemas.AddIfUnique(schema, x => x.Name == schema.Name);
schema.Subtypes.ForEach(s => AddSchema(s, schemas));
}
protected void AddSubtypes(Schema schema, TreeNode subTypesNode)
{
foreach(Schema st in schema.Subtypes)
{
TreeNode tn = CreateSchemaNode(st);
subTypesNode.Nodes.Add(tn);
}
}
public static Schema InstantiateSchema(string json)
{
Schema target = new Schema();
JsonConvert.PopulateObject(json, target);
return target;
}
protected TreeNode CreateSchemaNode(Schema schema)
{
TreeNode schemaRootNode = new TreeNode(Helpers.GetSchemaNodeText(schema));
schemaRootNode.Tag = schema;
TreeNode concreteTypesNode = schemaRootNode.Nodes.Add("Concrete Types");
TreeNode subTypesNode = schemaRootNode.Nodes.Add("Subtypes");
AddConcreteTypes(schema, concreteTypesNode);
AddSubtypes(schema, subTypesNode);
return schemaRootNode;
}
