GetAttributeByName() public method

public GetAttributeByName ( string name ) : ConnectorAttribute
name string
return ConnectorAttribute
示例#1
0
 /// <summary>
 /// Determine if the password is expired for this object.
 /// </summary>
 /// <param name="obj">
 /// <see cref="ConnectorObject" /> that should contain a password expired
 /// attribute.</param>
 /// <returns>
 /// <code>null</code> if the attribute does not exist and the value
 /// of the <see cref="ConnectorAttribute" /> if it does.</returns>
 public static bool? IsPasswordExpired(ConnectorObject obj)
 {
     ConnectorAttribute pwd = obj.GetAttributeByName(OperationalAttributes.PASSWORD_EXPIRED_NAME);
     return (pwd == null) ? null : GetBooleanValue(pwd);
 }
示例#2
0
 /// <summary>
 /// Determine if the <see cref="ConnectorObject" /> is enable.
 /// </summary>
 /// <remarks>
 /// By getting the value
 /// of the <see cref="OperationalAttributes.ENABLE_NAME" />.
 /// </remarks>
 /// <param name="obj">
 /// <see cref="ConnectorObject" /> object to inspect.</param>
 /// <exception cref="IllegalStateException">if the object does not contain attribute in question.</exception>
 /// <exception cref="NullReferenceException">iff the parameter 'obj' is <code>null</code>.</exception>
 /// <returns>
 /// <code>null</code> if the attribute does not exist otherwise to
 /// value of the <see cref="ConnectorAttribute" />.</returns>
 public static bool? IsEnabled(ConnectorObject obj)
 {
     ConnectorAttribute attr = obj.GetAttributeByName(OperationalAttributes.ENABLE_NAME);
     return (attr == null) ? null : GetBooleanValue(attr);
 }
示例#3
0
 /// <summary>
 /// Determine if the <see cref="ConnectorObject" /> is locked out.
 /// </summary>
 /// <remarks>
 /// By getting the
 /// value of the <see cref="OperationalAttributes.LOCK_OUT_NAME" />.
 /// </remarks>
 /// <param name="obj">
 /// <see cref="ConnectorObject" /> object to inspect.</param>
 /// <exception cref="NullReferenceException">iff the parameter 'obj' is <code>null</code>.</exception>
 /// <returns>
 /// <code>null</code> if the attribute does not exist otherwise to
 /// value of the <see cref="ConnectorAttribute" />.</returns>
 public static bool? IsLockedOut(ConnectorObject obj)
 {
     ConnectorAttribute attr = obj.GetAttributeByName(OperationalAttributes.LOCK_OUT_NAME);
     return (attr == null) ? null : GetBooleanValue(attr);
 }
示例#4
0
 /// <summary>
 /// Retrieve the password expiration date from the <see cref="ConnectorObject" />.
 /// </summary>
 /// <param name="obj">
 /// <see cref="ConnectorObject" /> object to inspect.</param>
 /// <exception cref="IllegalStateException">if the object does not contain attribute in question.</exception>
 /// <exception cref="NullReferenceException">iff the parameter 'obj' is <code>null</code>.</exception>
 /// <returns>
 /// <code>null</code> if the <see cref="ConnectorAttribute" /> does not exist
 /// otherwise the value of the <see cref="ConnectorAttribute" />.</returns>
 public static DateTime? GetPasswordExpirationDate(ConnectorObject obj)
 {
     DateTime? ret = null;
     ConnectorAttribute attr = obj.GetAttributeByName(OperationalAttributes.PASSWORD_EXPIRATION_DATE_NAME);
     if (attr != null)
     {
         long? date = GetLongValue(attr);
         if (date != null)
         {
             ret = DateTime.FromFileTimeUtc(date.Value);
         }
     }
     return ret;
 }
