public bool HasChangedRoles(Object derivable, RelationKind relationKind)
{
Func <IRoleType, bool> check;
switch (relationKind)
{
case RelationKind.Regular:
check = (roleType) => !roleType.RelationType.IsDerived && !roleType.RelationType.IsSynced;
break;
case RelationKind.Derived:
check = (roleType) => roleType.RelationType.IsDerived;
break;
case RelationKind.Synced:
check = (roleType) => roleType.RelationType.IsSynced;
break;
default:
check = (roleType) => true;
break;
}
this.RoleTypesByAssociation.TryGetValue(derivable.Id, out var changedRoleTypes);
if (changedRoleTypes != null)
{
if (changedRoleTypes.Any(roleType => check(roleType)))
{
return(true);
}
}
return(false);
}
internal void AddDependency(Object dependent, Object[] dependencies)
{
if (dependent != null && dependencies.Length > 0)
{
var dependentNode = this.GetOrAddDerivationNode(dependent);
if (dependentNode.Dependencies == null)
{
dependentNode.Dependencies = dependencies
.Where(v => v != null)
.Select(this.GetOrAddDerivationNode)
.Distinct()
.Where(v => !v.Equals(dependentNode))
.ToArray();
}
else
{
dependentNode.Dependencies = dependentNode.Dependencies
.Union(dependencies
.Where(v => v != null)
.Select(this.GetOrAddDerivationNode))
.Distinct()
.Where(v => !v.Equals(dependentNode))
.ToArray();
}
if (dependentNode.Dependencies.Length == 0)
{
dependentNode.Dependencies = null;
}
}
}
internal bool IsScheduled(Object @object)
{
if (this.NodeByObject.TryGetValue(@object, out var node))
{
return(node.IsScheduled);
}
return(false);
}
private Node GetOrAddDerivationNode(Object @object)
{
if (!this.NodeByObject.TryGetValue(@object, out var derivationNode))
{
derivationNode = new Node(@object);
this.NodeByObject.Add(@object, derivationNode);
}
return(derivationNode);
}
public bool HasChangedAssociations(Object derivable, params AssociationType[] associationTypes)
{
this.AssociationTypesByRole.TryGetValue(derivable.Id, out var changedAssociationTypes);
if (changedAssociationTypes != null)
{
if (associationTypes.Length == 0 || associationTypes.Any(associationType => changedAssociationTypes.Contains(associationType)))
{
return(true);
}
}
return(false);
}
public bool HasChangedRoles(Object derivable, params RoleType[] roleTypes)
{
this.RoleTypesByAssociation.TryGetValue(derivable.Id, out var changedRoleTypes);
if (changedRoleTypes != null)
{
if (roleTypes.Length == 0 || roleTypes.Any(roleType => changedRoleTypes.Contains(roleType)))
{
return(true);
}
}
return(false);
}
// TODO: move to security
public static void AddCreatorSecurityToken(this Domain.Object @this)
{
var accessControlledObject = @this as AccessControlledObject;
if (accessControlledObject != null)
{
var creator = new Users(@this.Strategy.Session).GetCurrentAuthenticatedUser();
if (creator != null)
{
accessControlledObject.AddSecurityToken(creator.OwnerSecurityToken);
}
}
}
public static void BaseOnPostBuild(this Domain.Object @this, ObjectOnPostBuild method)
{
// TODO: Optimize
foreach (var concreteRoleType in ((Class)@this.Strategy.Class).ConcreteRoleTypes)
{
if (concreteRoleType.IsRequired)
{
var relationType = concreteRoleType.RelationType;
var unit = relationType.RoleType.ObjectType as IUnit;
if (unit != null && [email protected](relationType))
{
switch (unit.UnitTag)
{
case UnitTags.Boolean:
@this.Strategy.SetUnitRole(relationType, false);
break;
case UnitTags.Decimal:
@this.Strategy.SetUnitRole(relationType, 0m);
break;
case UnitTags.Float:
@this.Strategy.SetUnitRole(relationType, 0d);
break;
case UnitTags.Integer:
@this.Strategy.SetUnitRole(relationType, 0);
break;
case UnitTags.Unique:
@this.Strategy.SetUnitRole(relationType, Guid.NewGuid());
break;
case UnitTags.DateTime:
@this.Strategy.SetUnitRole(relationType, @this.Strategy.Session.Now());
break;
}
}
}
}
}
internal void Mark(Object @object) => this.GetOrAddDerivationNode(@object).IsMarked = true;
internal Node(Domain.Object derivable) => this.derivable = derivable;
protected override void OnPreDeriving(Domain.Object derivable)
{
}
protected override void OnAddedDerivable(Domain.Object derivable)
{
}
public bool HasChangedRole(Object derivable, RoleType roleType)
{
this.RoleTypesByAssociation.TryGetValue(derivable.Id, out var changedRoleTypes);
return(changedRoleTypes?.Contains(roleType) ?? false);
}
public bool IsCreated(Object derivable) => this.Created.Contains(derivable.Id);
internal void Schedule(Object @object) => this.GetOrAddDerivationNode(@object).IsScheduled = true;
protected override void OnAddedDependency(Domain.Object dependent, Domain.Object dependee)
{
}
public bool HasChangedAssociation(Object derivable, AssociationType associationType)
{
this.AssociationTypesByRole.TryGetValue(derivable.Id, out var changedAssociationTypes);
return(changedAssociationTypes?.Contains(associationType) ?? false);
}
