public EntityGraphNode(Type entityType, IEntityGraphNode parent, ITableConfig table, IRelationConfig relation)
{
this.EntityType = entityType;
this.Parent = parent;
this.Table = table;
this.Relation = relation;
}
protected virtual IEntityGraphNode CreateNode(IEntityGraphNode parent, IRelationConfig relation, IEntityMapper mapper)
{
var node = (EntityGraphNode)this.Members.Invoke(this, "CreateNode", new[] { this.GetMapping(parent.Table).EntityType, relation.RelationType }, parent, relation);
node.Children = GetChildren(this, node, mapper);
return(node);
}
protected virtual EntityAction OnVisit(IEntityGraphNode node, Frame frame)
{
var result = EntityAction.None;
var persister = this.GetPersister(node);
if (frame.Persisted != null && frame.Updated != null)
{
if (node.Relation == null || node.Relation.Flags.HasFlag(RelationFlags.CascadeUpdate))
{
result = persister.Update(frame.Persisted, frame.Updated, this.GetParameters(frame, node.Relation));
this.Cascade(node, frame);
}
}
else if (frame.Updated != null)
{
if (node.Relation == null || node.Relation.Flags.HasFlag(RelationFlags.CascadeAdd))
{
result = persister.Add(frame.Updated, this.GetParameters(frame, node.Relation));
this.Cascade(node, frame);
}
}
else if (frame.Persisted != null)
{
if (node.Relation == null || node.Relation.Flags.HasFlag(RelationFlags.CascadeDelete))
{
this.Cascade(node, frame);
result = persister.Delete(frame.Persisted, this.GetParameters(frame, node.Relation));
}
}
return(result);
}
public override EntityGraphIdentifier[] ReportConnectedNodeList(EntityGraphIdentifier target)
{
IEntityGraphNode node = this.GetNode(target);
Log <Service> .Logger.Debug("Report undering lists.");
return(node.ReportConnectedNodeList());
}
protected virtual IEntityPersister GetPersister(IEntityGraphNode node)
{
return(this.EntityPersisters.GetOrAdd(node.Table, key =>
{
var persister = new EntityPersister(this.Database, key, this.Transaction);
return persister;
}));
}
protected virtual EntityAction OnVisit <T, TRelation>(IEntityGraphNode <T, TRelation> node, Frame <T> frame)
{
var difference = EntityDiffer.Instance.GetDifference <T, TRelation>(node.Relation, frame.Persisted, frame.Updated);
foreach (var element in difference.All)
{
return(this.OnVisit(node, new Frame <TRelation>(frame, element.Persisted, element.Updated)));
}
return(EntityAction.None);
}
protected virtual void Cascade(IEntityGraphNode node, Frame frame)
{
foreach (var child in node.Children)
{
if (child.Relation == null)
{
continue;
}
this.Members.Invoke(this, "OnVisit", new[] { node.EntityType, child.Relation.RelationType }, child, frame);
}
}
public override void ShutDownEntity(EntityGraphIdentifier p)
{
IEntityGraphNode node = this.GetNode(p);
if (node == EntityGraphNode.NullNode)
{
return;
}
if (node == null)
{
return;
}
Entity entity = node as Entity;
entity.Close();
Scheduler.Schedule(base.Thread, Job.Create <Entity>(new Action <Entity>(this.ForceRemoveEntity), entity), 10000);
}
public override string ReportOperationTimeReport(EntityGraphIdentifier p, EntityGraphIdentifier q)
{
IEntityGraphNode node = this.GetNode(p);
if (node == EntityGraphNode.NullNode)
{
return("");
}
if (node is Entity)
{
Entity entity = node as Entity;
Log <Service> .Logger.Debug("Found Entity : Request TimeReport");
return(entity.ReportOperationTimeReport(q));
}
return(OperationTimeReportElement.ReportString(this.OperationTimeReport));
}
public EntityGraph(IEntityGraphNode root)
{
this.Root = root;
}
public CollectionEntityRelationGraphNode(IEntityGraphNode parent, ICollectionRelationConfig <T, TRelation> relation) : base(parent, relation.RightTable, relation)
{
}
protected virtual void OnVisit <T, TRelation>(IEntityEnumeratorBuffer buffer, IEntityEnumeratorSink sink, IEntityGraphNode <T, TRelation> node)
{
if (!buffer.Exists(node.Parent.Table) || !buffer.Exists(node.Table))
{
return;
}
var parent = (T)buffer.Get(node.Parent.Table);
var child = (TRelation)buffer.Get(node.Table);
node.Relation.Accessor.Set(parent, child);
}
protected virtual void OnVisit <T>(IEntityEnumeratorBuffer buffer, IEntityEnumeratorSink sink, IEntityGraphNode <T> node)
{
do
{
if (!buffer.Exists(node.Table))
{
if (buffer.HasKey(node.Table))
{
buffer.Create(node.Table);
}
break;
}
else if (buffer.KeyChanged(node.Table))
{
this.OnEmit(buffer, sink, node.Table);
}
else
{
break;
}
} while (true);
}
protected virtual void Visit(IEntityEnumeratorBuffer buffer, IEntityEnumeratorSink sink, IEntityGraphNode node)
{
if (node.Table != null)
{
this.Members.Invoke(this, "OnVisit", node.EntityType, buffer, sink, node);
if (node.Relation != null)
{
this.Members.Invoke(this, "OnVisit", new[] { node.Parent.EntityType, node.Relation.RelationType }, buffer, sink, node);
}
}
foreach (var child in node.Children)
{
this.Visit(buffer, sink, child);
}
}
protected static IEnumerable <IEntityGraphNode> GetChildren(EntityGraphBuilder builder, IEntityGraphNode parent, IEntityMapper mapper)
{
var children = new List <IEntityGraphNode>();
foreach (var relation in parent.Table.Relations)
{
if (!mapper.Relations.Contains(relation))
{
continue;
}
if (children.Any(child => TableComparer.TableConfig.Equals(child.Relation.RightTable, relation.RightTable)))
{
continue;
}
children.Add(builder.CreateNode(parent, relation, mapper));
}
return(children);
}
protected virtual EntityGraphNode <TRelation> CreateNode <T, TRelation>(IEntityGraphNode <T> parent, ICollectionRelationConfig <T, TRelation> relation)
where T : class
where TRelation : class
{
return(new CollectionEntityRelationGraphNode <T, TRelation>(parent, relation));
}
