public MsPowerShellSyncResults(ObjectClass objectClass, SyncResultsHandler handler)
{
_objectClass = objectClass;
_handler = handler;
}
/// <summary>
/// Implementation of SynOp.Sync
/// </summary>
/// <param name="objClass">Object class</param>
/// <param name="token">Syncronization token</param>
/// <param name="handler">Handler for syncronization results</param>
/// <param name="options">Operation options, can be null</param>
public override void Sync(
ObjectClass objClass,
SyncToken token,
SyncResultsHandler handler,
OperationOptions options)
{
// TODO: implement Sync
base.Sync(objClass, token, handler, options);
}
/// <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)
{
ObjectClassInfo ret = CollectionUtil.GetValue(this.mapOcInfo, oc, null) ?? base.GetObjectClassInfo(oc);
Assertions.NullCheck(ret, "ret");
return ret;
}
public Uid Update(ObjectClass objclass, Uid uid, ICollection<ConnectorAttribute> attrs, OperationOptions options)
{
return ((UpdateApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<UpdateApiOp>()))
.Update(objclass, uid, attrs, options);
}
/// <summary>
/// Implementation of SearchOp.ExecuteQuery
/// </summary>
/// <param name="oclass">Object class</param>
/// <param name="query">Query to execute</param>
/// <param name="handler">Result handler</param>
/// <param name="options">Operation options</param>
public override void ExecuteQuery(
ObjectClass oclass,
string query,
ResultsHandler handler,
OperationOptions options)
{
// TODO: Implement ExecuteQuery
base.ExecuteQuery(oclass, query, handler, options);
}
public SearchResult Search(ObjectClass objectClass, Filter filter, ResultsHandler handler, OperationOptions options)
{
return ((SearchApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<SearchApiOp>())).Search(
objectClass, filter, handler, options);
}
public ISubscription Subscribe(ObjectClass objectClass, SyncToken token, IObserver<SyncDelta> handler, OperationOptions operationOptions)
{
return ((ISyncEventSubscriptionApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<ISyncEventSubscriptionApiOp>()))
.Subscribe(objectClass, token, handler, operationOptions);
}
// =======================================================================
// Clone basically..
// =======================================================================
/// <summary>
/// Takes all the attribute from a <see cref="ConnectorObject" /> and add/overwrite
/// the current attributes.
/// </summary>
public ConnectorObjectBuilder Add(ConnectorObject obj)
{
// simply add all the attributes it will include (Uid, ObjectClass..)
foreach (ConnectorAttribute attr in obj.GetAttributes())
{
AddAttribute(attr);
}
ObjectClass = obj.ObjectClass;
return this;
}
/// <summary>
/// Determines if this object class is a special object class.
/// Special object classes include the predefined ones, such as
/// <see cref="ObjectClass.ACCOUNT"/> and <see cref="ObjectClass.GROUP"/>.
/// </summary>
/// <param name="oclass">the object class to test</param>
/// <returns>true iff the object class is special</returns>
/// <exception cref="NullReferenceException">if the object class parameter is null</exception>
public static bool IsSpecial(ObjectClass oclass)
{
String name = oclass.GetObjectClassValue();
return IsSpecialName(name);
}
/// <summary>
/// Updates an AD object (also called by create after object is created)
/// </summary>
/// <param name="oclass"></param>
/// <param name="directoryEntry"></param>
/// <param name="attributes"></param>
/// <param name="type"></param>
/// <param name="config"></param>
internal void UpdateADObject(ObjectClass oclass,
DirectoryEntry directoryEntry, ICollection<ConnectorAttribute> attributes,
UpdateType type, ActiveDirectoryConfiguration config)
{
if(oclass.Equals(ObjectClass.ACCOUNT))
{
// translate attribute passed in
foreach (ConnectorAttribute attribute in attributes)
{
// encountered problems when processing change password at the same time
// as setting expired. It would be set to expired, but the change would
// clear that. So we must ensure that expired comes last.
if (OperationalAttributes.PASSWORD_EXPIRED_NAME.Equals(attribute.Name))
{
continue;
}
AddConnectorAttributeToADProperties(oclass,
directoryEntry, attribute, type);
// Uncommenting the next line is very helpful in
// finding mysterious errors.
// Trace.TraceInformation("Committing after setting attribute {0} to {1}", attribute.Name, attribute.Value);
// directoryEntry.CommitChanges();
}
directoryEntry.CommitChanges();
// now do the password change. This is handled separately, because
// it might be a user changing his own password, or it might be an
// administrative change.
GuardedString gsNewPassword = ConnectorAttributeUtil.GetPasswordValue(attributes);
if (gsNewPassword != null)
{
GuardedString gsCurrentPassword = ConnectorAttributeUtil.GetCurrentPasswordValue(attributes);
PasswordChangeHandler changeHandler = new PasswordChangeHandler(_configuration);
if (gsCurrentPassword == null)
{
// just a normal password change
changeHandler.changePassword(directoryEntry, gsNewPassword);
}
else
{
changeHandler.changePassword(directoryEntry,
gsCurrentPassword, gsNewPassword);
}
UserAccountControl.Set(directoryEntry.Properties[ActiveDirectoryConnector.ATT_USER_ACOUNT_CONTROL],
UserAccountControl.PASSWD_NOTREQD, false);
directoryEntry.CommitChanges();
}
// see note in loop above for explaination of this
ConnectorAttribute expirePasswordAttribute = ConnectorAttributeUtil.Find(
OperationalAttributes.PASSWORD_EXPIRED_NAME, attributes);
if (expirePasswordAttribute != null)
{
AddConnectorAttributeToADProperties(oclass,
directoryEntry, expirePasswordAttribute, type);
directoryEntry.CommitChanges();
}
/*
UserAccountControl.Set(directoryEntry.Properties[ActiveDirectoryConnector.ATT_USER_ACOUNT_CONTROL],
UserAccountControl.PASSWD_NOTREQD, false);
*/
directoryEntry.CommitChanges();
HandleNameAndContainerChange(type, directoryEntry, attributes, config);
}
else if (oclass.Equals(ActiveDirectoryConnector.groupObjectClass))
{
// translate attribute passed in
foreach (ConnectorAttribute attribute in attributes)
{
// Temporary
// Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
// attribute.Name, attribute.Value));
AddConnectorAttributeToADProperties(oclass,
directoryEntry, attribute, type);
// Uncommenting the next line is very helpful in
// finding mysterious errors.
// directoryEntry.CommitChanges();
}
directoryEntry.CommitChanges();
HandleNameAndContainerChange(type, directoryEntry, attributes, config);
}
else if (oclass.Equals(ActiveDirectoryConnector.ouObjectClass))
{
// translate attribute passed in
foreach (ConnectorAttribute attribute in attributes)
{
// Temporary
// Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
// attribute.Name, attribute.Value));
AddConnectorAttributeToADProperties(oclass,
directoryEntry, attribute, type);
// Uncommenting the next line is very helpful in
// finding mysterious errors.
// directoryEntry.CommitChanges();
}
directoryEntry.CommitChanges();
HandleNameAndContainerChange(type, directoryEntry, attributes, config);
}
else
{
String objectClassName = GetADObjectClass(oclass);
// translate attribute passed in
foreach (ConnectorAttribute attribute in attributes)
{
// Temporary
// Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
// attribute.Name, attribute.Value));
AddConnectorAttributeToADProperties(oclass,
directoryEntry, attribute, type);
// Uncommenting the next line is very helpful in
// finding mysterious errors.
// directoryEntry.CommitChanges();
}
directoryEntry.CommitChanges();
HandleNameAndContainerChange(type, directoryEntry, attributes, config);
}
}
public ConnectorObject(ObjectClass objectClass, ICollection<ConnectorAttribute> attrs)
{
if (objectClass == null)
{
throw new ArgumentException("ObjectClass may not be null");
}
if (attrs == null || attrs.Count == 0)
{
throw new ArgumentException("attrs cannot be empty or null.");
}
_objectClass = objectClass;
_attrs =
CollectionUtil.NewReadOnlyDictionary(attrs,
value => { return value.Name; });
if (!_attrs.ContainsKey(Uid.NAME))
{
const String MSG = "The ConnectorAttribute set must contain a Uid.";
throw new ArgumentException(MSG);
}
if (!_attrs.ContainsKey(Name.NAME))
{
const string MSG = "The ConnectorAttribute set must contain a Name.";
throw new ArgumentException(MSG);
}
}
// entry may be null, needs to be get fresh in that case
internal ConnectorAttribute GetConnectorAttributeFromADEntry(ObjectClass oclass,
String attributeName, DS.SearchResult searchResult, DirectoryEntry entry)
{
Boolean ourEntry = false;
// Boolean translated = false;
if (searchResult == null)
{
throw new ConnectorException(_configuration.ConnectorMessages.Format(
"ex_AttributeNull",
"Could not add connector attribute to <null> search result"));
}
if (entry == null)
{
ourEntry = true;
entry = searchResult.GetDirectoryEntry();
}
try
{
return _customHandlers.GetCaFromDe(oclass,
attributeName, searchResult, entry);
}
finally
{
if (ourEntry && entry != null)
{
entry.Dispose();
}
}
}
/// <summary>
/// Returns the AD ObjectClass associated with a particular
/// Connector ObjectClass
/// </summary>
/// <param name="oclass"></param>
/// <returns></returns>
internal String GetADObjectClass(ObjectClass oclass)
{
if (oclass.Equals(ObjectClass.ACCOUNT))
{
return _configuration.ObjectClass;
}
else if (ActiveDirectoryConnector.groupObjectClass.Equals(oclass))
{
return "Group";
}
else if (ActiveDirectoryConnector.ouObjectClass.Equals(oclass))
{
return "organizationalUnit";
}
else
{
// It's not something I know about, so I'll consult the AD schema.
// if it's there, fine, but if not throw an exception.
//first check to see if we have seen it before.
String objectClassName = oclass.GetObjectClassValue();
if(_knownObjectClasses.Contains(objectClassName))
{
return objectClassName;
}
// if we havent seen it before, consult AD's schema
ActiveDirectorySchema ADSchema = GetADSchema();
ActiveDirectorySchemaClass ADSchemaClass = null;
try
{
ADSchemaClass = ADSchema.FindClass(objectClassName);
_knownObjectClasses.Add(objectClassName);
return objectClassName;
}
catch (ActiveDirectoryObjectNotFoundException exception)
{
String msg = _configuration.ConnectorMessages.Format(
"ex_ObjectClassInvalidForConnector",
"ObjectClass \'{0}\' is not valid for this connector",
objectClassName);
throw new ConnectorException(msg);
}
}
}
internal void AddConnectorAttributeToADProperties(ObjectClass oclass,
DirectoryEntry directoryEntry, ConnectorAttribute attribute,
UpdateType type)
{
// Boolean translated = false;
if (directoryEntry == null)
{
throw new ConnectorException(_configuration.ConnectorMessages.Format(
"ex_CouldNotAddNullAttributeToDe",
"Could not add connector attribute to <null> directory entry"));
}
_customHandlers.UpdateDeFromCa(oclass, type,
directoryEntry, attribute);
}
public ConnectorObject GetObject(ObjectClass objClass, Uid uid, OperationOptions options)
{
return ((GetApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<GetApiOp>()))
.GetObject(objClass, uid, options);
}
/// <summary>
/// Create a QualifiedUid.
/// </summary>
/// <param name="objectClass">The object class. May not be null.</param>
/// <param name="uid">The uid. May not be null.</param>
public QualifiedUid(ObjectClass objectClass,
Uid uid)
{
Assertions.NullCheck(objectClass, "objectClass");
Assertions.NullCheck(uid, "uid");
_objectClass = objectClass;
_uid = uid;
}
public Uid ResolveUsername(ObjectClass objectClass, String username, OperationOptions options)
{
return ((ResolveUsernameApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<ResolveUsernameApiOp>())).ResolveUsername(
objectClass, username, options);
}
public ConnectorAttribute NormalizeAttribute(ObjectClass oclass, ConnectorAttribute attribute)
{
if (attribute.Is("foo"))
{
String val = ConnectorAttributeUtil.GetStringValue(attribute);
return ConnectorAttributeBuilder.Build("foo", val.Trim());
}
else
{
return attribute;
}
}
public ISubscription Subscribe(ObjectClass objectClass, Filter eventFilter, IObserver<ConnectorObject> handler,
OperationOptions operationOptions)
{
return ((IConnectorEventSubscriptionApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<IConnectorEventSubscriptionApiOp>()))
.Subscribe(objectClass, eventFilter, handler, operationOptions);
}
public void TestObjectClass()
{
ObjectClass v1 = new ObjectClass("test");
ObjectClass v2 = (ObjectClass)CloneObject(v1);
Assert.AreEqual(v1, v2);
}
public SyncToken Sync(ObjectClass objectClass, SyncToken token,
SyncResultsHandler handler,
OperationOptions options)
{
return ((SyncApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<SyncApiOp>()))
.Sync(objectClass, token, handler, options);
}
public Uid Authenticate(ObjectClass objectClass, String username, GuardedString password, OperationOptions options)
{
return ((AuthenticationApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<AuthenticationApiOp>())).Authenticate(
objectClass, username, password, options);
}
/// <summary>
/// Implementation of SearchOp.CreateFilterTranslator
/// </summary>
/// <param name="oclass">Object class</param>
/// <param name="options">Operation options</param>
/// <returns>Exchange specific Filter translator</returns>
public override Org.IdentityConnectors.Framework.Common.Objects.Filters.FilterTranslator<string> CreateFilterTranslator(
ObjectClass oclass,
OperationOptions options)
{
// TODO: Implement CreateFilterTranslator
return base.CreateFilterTranslator(oclass, options);
}
public Uid Create(ObjectClass oclass, ICollection<ConnectorAttribute> attrs, OperationOptions options)
{
return ((CreateApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<CreateApiOp>())).Create(oclass, attrs, options);
}
/// <summary>
/// Implementation of SynOp.GetLatestSyncToken
/// </summary>
/// <param name="objectClass">Object class</param>
/// <returns><see cref="SyncToken" /> of the last sync</returns>
public override SyncToken GetLatestSyncToken(ObjectClass objectClass)
{
// TODO: Implement GetLatestSyncToken
return base.GetLatestSyncToken(objectClass);
}
public void Delete(ObjectClass objClass, Uid uid, OperationOptions options)
{
((DeleteApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<DeleteApiOp>()))
.Delete(objClass, uid, options);
}
/// <summary>
/// Implementation of UpdateOp.Update
/// </summary>
/// <param name="type">Update type</param>
/// <param name="oclass">Object class</param>
/// <param name="attributes">Object attributes</param>
/// <param name="options">Operation options</param>
/// <returns><see cref="Uid"/> of the updated object</returns>
public override Uid Update(
UpdateType type,
ObjectClass oclass,
ICollection<ConnectorAttribute> attributes,
OperationOptions options)
{
// TODO: Implement Update
return base.Update(type, oclass, attributes, options);
}
public SyncToken GetLatestSyncToken(ObjectClass objectClass)
{
return ((SyncApiOp)GetOperationCheckSupported(SafeType<APIOperation>.Get<SyncApiOp>()))
.GetLatestSyncToken(objectClass);
}
/// <summary>
/// Implementation of CreateOp.Create
/// </summary>
/// <param name="oclass">Object class</param>(oc
/// <param name="attributes">Object attributes</param>
/// <param name="options">Operation options</param>
/// <returns><see cref="Uid"/> of the created object</returns>
public override Uid Create(
ObjectClass oclass,
ICollection<ConnectorAttribute> attributes,
OperationOptions options)
{
const string METHOD = "Create";
Debug.WriteLine(METHOD + ":entry", ClassName);
// first create the object in AD
Uid uid = base.Create(oclass, attributes, options);
try
{
if (oclass.Is(MailboxName))
{
// enable mailbox for person
Command cmd = ExchangeUtility.GetCommand(CommandInfo.EnableMailbox, attributes, this.configuration);
this.runspace.InvokePipeline(cmd);
}
else if (oclass.Is(MailUserName))
{
// enable mailuser
Command cmd = ExchangeUtility.GetCommand(CommandInfo.EnableMailUser, attributes, this.configuration);
this.runspace.InvokePipeline(cmd);
}
Debug.WriteLine(METHOD + ":exit", ClassName);
}
catch
{
// do the rollback - delete the object by uid
// no need to check the uid is null, ensured by the create contract
this.Delete(oclass, uid, options);
throw;
}
return uid;
}
public ObjectClassInfo GetObjectClassInfo(ExchangeConnector connector, ObjectClass oc)
{
return connector.GetObjectClassInfoGeneric(oc);
}