示例#5
0
 private static void copyAttribute(ConnectorObjectBuilder builder, ConnectorObject cobject, string src, string dest)
 {
     ConnectorAttribute srcAttr = cobject.GetAttributeByName(src);
     if (srcAttr != null)
     {
         builder.AddAttribute(RenameAttribute(srcAttr, dest));
     }
 }
        private static void VerifyObject(ICollection<ConnectorAttribute> requestedAttributes,
            ConnectorObject returnedObject)
        {
            // verify guid is in the proper format.  This is important for IDM.
            if (returnedObject.ObjectClass.Equals(ObjectClass.ACCOUNT))
            {

                Uid uid = returnedObject.Uid;
                String uidValue = uid.GetUidValue();
                Assert.That(uidValue.StartsWith(("<GUID=")), "GUID for user objects must start with <GUID=");
                Assert.That(uidValue.EndsWith(">"), "GUID for account objects must end with >");
                Assert.That(uidValue.ToLower().Replace("guid", "GUID").Equals(uidValue),
                    "GUID for account objects must have lowercase hex strings");
            }

            // for now, skipping values that are very difficult to
            // determine equality ... or they are not returned like
            // 'userPassword'.
            ICollection<String> skipAttributeNames = new List<String>();
            skipAttributeNames.Add("USERPASSWORD");
            skipAttributeNames.Add(OperationalAttributes.PASSWORD_NAME);
            skipAttributeNames.Add(OperationalAttributes.CURRENT_PASSWORD_NAME);
            skipAttributeNames.Add(Uid.NAME);
            // have to ignore the password expire attribute.  It will not come
            // back EXACTLY the same as it was set.  It seems like may ad rounds
            // off to the nearest second, or minute, or something.
            skipAttributeNames.Add(OperationalAttributes.PASSWORD_EXPIRATION_DATE_NAME);

            ICollection<String> ldapStringAttributes = new List<String>();
            ldapStringAttributes.Add("AD_CONTAINER");
            ldapStringAttributes.Add(Name.NAME);
            ldapStringAttributes.Add(PredefinedAttributes.GROUPS_NAME);
            ldapStringAttributes.Add(ActiveDirectoryConnector.ATT_ACCOUNTS);

            // for each attribute in the connector object ...
            foreach (ConnectorAttribute attribute in requestedAttributes)
            {
                ConnectorAttribute returnedAttribute = returnedObject.GetAttributeByName(
                    attribute.Name);

                if (skipAttributeNames.Contains(attribute.Name.ToUpper()))
                {
                    Trace.TraceWarning("Skipping comparison of attribute {0}",
                        attribute.Name);
                    Trace.TraceWarning("requested values were:");
                    foreach (Object requestedValueObject in attribute.Value)
                    {
                        Trace.TraceWarning(requestedValueObject.ToString());
                    }
                    if (returnedAttribute == null)
                    {
                        Trace.TraceWarning("<null> no {0} attribute was returned",
                            attribute.Name);
                    }
                    else
                    {
                        Trace.TraceWarning("returned values were:");
                        foreach (Object returnedValueObject in returnedAttribute.Value)
                        {
                            Trace.TraceWarning(returnedValueObject.ToString());
                        }
                    }
                    continue;
                }

                Assert.IsNotNull(returnedAttribute);

                // for each value in the attribute ...
                foreach (Object requestedValueObject in attribute.Value)
                {
                    // order of multivalue attributes is not gauranted, so check
                    // all values of the returned object against the value
                    // also attributes like the ldap 'objectclass' might return
                    // more values than I set ... (set User, return user, top, inetorgperson)
                    Boolean foundValue = false;
                    foreach (Object returnedValueObject in returnedAttribute.Value)
                    {
                        Object lhs = requestedValueObject;
                        Object rhs = returnedValueObject;

                        // if its an ldap string, put it in a standard form
                        if (ldapStringAttributes.Contains(attribute.Name.ToUpper()))
                        {
                            Assert.That(requestedValueObject is String);
                            Assert.That(returnedValueObject is String);
                            lhs = ActiveDirectoryUtils.NormalizeLdapString((String)requestedValueObject);
                            rhs = ActiveDirectoryUtils.NormalizeLdapString((String)returnedValueObject);
                            /*
                            // if either of them start with a server name, take it off
                            // it's not important to the comparison
                            string []lhsParts = ((string)lhs).Split('/');
                            Assert.LessOrEqual(lhsParts.Length, 2);
                            lhs = (lhsParts.Length) == 1 ? lhsParts[0] : lhsParts[1];
                            string[] rhsParts = ((string)rhs).Split('/');
                            Assert.LessOrEqual(rhsParts.Length, 2);
                            lhs = (rhsParts.Length) == 1 ? rhsParts[0] : rhsParts[1];
                            */
                        }

                        if (lhs.Equals(rhs))
                        {
                            foundValue = true;
                            break;
                        }
                    }
                    Assert.IsTrue(foundValue,
                        String.Format("Could not find value {0} for attribute named {1}",
                        requestedValueObject, attribute.Name));
                }
            }
        }
示例#7
0
        // 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;
            }
        }
示例#8
0
        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);
            } */
        }