// Note: Will go through ALL class, even built-in ones (modify the code if different behavior
// is needed).
private void ClearSelectedClassAliases()
{
ObjectClasses classes = vault.ClassOperations.GetAllObjectClasses();
foreach (ObjectClass cl in classes)
{
// The corresponding ObjectClassAdmin
ObjectClassAdmin cla = vault.ClassOperations.GetObjectClassAdmin(cl.ID);
string clName = cla.Name.Replace(" ", ""); //String.Empty);
string aliases = cla.SemanticAliases.Value;
// Remove the aliasPrefix if it exists.
string updatedAliases = RemoveAlias(aliases, clPrefix + clName);
if (aliases != updatedAliases)
{
// Need to get the AssociatedPropertyDefs from the underlying ObjectClass (except
// for a few built-in properties), otherwise UpdateObjectClassAdmin() will fail.
CopyPropertiesToObjectClassAdmin(cla, cl);
cla.SemanticAliases.Value = updatedAliases;
vault.ClassOperations.UpdateObjectClassAdmin(cla);
}
}
}
/// <summary>
/// Test Helper : Removes a Class Alias with test assertions.
/// </summary>
public void RemoveClassAlias(int objectClass, bool useShorthand = false)
{
if (useShorthand)
{
this.Settings.UseShorthand = true;
}
// Resolve the ClassAdmin.
ObjectClassAdmin oca = this.V.ClassOperations.GetObjectClassAdmin(objectClass);
// Format the alias to Remove.
string aliasToRemove = this.Settings.FormatAlias(oca);
// Check for the existence of the alias, removing if found.
if (!this.V.AliasExists(MFMetadataStructureItem.MFMetadataStructureItemClass, aliasToRemove))
{
this.Tools.Add.ClassAlias(aliasToRemove, oca);
}
// Verify that the alias exists.
Assert.IsTrue(
this.V.AliasExists(MFMetadataStructureItem.MFMetadataStructureItemClass, aliasToRemove),
"Verifying that alias exists: " + aliasToRemove);
// Remove the Alias.
this.Tools.Remove.ClassAlias(aliasToRemove, oca);
// Verify that the alias does not exist.
Assert.IsFalse(
this.V.AliasExists(MFMetadataStructureItem.MFMetadataStructureItemClass, aliasToRemove),
"Verifying that alias does not exist: " + aliasToRemove);
}
/// <summary>
/// Appends an object alias to the object class.
/// </summary>
/// <param name="id">Class ID</param>
/// <param name="aliases">Aliases to append.</param>
public void ClassAliases(int id, string[] aliases)
{
// Resolve the API Structure Object.
ObjectClassAdmin objectClass = this.Vault.ClassOperations.GetObjectClassAdmin(id);
foreach (string alias in aliases)
ClassAlias(alias, objectClass);
}
private void btnAddToClass_Click(object sender, EventArgs e)
{
// Connect to the vault and continue if successful.
if (!ConnectToSelectedVault())
{
return;
}
ObjectClasses classes = vault.ClassOperations.GetAllObjectClasses();
foreach (ObjectClass cl in classes)
{
if (cl.ObjectType == 0)
{
ObjectClassAdmin cla = vault.ClassOperations.GetObjectClassAdmin(cl.ID);
// Need to get the AssociatedPropertyDefs from the underlying ObjectClass (except
// for a few built-in properties), otherwise UpdateObjectClassAdmin() will fail.
CopyPropertiesToObjectClassAdmin(cla, cl);
AssociatedPropertyDef apd = new AssociatedPropertyDef();
apd.PropertyDef = ((PropertyComboBoxItem)propertyComboBox.SelectedItem).propID;
cla.AssociatedPropertyDefs.Add(-1, apd);
vault.ClassOperations.UpdateObjectClassAdmin(cla);
}
}
MessageBox.Show("Done");
}
/// <summary>
/// Clears the aliases on the <see cref="ObjectClass"/>with the provided id.
/// </summary>
/// <param name="classAdmin">Pre-resolved <see cref="ObjectClass"/></param>
public void ClassAlias(ObjectClassAdmin classAdmin)
{
// Clear the aliases.
classAdmin.SemanticAliases.Value = string.Empty;
// Save changes.
this.Vault.ClassOperations.UpdateObjectClassAdmin( classAdmin );
}
/// <summary>
/// Removes a alias from a <see cref="ObjectClass"/>.
/// </summary>
/// <param name="alias">Alias to remove.</param>
/// <param name="objClass">Pre-resolved Object Class</param>
public void ClassAlias(string alias, ObjectClassAdmin objClass)
{
// Search and Destroy.
if (removeAlias(objClass.SemanticAliases, alias))
{
// Save changes.
this.Vault.ClassOperations.UpdateObjectClassAdmin( objClass );
}
}
public ObjectClassAdmin AddObjectClassAdmin(ObjectClassAdmin objectClassAdmin)
{
vault.MetricGatherer.MethodCalled();
// TODO: make functionality comparable to API
vault.classAdmins.Add(objectClassAdmin);
vault.classes.Add(new TestObjectClass(objectClassAdmin));
return(objectClassAdmin);
}
/// <summary>
/// Test Helper : Clears a Class Alias with test assertions.
/// </summary>
public void ClearClassAlias(int objectClass)
{
// Resolve the ClassAdmin.
ObjectClassAdmin oca = this.V.ClassOperations.GetObjectClassAdmin(objectClass);
// Clear the Alias.
this.Tools.Clear.ClassAlias(oca);
// Verify that no aliases exist.
Assert.IsTrue(
string.IsNullOrWhiteSpace(oca.SemanticAliases.Value),
"Verifying that no aliases exist: ");
}
public int GetObjectClassIDByAlias(string alias)
{
vault.MetricGatherer.MethodCalled();
try
{
ObjectClassAdmin classAdmin =
vault.classAdmins.SingleOrDefault(classy => classy.SemanticAliases.Value.Split(';').Contains(alias));
return(classAdmin == null ? -1 : classAdmin.ID);
}
catch
{
return(-1);
}
}
/// <summary>
/// Appends the alias to the object class.
/// </summary>
/// <param name="oca"><see cref="ObjectClass"/></param>
/// <param name="alias">Alias to append.</param>
public void ClassAlias(string alias, ObjectClassAdmin oca)
{
// Add the alias only if it does not already exist.
if (!this.Vault.AliasExists(MFMetadataStructureItem.MFMetadataStructureItemClass, alias))
{
// Append a delimiter if needed.
if (oca.SemanticAliases.Value.Length > 1 && !oca.SemanticAliases.Value.Trim().EndsWith(";"))
oca.SemanticAliases.Value += ';';
// Append the alias.
oca.SemanticAliases.Value += alias;
// Persist the change.
this.Vault.ClassOperations.UpdateObjectClassAdmin(oca);
}
}
private void UpdateClassAdmin(ObjectClassAdmin classAdmin)
{
var @class = Vault.ClassOperations.GetObjectClass(classAdmin.ID);
classAdmin.AssociatedPropertyDefs = new AssociatedPropertyDefs();
foreach (var apd in @class.AssociatedPropertyDefs.Cast <AssociatedPropertyDef>())
{
if (_ignorePropDefs.Contains(apd.PropertyDef))
{
continue;
}
classAdmin.AssociatedPropertyDefs.Add(-1, apd);
}
Vault.ClassOperations.UpdateObjectClassAdmin(classAdmin);
}
public TestObjectClass(ObjectClassAdmin oca)
{
xObjectClassAdmin oClass = new xObjectClassAdmin(oca);
AssociatedPropertyDefs = new AssociatedPropertyDefs();
foreach (xAssociatedPropertyDef associatedPropertyDef in oClass.AssociatedPropertyDefs)
{
AssociatedPropertyDefs.Add(-1, new TestAssociatedPropertyDef(associatedPropertyDef));
}
AutomaticPermissionsForObjects = new TestAutomaticPermissions(oClass.AutomaticPermissionsForObjects);
ForceWorkflow = oClass.ForceWorkflow;
ID = oClass.ID;
Name = oClass.Name;
NamePropertyDef = oClass.NamePropertyDef;
ObjectType = oClass.ObjectType;
Workflow = oClass.Workflow;
}
// Note: Will go through ALL classes, even built-in ones (modify the code if different behavior
// is needed).
private void ClearAllClassAliases()
{
ObjectClasses classes = vault.ClassOperations.GetAllObjectClasses();
foreach (ObjectClass cl in classes)
{
// The corresponding ObjectClassAdmin
ObjectClassAdmin cla = vault.ClassOperations.GetObjectClassAdmin(cl.ID);
// Need to get the AssociatedPropertyDefs from the underlying ObjectClass (except
// for a few built-in properties), otherwise UpdateObjectClassAdmin() will fail.
CopyPropertiesToObjectClassAdmin(cla, cl);
cla.SemanticAliases.Value = "";
vault.ClassOperations.UpdateObjectClassAdmin(cla);
}
}
private void CopyPropertiesToObjectClassAdmin(ObjectClassAdmin oca, ObjectClass oc)
{
oca.AssociatedPropertyDefs = new AssociatedPropertyDefs();
// Skip certain built-in properties present in the original ObjectClass object, these cause problems with
// UpdateObjectClassAdmin() later.
foreach (AssociatedPropertyDef def in oc.AssociatedPropertyDefs)
{
if ((def.PropertyDef >= 20 && def.PropertyDef <= 25) ||
(def.PropertyDef >= 30 && def.PropertyDef <= 32) ||
def.PropertyDef == 89 ||
def.PropertyDef == 101)
{
continue;
}
else
{
//Console.WriteLine("Adding: " + oc.Name + ", " + def.PropertyDef);
oca.AssociatedPropertyDefs.Add(-1, def);
}
}
}
public void KnownObjectClassReturnsCorrectData()
{
// Details about the class.
int classId = 1234;
string[] aliases = new []
{
"alias1",
"alias2"
};
// Mock the class.
var mock = this.GetVaultClassOperationsMock();
mock
.Setup(m => m.GetObjectClassAdmin(classId))
.Returns((int id) =>
{
var objectClassAdmin = new ObjectClassAdmin()
{
ID = classId,
Name = "hello world",
SemanticAliases = new SemanticAliases()
{
Value = string.Join(";", aliases)
}
};
return(objectClassAdmin);
});
// Run the method and check the output.
Assert.IsTrue(mock.Object.TryGetObjectClassAliases(classId, out string[] output));
Assert.AreEqual(aliases.Length, output.Length);
foreach (var alias in aliases)
{
Assert.IsTrue(output.Contains(alias));
}
}
private void CreateClassAliases()
{
ObjectClasses classes = vault.ClassOperations.GetAllObjectClasses();
foreach (ObjectClass cl in classes)
{
// Skip Assignment and Report classes (comment this line out if you want to include them).
if (cl.ID < 0)
{
continue;
}
// The corresponding ObjectClassAdmin
ObjectClassAdmin cla = vault.ClassOperations.GetObjectClassAdmin(cl.ID);
string clName = cla.Name.Replace(" ", ""); //String.Empty);
string aliases = cla.SemanticAliases.Value;
Alias newAlias = new Alias(Alias.ELEMENT_TYPE_CL, clName, clPrefix);
// Add the new alias if not already there.
string updatedAliases = AddAlias(aliases, newAlias.ElementAlias);
if (aliases != updatedAliases)
{
// Need to get the AssociatedPropertyDefs from the underlying ObjectClass (except
// for a few built-in properties), otherwise UpdateObjectClassAdmin() will fail.
CopyPropertiesToObjectClassAdmin(cla, cl);
cla.SemanticAliases.Value = updatedAliases;
vault.ClassOperations.UpdateObjectClassAdmin(cla);
}
// We will need the alias object later when generating the "Aliases.cs" and "Config.cs" files.
clAliases.Add(newAlias);
}
}
public void UpdateObjectClassAdmin(ObjectClassAdmin objectClass)
{
vault.MetricGatherer.MethodCalled();
throw new NotImplementedException();
}
/// <summary>
/// Clears the aliases on the <see cref="ObjectClass"/>with the provided id.
/// </summary>
/// <param name="id"><see cref="ObjectClass"/> ID</param>
public void ClassAlias(int id)
{
// Get the Class Admin with the provided id.
ObjectClassAdmin classAdmin = this.Vault.ClassOperations.GetObjectClassAdmin( id );
ClassAlias(classAdmin);
}
public void Test_002_ClassFormating(string expectedAlias, int id, bool useShorthand = false)
{
ObjectClassAdmin objClass = this.V.ClassOperations.GetObjectClassAdmin(id);
FormatAlias(objClass, expectedAlias, useShorthand);
}
/// <summary>
/// Removes a alias from a <see cref="ObjectClass"/>.
/// </summary>
/// <param name="id">Class ID</param>
/// <param name="alias">Alias to remove.</param>
public void ClassAlias(int id, string alias)
{
// Resolve the ObjectClass Admin.
ObjectClassAdmin objClass = this.Vault.ClassById(id );
ClassAlias(alias, objClass);
}
