public void Update(UpdateOpContext context)
{
ExchangeConnector exconn = (ExchangeConnector)context.Connector;
ActiveDirectoryConnector adconn = exconn.ActiveDirectoryConnector;
adconn.Update(context.UpdateType, context.ObjectClass, context.Uid, context.Attributes, context.Options);
}
public ICollection<ConnectorAttribute> DetermineNewAttributeValues(UpdateOpContext context, string query)
{
ConnectorObject originalObject;
if (context.UpdateType != UpdateType.REPLACE)
{
originalObject = GetCurrentObject(context, query);
}
else
{
originalObject = null; // not necessary here
}
return DetermineNewAttributeValues(context, originalObject);
}
public void Update(UpdateOpContext context)
{
ExchangeConnector exconn = (ExchangeConnector)context.Connector;
ICollection<ConnectorAttribute> attributesForReplace = _helper.DetermineNewAttributeValues(context, context.Uid.GetUidValue()); // query string is the UID value!
Command cmdSet = ExchangeUtility.GetCommand(
new PSExchangeConnector.CommandInfo(GetSetCommandName()),
attributesForReplace, context.Uid, exconn.Configuration);
try {
_helper.InvokePipeline(exconn, cmdSet);
} catch (ObjectNotFoundException e) {
throw new UnknownUidException("Object with UID " + context.Uid.GetUidValue() + " couldn't be modified", e);
}
}
// creates a collection of attributes that correspond to the original ones, but resolves ADD/DELETE using existing values of psuser
public ICollection<ConnectorAttribute> DetermineNewAttributeValues(UpdateOpContext context, ConnectorObject originalObject)
{
if (context.UpdateType == UpdateType.REPLACE)
{
// TODO check multivaluedness and updateability (as below)
return new List<ConnectorAttribute>(context.Attributes);
}
else
{
Boolean add;
if (context.UpdateType == UpdateType.ADD)
{
add = true;
}
else if (context.UpdateType == UpdateType.DELETE)
{
add = false;
}
else
{
throw new ArgumentException("Unsupported update type: " + context.UpdateType);
}
Schema schema = null;
ICollection<ConnectorAttribute> rv = new List<ConnectorAttribute>(context.Attributes.Count);
foreach (ConnectorAttribute attribute in context.Attributes)
{
ConnectorAttribute originalAttribute = originalObject.GetAttributeByName(attribute.Name);
IList<object> newValues = originalAttribute != null && originalAttribute.Value != null ? new List<object>(originalAttribute.Value) : new List<object>();
Boolean changed = false;
if (attribute.Value != null)
{
foreach (object item in attribute.Value)
{
if (add)
{
if (newValues.Contains(item))
{
LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Trying to add value from " + attribute.Name + " that is already there: " + item);
}
else
{
newValues.Add(item);
changed = true;
}
}
else
{
if (!newValues.Contains(item))
{
LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Trying to remove value from " + attribute.Name + " that is not there: " + item);
}
else
{
newValues.Remove(item);
changed = true;
}
}
}
}
if (changed)
{
ConnectorAttributeBuilder b = new ConnectorAttributeBuilder();
b.Name = attribute.Name;
b.AddValue(newValues);
ConnectorAttribute modified = b.Build();
if (schema == null)
{
ExchangeConnector connector = (ExchangeConnector)context.Connector;
schema = connector.Schema();
}
ObjectClassInfo oci = schema.FindObjectClassInfo(context.ObjectClass.Type);
if (oci == null)
{
throw new InvalidOperationException("No object class info for " + context.ObjectClass.Type + " in the schema");
}
var cai = ConnectorAttributeInfoUtil.Find(attribute.Name, oci.ConnectorAttributeInfos);
if (cai == null)
{
throw new InvalidOperationException("No connector attribute info for " + context.ObjectClass.Type + " in the schema");
}
if (!cai.IsUpdateable)
{
throw new ConnectorSecurityException("Attempt to update a non-updateable attribute (" + attribute.Name + "): " +
CollectionUtil.Dump(newValues));
}
if (newValues.Count > 1 && !cai.IsMultiValued)
{
throw new InvalidAttributeValueException("More than one value in a single-valued attribute (" + attribute.Name + "): " +
CollectionUtil.Dump(newValues));
}
rv.Add(modified);
}
}
return rv;
}
}
internal ConnectorObject GetCurrentObject(UpdateOpContext context, string query)
{
ConnectorObject currentObject = null;
LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Fetching object using query {0}", query);
ResultsHandler handler = new ResultsHandler()
{
Handle = cobject =>
{
//LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Object-to-be-modified: {0}", CommonUtils.DumpConnectorAttributes(cobject.GetAttributes()));
if (currentObject != null)
{
throw new InvalidOperationException("More than one object complying with " + query + " was found");
}
currentObject = cobject;
return true;
}
};
((ExchangeConnector) context.Connector).ExecuteQuery(context.ObjectClass, query, handler, null);
if (currentObject == null)
{
throw new ObjectNotFoundException("Object with UID " + context.Uid.GetUidValue() + " was not found");
}
return currentObject;
}
public string DetermineOrigAndNewAttributeValue(UpdateOpContext context, ConnectorObject origObject, ICollection<ConnectorAttribute> attributesForReplace, string attributeName, out string origAttributeValue)
{
ConnectorAttribute originalAttribute = origObject.GetAttributeByName(attributeName);
if (originalAttribute != null)
{
origAttributeValue = ConnectorAttributeUtil.GetAsStringValue(originalAttribute);
}
else
{
origAttributeValue = null;
}
ConnectorAttribute newAttribute = ConnectorAttributeUtil.Find(attributeName, attributesForReplace);
if (newAttribute != null)
{
return ConnectorAttributeUtil.GetAsStringValue(newAttribute);
}
else
{
return origAttributeValue;
}
/*
string deltaValue = ConnectorAttributeUtil.GetAsStringValue(attribute);
if (attribute == null) {
return origAttributeValue;
}
switch (context.UpdateType) {
case UpdateType.ADD:
if (deltaValue == null) {
return origAttributeValue;
}
if (origAttributeValue != null && !origAttributeValue.Equals(deltaValue)) {
throw new ArgumentException("Multiple values for " + attribute.Name + " are not allowed: existing = " + origAttributeValue + ", one being added = " + deltaValue);
} else {
return deltaValue;
}
case UpdateType.REPLACE:
return deltaValue;
case UpdateType.DELETE:
if (deltaValue == null) {
return origAttributeValue;
}
if (origAttributeValue == null || !origAttributeValue.Equals(deltaValue)) {
LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Trying to remove value from " + attribute.Name + " that is not there: " + deltaValue);
return origAttributeValue;
} else {
return null;
}
default:
throw new ArgumentException("Invalid update type: " + context.UpdateType);
} */
}