public void TestSchema()
{
OperationOptionInfo opInfo =
new OperationOptionInfo("name", typeof(int?));
ObjectClassInfoBuilder bld = new ObjectClassInfoBuilder();
bld.ObjectType = ObjectClass.ACCOUNT_NAME;
ObjectClassInfo info = bld.Build();
ICollection <ObjectClassInfo> temp = CollectionUtil.NewSet(info);
IDictionary <SafeType <APIOperation>, ICollection <ObjectClassInfo> > map =
new Dictionary <SafeType <APIOperation>, ICollection <ObjectClassInfo> >();
map[SafeType <APIOperation> .Get <CreateApiOp>()] = temp;
ICollection <OperationOptionInfo> temp2 = CollectionUtil.NewSet(opInfo);
IDictionary <SafeType <APIOperation>, ICollection <OperationOptionInfo> > map2 =
new Dictionary <SafeType <APIOperation>, ICollection <OperationOptionInfo> >();
map2[SafeType <APIOperation> .Get <CreateApiOp>()] = temp2;
Schema v1 = new Schema(CollectionUtil.NewSet(info),
CollectionUtil.NewSet(opInfo),
map,
map2);
Schema v2 = (Schema)CloneObject(v1);
Assert.AreEqual(v1, v2);
Assert.AreEqual(info, v2.ObjectClassInfo.First());
Assert.AreEqual(1, v2.SupportedObjectClassesByOperation.Count);
Assert.AreEqual(1, v2.SupportedOptionsByOperation.Count);
Assert.AreEqual(1, v2.OperationOptionInfo.Count);
}
private static void Merge(IDictionary <ObjectClass, ObjectClassInfo> target, IDictionary <ObjectClass, ObjectClassInfo> source)
{
foreach (ObjectClass oc in source.Keys)
{
ObjectClassInfo sourceOCI = source[oc];
if (!target.ContainsKey(oc))
{
ObjectClassInfoBuilder builder = new ObjectClassInfoBuilder();
builder.ObjectType = sourceOCI.ObjectType;
builder.IsContainer = sourceOCI.IsContainer;
builder.AddAllAttributeInfo(sourceOCI.ConnectorAttributeInfos);
ObjectClassInfo targetOCI = builder.Build();
LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Adding object class info {0}", targetOCI.ObjectType);
target.Add(oc, targetOCI);
}
else
{
ObjectClassInfo targetOCI = target[oc];
if (!targetOCI.ObjectType.Equals(sourceOCI.ObjectType))
{
throw new ArgumentException("Incompatible ObjectType for object class " + oc);
}
if (targetOCI.IsContainer != sourceOCI.IsContainer)
{
throw new ArgumentException("Incompatible Container flag for object class " + oc);
}
ObjectClassInfoBuilder builder = new ObjectClassInfoBuilder();
builder.ObjectType = targetOCI.ObjectType;
builder.IsContainer = targetOCI.IsContainer;
builder.AddAllAttributeInfo(targetOCI.ConnectorAttributeInfos);
foreach (ConnectorAttributeInfo info in sourceOCI.ConnectorAttributeInfos)
{
if (info.Is(Name.NAME))
{
// The __NAME__ attribute is a special one and has to be provided on each object class.
// So, even if we just want to extend an object class with a few attributes, we have to provide
// artificial __NAME__ attribute there. When merging, we simply skip it.
continue;
}
foreach (ConnectorAttributeInfo existingInfo in targetOCI.ConnectorAttributeInfos)
{
if (existingInfo.Is(info.Name))
{
throw new ArgumentException("Attempted to redefine attribute " + info.Name);
}
}
LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Adding connector attribute info {0}:{1}", info.Name, info.ValueType);
builder.AddAttributeInfo(info);
}
ObjectClassInfo targetRebuilt = builder.Build();
LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Replacing object class info {0}", targetOCI.ObjectType);
target.Remove(oc);
target.Add(oc, targetRebuilt);
}
}
}
public virtual Schema Schema()
{
if (null == _schema)
{
var builder = new SchemaBuilder(SafeType <Connector> .Get(this));
// Account
var accountInfoBuilder = new ObjectClassInfoBuilder();
accountInfoBuilder.AddAttributeInfo(Name.INFO);
accountInfoBuilder.AddAttributeInfo(OperationalAttributeInfos.PASSWORD);
accountInfoBuilder.AddAttributeInfo(PredefinedAttributeInfos.GROUPS);
accountInfoBuilder.AddAttributeInfo(ConnectorAttributeInfoBuilder.Build("firstName"));
accountInfoBuilder.AddAttributeInfo(
ConnectorAttributeInfoBuilder.Define("lastName").SetRequired(true).Build());
builder.DefineObjectClass(accountInfoBuilder.Build());
// Group
var groupInfoBuilder = new ObjectClassInfoBuilder();
groupInfoBuilder.ObjectType = ObjectClass.GROUP_NAME;
groupInfoBuilder.AddAttributeInfo(Name.INFO);
groupInfoBuilder.AddAttributeInfo(PredefinedAttributeInfos.DESCRIPTION);
groupInfoBuilder.AddAttributeInfo(
ConnectorAttributeInfoBuilder.Define("members")
.SetCreatable(false)
.SetUpdateable(false)
.SetMultiValued(true)
.Build());
// Only the CRUD operations
builder.DefineObjectClass(groupInfoBuilder.Build(), SafeType <SPIOperation> .Get <CreateOp>(),
SafeType <SPIOperation> .ForRawType(typeof(SearchOp <>)), SafeType <SPIOperation> .Get <UpdateOp>(),
SafeType <SPIOperation> .Get <DeleteOp>());
// Operation Options
builder.DefineOperationOption(OperationOptionInfoBuilder.BuildAttributesToGet(),
SafeType <SPIOperation> .ForRawType(typeof(SearchOp <>)));
// Support paged Search
builder.DefineOperationOption(OperationOptionInfoBuilder.BuildPageSize(),
SafeType <SPIOperation> .ForRawType(typeof(SearchOp <>)));
builder.DefineOperationOption(OperationOptionInfoBuilder.BuildPagedResultsCookie(),
SafeType <SPIOperation> .ForRawType(typeof(SearchOp <>)));
// Support to execute operation with provided credentials
builder.DefineOperationOption(OperationOptionInfoBuilder.BuildRunAsUser());
builder.DefineOperationOption(OperationOptionInfoBuilder.BuildRunWithPassword());
_schema = builder.Build();
}
return(_schema);
}
public Schema Schema()
{
SchemaBuilder builder = new SchemaBuilder(SafeType <Connector> .Get <TstConnector>());
for (int i = 0; i < 2; i++)
{
ObjectClassInfoBuilder classBuilder = new ObjectClassInfoBuilder();
classBuilder.ObjectType = ("class" + i);
for (int j = 0; j < 200; j++)
{
classBuilder.AddAttributeInfo(ConnectorAttributeInfoBuilder.Build("attributename" + j, typeof(String)));
}
builder.DefineObjectClass(classBuilder.Build());
}
return(builder.Build());
}
/// <summary>
/// Gets the object class info for specified object class, used for schema building
/// </summary>
/// <param name="oc">ObjectClass to get info for</param>
/// <returns>ObjectClass' ObjectClassInfo</returns>
protected override ObjectClassInfo GetObjectClassInfo(ObjectClass oc)
{
// get the object class from base
ObjectClassInfo oinfo = base.GetObjectClassInfo(oc);
// add additional attributes for ACCOUNT
if (oc.Is(ObjectClass.ACCOUNT_NAME))
{
var classInfoBuilder = new ObjectClassInfoBuilder {
IsContainer = oinfo.IsContainer, ObjectType = oinfo.ObjectType
};
classInfoBuilder.AddAllAttributeInfo(oinfo.ConnectorAttributeInfos);
classInfoBuilder.AddAttributeInfo(AttInfoDatabase);
classInfoBuilder.AddAttributeInfo(AttInfoRecipientType);
classInfoBuilder.AddAttributeInfo(AttInfoExternalMail);
oinfo = classInfoBuilder.Build();
}
// return
return(oinfo);
}
public void TestObjectClassInfo()
{
ConnectorAttributeInfoBuilder builder = new ConnectorAttributeInfoBuilder();
builder.Name = ("foo");
builder.ValueType = (typeof(String));
builder.Required = (true);
builder.Readable = (true);
builder.Updateable = (true);
builder.MultiValued = (true);
ObjectClassInfoBuilder obld = new ObjectClassInfoBuilder();
obld.ObjectType = ObjectClass.ACCOUNT_NAME;
obld.IsContainer = true;
obld.AddAttributeInfo(builder.Build());
ObjectClassInfo v1 = obld.Build();
ObjectClassInfo v2 = (ObjectClassInfo)CloneObject(v1);
Assert.AreEqual(v1, v2);
Assert.IsTrue(v2.IsContainer);
}
