protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext)
{
// The relationship (definition) being accessed
// (don't evaluate in loop for now ... OK while they're just literals)
IEntity relationship = Right.EvaluateEntity(evalContext);
IEntity current = Left.EvaluateEntity(evalContext);
if (current == null)
{
yield break;
}
// Relationship data
IEntityRelationshipCollection <IEntity> values = current.GetRelationships(relationship,
Direction);
foreach (var pair in values)
{
var result = new EntitySetHandle
{
Entity = pair != null ? pair.Entity : null,
Expression = this
};
yield return(result);
}
}
public void EnsureTypeHasFields( )
{
// Ensure that regex is not applied for empty string, if IsRequired is not set.
IEntity e = Entity.Get(new EntityRef("test", "employee"));
IEntityRelationshipCollection <IEntity> coll = e.GetRelationships(EntityType.Fields_Field, Direction.Reverse);
Assert.IsTrue(coll.Count > 0);
}
/// <summary>
/// Reads the list of related entity IDs out of an entity for a given relationship type.
/// </summary>
private static IEnumerable <IEntity> GetRelationshipList(IEntity entity, IEntity relationshipDefn, Direction direction, string alias)
{
IEntityRelationshipCollection <IEntity> oRelated = entity.GetRelationships(relationshipDefn, direction);
if (oRelated == null)
{
return(Enumerable.Empty <IEntity>());
}
return(oRelated.Where(ri => ri.Entity != null));
}
/// <summary>
/// Multi-relationship setter implementation for strong types.
/// </summary>
/// <typeparam name="T">Type of entity being pointed to.</typeparam>
/// <param name="alias">Relationship alias.</param>
/// <param name="values">New entities to point to, or null.</param>
/// <param name="direction">Relationship direction.</param>
protected void SetRelationships <T>(string alias, IEntityCollection <T> values, Direction direction)
where T : class, IEntity
{
IEntityRelationshipCollection <T> converted = null;
if (values != null)
{
converted = new EntityRelationshipCollection <T>(values);
}
_entity.SetRelationships(alias, converted, direction);
}
public void GetRelationshipInstancesByRelId( )
{
IEntity entity = Entity.GetByName("Test 01").First( );
long relId = Entity.GetId("test", "herbs");
IEntityRelationshipCollection <IEntity> instances =
entity.GetRelationships(relId, Direction.Forward);
foreach (var i in instances)
{
IEntity relatedEntity = i.Entity; // this is typically what you want
}
}
/// <summary>
/// Get the removed entities in a rel collection, ignoring temporary entities
/// </summary>
IEnumerable <IEntity> GetRemoved(IEntityRelationshipCollection <IEntity> rels)
{
var addedIds = rels.Tracker.Added.Select(i => i.Key);
var removedIds = rels.Tracker.Removed.Select(i => i.Key).Except(addedIds).Where(i => !EntityId.IsTemporary(i));
if (removedIds.Any())
{
return(Entity.Get(removedIds));
}
else
{
return(Enumerable.Empty <IEntity>());
}
}
/// <summary>
/// Get the added entities in a rel collection
/// </summary>
IEnumerable <IEntity> GetAdded(IEntityRelationshipCollection <IEntity> rels)
{
var removedIds = rels.Tracker.Removed.Select(i => i.Key);
var addedIds = rels.Tracker.Added.Select(i => i.Key).Except(removedIds);
if (addedIds.Any())
{
return(rels.Where(e => e != null && addedIds.Contains(e.Id)).ToList());
}
else
{
return(Enumerable.Empty <IEntity>());
}
}
/// <summary>
/// Implementation for relationship actions.
/// </summary>
/// <param name="entities">Entities to set.</param>
/// <param name="relId">ID of relationship to update.</param>
/// <param name="direction">Direction of relationship.</param>
/// <param name="defaultValue">Proposed default value.</param>
/// <param name="defaultToCurrentUser">True if the current user should be the default value.</param>
/// <param name="defaultUseCurrentPerson">True if the account holder of the user should be the default value.</param>
private void SetDefaultForRelationship(IEnumerable <IEntity> entities, long relId, Direction direction, IEntity defaultValue, bool defaultToCurrentUser, bool defaultUseCurrentPerson)
{
if (defaultToCurrentUser || defaultUseCurrentPerson)
{
defaultValue = GetCurrentUser(defaultUseCurrentPerson);
}
foreach (IEntity entity in entities)
{
IEntityRelationshipCollection <IEntity> relValues = entity.GetRelationships(relId, direction);
if (relValues.Count == 0)
{
relValues.Add(defaultValue);
}
}
}
/// <summary>
/// Multi-flag enum getter implementation for strong types.
/// </summary>
/// <typeparam name="TEntity">Entity type for the enum value.</typeparam>
/// <typeparam name="TEnum">C# enum type</typeparam>
/// <param name="alias">Alias for the enum relationship.</param>
/// <param name="direction">Direction of the enum relationship. (Presumably forwards)</param>
/// <param name="convertAliasToEnum">Callback to convert aliases to enum instance values.</param>
/// <param name="combineFlags">Callback to 'or' two enum flags together.</param>
/// <returns>Nullable enum value.</returns>
protected TEnum?GetMultiEnum <TEntity, TEnum>(string alias, Direction direction, Func <string, TEnum?> convertAliasToEnum, Func <TEnum?, TEnum?, TEnum?> combineFlags)
where TEntity : class, IEntity
where TEnum : struct
{
// Get related entities
IEntityRelationshipCollection <TEntity> enumEntities = GetRelationships <TEntity>(alias, direction);
// Handle null
if (enumEntities == null)
{
return(null);
}
TEnum?enumValue = null;
long aliasFieldId = WellKnownAliases.CurrentTenant.Alias;
// Convert values to enum and combine
foreach (TEntity value in enumEntities.Entities)
{
// Get alias of enum
// Note : we would use enumEntity.Alias, except it doesn't return a namespace because it is from IEntityRef.Alias
string enumAlias = value.GetField <string>(aliasFieldId);
if (enumValue == null)
{
enumValue = convertAliasToEnum(enumAlias);
}
else
{
TEnum?converted = convertAliasToEnum(enumAlias);
enumValue = combineFlags(enumValue, converted);
}
}
return(enumValue);
}
public void TestCascadeDeleteWithRelationships2( )
{
var f1 = Entity.Create <NavContainer>( );
f1.Name = "f1";
f1.Save( );
var f2 = Entity.Create <NavContainer>( );
f2.Name = "f2";
f2.ResourceInFolder.Add(f1);
var f3 = Entity.Create <NavContainer>( );
f3.Name = "f3";
f3.ResourceInFolder.Add(f2);
f3.ShortcutInFolder.Add(f1);
f3.Save( );
long id1 = f1.Id;
Assert.IsTrue(Entity.Exists(f1), "a f1");
Assert.IsTrue(Entity.Exists(f2), "a f2");
Assert.IsTrue(Entity.Exists(f3), "a f3");
f2.Delete( );
Assert.AreEqual(0, f3.Shortcuts.Count);
IEntity e = Entity.Get(id1);
var relDefn = new EntityRef("console", "shortcutInFolder");
IEntityRelationshipCollection <IEntity> oRelated = e.GetRelationships(relDefn, Direction.Reverse);
Assert.IsFalse(oRelated.Any(ri => ri.Entity == null));
Assert.AreEqual(0, oRelated.Count);
f1.Delete( );
}
public void SetChoiceMultiple( )
{
var sch = new ScheduleDailyRepeat
{
Name = "Test sch" + DateTime.Now
};
sch.Save( );
// _toDelete.Add(sch.Id);
var setAction = new SetChoiceActivity( );
setAction.Save( );
ToDelete.Add(setAction.Id);
var setChoiceAs = setAction.As <WfActivity>( );
ActivityImplementationBase nextActivity = setChoiceAs.CreateWindowsActivity( );
var dayOfWeekRef = ( EntityRef )"core:sdrDayOfWeek";
var args = new Dictionary <string, object>
{
{
"Resource to Update", sch
},
{
"Field to Update", dayOfWeekRef.Entity
},
{
"New Value", new EntityRef("core:dowSunday").Entity
},
};
RunActivity(nextActivity, args);
sch = Entity.Get <ScheduleDailyRepeat>(sch.Id);
IEntityRelationshipCollection <IEntity> dowRefs = sch.GetRelationships(dayOfWeekRef);
Assert.AreEqual(1, dowRefs.Count( ), "has been set");
Assert.IsTrue(dowRefs.Any(w => w.Entity.Alias == "dowSunday"));
args = new Dictionary <string, object>
{
{
"Resource to Update", sch
},
{
"Field to Update", dayOfWeekRef.Entity
},
{
"New Value", new EntityRef("core:dowMonday").Entity
},
{
"Replace Existing Values", false
}
};
RunActivity(nextActivity, args);
sch = Entity.Get <ScheduleDailyRepeat>(sch.Id);
dowRefs = sch.GetRelationships(dayOfWeekRef);
Assert.AreEqual(2, dowRefs.Count( ), "has been added");
Assert.IsTrue(dowRefs.Any(w => w.Entity.Alias == "dowMonday"));
args = new Dictionary <string, object>
{
{
"Resource to Update", sch
},
{
"Field to Update", dayOfWeekRef.Entity
},
{
"New Value", new EntityRef("core:dowTuesday").Entity
},
{
"Replace Existing Values", true
}
};
RunActivity(nextActivity, args);
sch = Entity.Get <ScheduleDailyRepeat>(sch.Id);
dowRefs = sch.GetRelationships(dayOfWeekRef);
Assert.AreEqual(1, dowRefs.Count( ), "has been reset");
Assert.IsTrue(dowRefs.Any(w => w.Entity.Alias == "dowTuesday"));
}
/// <summary>
/// Sets the relationships for the specified relationship definition.
/// </summary>
/// <param name="relationshipDefinition">The relationship definition.</param>
/// <param name="relationships">The relationships.</param>
/// <param name="direction"></param>
/// <exception cref="System.NotImplementedException"></exception>
public void SetRelationships(long relationshipDefinition, IEntityRelationshipCollection relationships, Direction direction)
{
throw new NotImplementedException( );
}
/// <summary>
/// Locates the invalid permission relationships.
/// </summary>
/// <param name="entities">The entities.</param>
/// <param name="permission">The permission.</param>
/// <param name="permissionRelationships">The permission relationships.</param>
/// <param name="direction">The direction.</param>
/// <param name="invalidPermissions">The invalid permissions.</param>
private void LocateInvalidPermissionRelationships(IEnumerable <IEntity> entities, Permission permission, IEntityRelationshipCollection <IEntity> permissionRelationships, Direction direction, ISet <long> invalidPermissions)
{
if (permissionRelationships != null && permissionRelationships.Count > 0)
{
IList <IEntity> enumerable = entities as IList <IEntity> ?? entities.ToList( );
foreach (var relationship in permissionRelationships.Where(entityRelationship => entityRelationship != null && entityRelationship.Entity != null))
{
LocateInvalidObjects(enumerable, relationship.Entity.Id, direction, invalidObjects =>
{
/////
// If there are any invalid objects, mark the permission as invalid.
/////
if (invalidObjects != null && invalidObjects.Count > 0)
{
invalidPermissions.Add(permission.Id);
}
});
}
}
}
/// <summary>
/// Sets the relationships for the specified relationship definition.
/// </summary>
/// <param name="relationshipDefinition">The relationship definition.</param>
/// <param name="relationships">The relationships.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void SetRelationships(string relationshipDefinition, IEntityRelationshipCollection relationships)
{
throw new NotImplementedException( );
}
public void Test_RelationshipInstance(string action, string fromPerms, string toPerms, Direction direction, bool saveBothEnds, bool haveFieldChanges, bool expectAllow)
{
if (fromPerms == "modify")
{
fromPerms = "read,modify";
}
if (toPerms == "modify")
{
toPerms = "read,modify";
}
// Create schema
EntityType fromType = new EntityType();
fromType.Inherits.Add(UserResource.UserResource_Type);
fromType.Name = Guid.NewGuid().ToString();
fromType.Save();
EntityType toType = new EntityType();
toType.Inherits.Add(UserResource.UserResource_Type);
toType.Name = Guid.NewGuid().ToString();
toType.Save();
Relationship rel = new Relationship();
rel.Name = Guid.NewGuid().ToString();
rel.FromType = fromType;
rel.ToType = toType;
rel.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany;
rel.Save();
// Create data
IEntity toInst = new Entity(toType);
toInst.Save();
IEntity fromInst = new Entity(fromType);
if (action != "Create")
{
fromInst.SetRelationships(rel, new EntityRelationshipCollection <IEntity> {
toInst
});
}
fromInst.Save();
// Create test user
UserAccount userAccount = Entity.Create <UserAccount>();
userAccount.Name = Guid.NewGuid().ToString();
userAccount.Save();
// Grant access
if (!string.IsNullOrEmpty(fromPerms))
{
new AccessRuleFactory().AddAllowByQuery(
userAccount.As <Subject>(),
fromType.As <SecurableEntity>(),
fromPerms.Split(',').Select(pa => new EntityRef(pa)),
TestQueries.Entities().ToReport());
}
if (!string.IsNullOrEmpty(toPerms))
{
new AccessRuleFactory().AddAllowByQuery(
userAccount.As <Subject>(),
toType.As <SecurableEntity>(),
toPerms.Split(',').Select(pa => new EntityRef(pa)),
TestQueries.Entities().ToReport());
}
// Test
bool allowed = false;
try
{
using (new SetUser(userAccount))
{
IEntity source = Entity.Get(direction == Direction.Forward ? fromInst.Id : toInst.Id);
if (action != "Read")
{
source = source.AsWritable();
}
Func <IEntity> target = () => Entity.Get(direction == Direction.Forward ? toInst.Id : fromInst.Id);
IEntityRelationshipCollection <IEntity> relCol = null;
switch (action)
{
case "Read":
relCol = source.GetRelationships(rel.Id, direction);
IEntity entity = relCol.FirstOrDefault();
allowed = entity != null;
break;
case "Create":
relCol = new EntityRelationshipCollection <IEntity> {
target()
};
source.SetRelationships(rel, relCol);
if (haveFieldChanges)
{
source.SetField("core:name", Guid.NewGuid().ToString());
}
if (saveBothEnds)
{
Entity.Save(new[] { source, target() });
}
else
{
source.Save();
}
allowed = true;
break;
case "Remove":
relCol = source.GetRelationships(rel.Id, direction);
relCol.Remove(target());
source.SetRelationships(rel, relCol);
if (haveFieldChanges)
{
source.SetField("core:name", Guid.NewGuid().ToString());
}
if (saveBothEnds)
{
Entity.Save(new[] { source, target() });
}
else
{
source.Save();
}
allowed = true;
break;
case "Clear":
relCol = source.GetRelationships(rel.Id, direction);
relCol.Clear();
source.SetRelationships(rel, relCol);
if (haveFieldChanges)
{
source.SetField("core:name", Guid.NewGuid().ToString());
}
if (saveBothEnds)
{
Entity.Save(new[] { source, target() });
}
else
{
source.Save();
}
allowed = true;
break;
default:
throw new InvalidOperationException("Unknown " + action);
}
}
Assert.That(allowed, Is.EqualTo(expectAllow));
}
catch (PlatformSecurityException)
{
Assert.That(false, Is.EqualTo(expectAllow));
}
}
public void Test_Relationship(Direction direction, string identityType, int count)
{
// Create schema
EntityType type = Entity.Create <EntityType>( );
type.Name = "Test Type";
type.Inherits.Add(Entity.Get <EntityType>("core:resource"));
type.Save( );
Field stringField = new StringField( ).As <Field>( );
Field intField = new IntField( ).As <Field>( );
EntityType type2 = Entity.Create <EntityType>( );
type2.Name = "Test Type2";
type2.Fields.Add(stringField);
type2.Fields.Add(intField);
type.Inherits.Add(Entity.Get <EntityType>("core:resource"));
type2.Save( );
Relationship relationship = Entity.Create <Relationship>( );
relationship.Name = "Rel1";
relationship.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany;
relationship.FromType = direction == Direction.Forward ? type : type2;
relationship.ToType = direction == Direction.Forward ? type2 : type;
relationship.Save( );
var targets = new List <Resource>( );
for (int i = 0; i < count; i++)
{
string name = "Target" + Guid.NewGuid( );
string stringVal = "StringVal" + i;
int intVal = 100 + i;
Resource target = Entity.Create(type2.Id).AsWritable <Resource>( );
target.SetField(stringField.Id, stringVal);
target.SetField(intField.Id, intVal);
target.Name = name;
target.Save( );
targets.Add(target);
}
using (new SecurityBypassContext( ))
{
new AccessRuleFactory( ).AddAllowByQuery(Entity.Get <Subject>("core:everyoneRole").AsWritable <Subject>( ), type.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type.Id).ToReport( ));
new AccessRuleFactory( ).AddAllowByQuery(Entity.Get <Subject>("core:everyoneRole").AsWritable <Subject>( ), type2.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type2.Id).ToReport( ));
}
Field lookupField = null;
if (identityType.Contains("StringField"))
{
lookupField = stringField;
}
else if (identityType.Contains("IntField"))
{
lookupField = intField;
}
var identities = new List <string>( );
for (int i = 0; i < count; i++)
{
var target = targets[i];
string identity;
if (identityType.Contains("Null"))
{
continue;
}
if (identityType == "Name")
{
identity = "\"" + target.Name + "\"";
}
else if (identityType == "Guid")
{
identity = "\"" + target.UpgradeId + "\"";
}
else if (identityType == "StringField")
{
identity = "\"StringVal" + i + "\"";
}
else if (identityType == "IntField")
{
identity = (100 + i).ToString( );
}
else
{
throw new InvalidOperationException( );
}
identities.Add(identity);
}
// Create JSON
string jsonMember = "rel1";
string json = "{\"" + jsonMember + "\":[" + string.Join(", ", identities) + "]}";
// Create a mapping
var mapping = CreateApiResourceMapping(new EntityRef(type.Id));
var relMapping = CreateApiRelationshipMapping(mapping, new EntityRef(relationship.Id), jsonMember, direction == Direction.Reverse);
relMapping.MappedRelationshipLookupField = lookupField;
relMapping.Save( );
// Fill entity
IEntity entity = RunTest(json, mapping);
IEntityRelationshipCollection <IEntity> value = entity.GetRelationships(relationship.Id, direction);
// Assert mapping
Assert.That(value, Is.Not.Null);
if (identityType == "Null")
{
Assert.That(value, Has.Count.EqualTo(0));
}
else
{
Assert.That(value, Has.Count.EqualTo(targets.Count));
var actual = value.Select(e => e.Id).OrderBy(id => id).ToList( );
var expected = targets.Select(e => e.Id).OrderBy(id => id).ToList( );
Assert.That(actual, Is.EquivalentTo(expected));
}
}
public void SetRelationships(long relationshipDefinition, IEntityRelationshipCollection relationships)
{
_entity.SetRelationships(relationshipDefinition, relationships);
}
public void Test_Lookup(Direction direction, string identityType)
{
string name = "Target" + Guid.NewGuid();
// Create schema
EntityType type = Entity.Create <EntityType>( );
type.Name = "Test Type";
type.Inherits.Add(Entity.Get <EntityType>("core:resource"));
type.Save( );
Field stringField = new StringField( ).As <Field>( );
Field intField = new IntField( ).As <Field>( );
EntityType type2 = Entity.Create <EntityType>( );
type2.Fields.Add(stringField);
type2.Fields.Add(intField);
type2.Name = "Test Type2";
type.Inherits.Add(Entity.Get <EntityType>("core:resource"));
type2.Save( );
Relationship relationship = Entity.Create <Relationship>( );
relationship.Name = "Rel1";
relationship.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
relationship.FromType = direction == Direction.Forward ? type : type2;
relationship.ToType = direction == Direction.Forward ? type2 : type;
relationship.Save( );
Resource target = Entity.Create(type2.Id).AsWritable <Resource>();
target.Name = name;
target.SetField(stringField.Id, "StringVal");
target.SetField(intField.Id, 101);
target.Save( );
using (new SecurityBypassContext( ))
{
new AccessRuleFactory( ).AddAllowByQuery(Entity.Get <Subject>("core:everyoneRole").AsWritable <Subject>( ), type.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type.Id).ToReport( ));
new AccessRuleFactory( ).AddAllowByQuery(Entity.Get <Subject>("core:everyoneRole").AsWritable <Subject>( ), type2.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type2.Id).ToReport( ));
}
Field lookupField = null;
string identity;
if (identityType == "Name")
{
identity = "\"" + name + "\"";
}
else if (identityType == "Guid")
{
identity = "\"" + target.UpgradeId.ToString() + "\"";
}
else if (identityType.Contains("Null"))
{
identity = "null";
}
else if (identityType == "StringField")
{
identity = "\"StringVal\"";
}
else if (identityType == "IntField")
{
identity = "101";
}
else
{
throw new InvalidOperationException();
}
if (identityType.Contains("StringField"))
{
lookupField = stringField;
}
else if (identityType.Contains("IntField"))
{
lookupField = intField;
}
// Create JSON
string jsonMember = "rel1";
string json = "{\"" + jsonMember + "\":" + identity + "}";
// Create a mapping
var mapping = CreateApiResourceMapping(new EntityRef(type.Id));
var relMapping = CreateApiRelationshipMapping(mapping, new EntityRef(relationship.Id), jsonMember, direction == Direction.Reverse);
relMapping.MappedRelationshipLookupField = lookupField;
relMapping.Save( );
// Fill entity
IEntity entity = RunTest(json, mapping);
IEntityRelationshipCollection <IEntity> value = entity.GetRelationships(relationship.Id, direction);
// Assert mapping
Assert.That(value, Is.Not.Null);
if (identityType.Contains("Null"))
{
Assert.That(value, Has.Count.EqualTo(0));
}
else
{
Assert.That(value, Has.Count.EqualTo(1));
Assert.That(value.First( ).Id, Is.EqualTo(target.Id));
}
}
public void SetRelationship( )
{
var employeeType = Entity.Get <EntityType>("test:employee");
var managerType = Entity.Get <EntityType>("test:manager");
var nameField = Entity.Get <StringField>("core:name");
IEntity emp = new Entity(employeeType);
emp.SetField(nameField, "Test Employee");
IEntity emp2 = new Entity(employeeType);
emp.SetField(nameField, "Test Employee 2");
IEntity mgr = (new Entity(employeeType));
emp.SetField(nameField, "Test Manager");
mgr.As <Resource>( ).IsOfType.Add(managerType);
emp.Save( );
emp2.Save( );
mgr.Save( );
ToDelete.Add(emp.Id);
ToDelete.Add(emp2.Id);
ToDelete.Add(mgr.Id);
var setRel = new SetRelationshipActivity( );
setRel.Save( );
ToDelete.Add(setRel.Id);
var setRelAs = setRel.As <WfActivity>( );
ActivityImplementationBase nextActivity = setRelAs.CreateWindowsActivity( );
var args = new Dictionary <string, object>
{
{
"Origin", emp
},
{
"Relationship", new EntityRef("test:reportsTo").Entity
},
{
"Destination", mgr
},
};
RunActivity(nextActivity, args);
emp = Entity.Get(emp.Id);
IEntityRelationshipCollection <IEntity> rels = emp.GetRelationships("test:reportsTo");
Assert.AreEqual(1, rels.Count( ), "Ensure the manager has been set");
Assert.AreEqual(rels.First( ).Entity.Id, mgr.Id, "Ensure the manager has been set to the correct value");
// clear relationships
args = new Dictionary <string, object>
{
{
"Origin", emp
},
{
"Relationship", new EntityRef("test:reportsTo").Entity
},
{
"Destination", null
},
{
"Replace Existing Destination", true
}
};
RunActivity(nextActivity, args);
emp = Entity.Get(emp.Id);
rels = emp.GetRelationships("test:reportsTo");
Assert.AreEqual(0, rels.Count( ), "Ensure the manager has been cleared");
// set the reverse relationship
args = new Dictionary <string, object>
{
{
"Origin", mgr
},
{
"Relationship", new EntityRef("test:directReports").Entity
},
{
"Destination", emp
},
{
"(Internal) Is this a reverse relationship", true
}
};
RunActivity(nextActivity, args);
mgr = Entity.Get(mgr.Id);
rels = mgr.GetRelationships("test:directReports");
Assert.AreEqual(1, rels.Count( ), "Ensure the employee has been set");
Assert.AreEqual(rels.First( ).Entity.Id, emp.Id, "Ensure the employee has been set to the correct value");
// add a second relationship, clearing the first
args = new Dictionary <string, object>
{
{
"Origin", mgr
},
{
"Relationship", new EntityRef("test:directReports").Entity
},
{
"Destination", emp2
},
{
"(Internal) Is this a reverse relationship", true
},
{
"Replace Existing Destination", true
}
};
RunActivity(nextActivity, args);
mgr = Entity.Get(mgr.Id);
rels = mgr.GetRelationships("test:directReports");
Assert.AreEqual(1, rels.Count( ), "Ensure the new employee has been set and the old cleared");
Assert.AreEqual(rels.First( ).Entity.Id, emp2.Id, "Ensure the manager has been set to the correct value");
// add the first back in
args = new Dictionary <string, object>
{
{
"Origin", mgr
},
{
"Relationship", new EntityRef("test:directReports").Entity
},
{
"Destination", emp
},
{
"(Internal) Is this a reverse relationship", true
},
{
"Replace Existing Destination", false
}
};
RunActivity(nextActivity, args);
mgr = Entity.Get(mgr.Id);
rels = mgr.GetRelationships("test:directReports");
Assert.AreEqual(2, rels.Count( ), "Add a second relationship");
}
public void SetRelationships(long relationshipDefinition, IEntityRelationshipCollection relationships)
{
throw new NotSupportedException( );
}
void IEntityGeneric <long> .SetRelationships(long relationshipDefinition, IEntityRelationshipCollection relationships)
{
throw new NotImplementedException( );
}
public void SetRelationships(string relationshipDefinition, IEntityRelationshipCollection relationships, Direction direction)
{
_entity.SetRelationships(relationshipDefinition, relationships, direction);
}
void IEntityGeneric <string> .SetRelationships(string relationshipDefinition, IEntityRelationshipCollection relationships, Direction direction)
{
throw new NotImplementedException( );
}
public void SetRelationships(string relationshipDefinition, IEntityRelationshipCollection relationships, Direction direction)
{
throw new NotSupportedException( );
}
