public static object GetValuesFromDirectoryProperty(SyncPropertyDefinition property, DirectoryProperty originalValues, List <ValidationError> errors)
{
if (originalValues == null)
{
return(null);
}
IList values = originalValues.GetValues();
if (values == null || values.Count == 0 || values == DirectoryProperty.EmptyValues)
{
return(null);
}
if (property.IsMultivalued)
{
IList values2 = new ArrayList(values.Count);
SyncValueConvertor.ConvertMultipleValues(property, values, ref values2, errors);
MultiValuedPropertyBase multiValuedPropertyBase = ADValueConvertor.CreateGenericMultiValuedProperty(property, property.IsReadOnly, values2, null, null);
multiValuedPropertyBase.IsCompletelyRead = true;
return(multiValuedPropertyBase);
}
ValidationError validationError = null;
object result = SyncValueConvertor.ConvertSingleValue(property, values[0], out validationError);
if (validationError != null)
{
errors.Add(validationError);
}
return(result);
}
private static void AddValueToResultCollection(SyncPropertyDefinition property, ArrayList result, object value)
{
object obj = SyncValueConvertor.ConvertSingleValueForDirectoryProperty(property, value);
if (obj != SyncValueConvertor.IgnoreValue)
{
result.Add(obj);
}
}
private static void ConvertMultipleValues(SyncPropertyDefinition property, IList values, ref IList convertedValues, List <ValidationError> errors)
{
foreach (object value in values)
{
ValidationError validationError = null;
object obj = SyncValueConvertor.ConvertSingleValue(property, value, out validationError);
if (obj != null)
{
convertedValues.Add(obj);
}
if (validationError != null)
{
errors.Add(validationError);
}
}
}
public static IList GetValuesForDirectoryProperty(SyncPropertyDefinition property, object value)
{
ArrayList result = new ArrayList();
if (property.IsMultivalued)
{
MultiValuedPropertyBase multiValuedPropertyBase = (MultiValuedPropertyBase)value;
using (IEnumerator enumerator = ((IEnumerable)multiValuedPropertyBase).GetEnumerator())
{
while (enumerator.MoveNext())
{
object value2 = enumerator.Current;
SyncValueConvertor.AddValueToResultCollection(property, result, value2);
}
return(result);
}
}
SyncValueConvertor.AddValueToResultCollection(property, result, value);
return(result);
}
private static object ConvertSingleValue(SyncPropertyDefinition property, object value, out ValidationError error)
{
error = null;
if (value is XmlValueAssignedPlan)
{
return(((XmlValueAssignedPlan)value).Plan);
}
if (value is XmlValueCompanyVerifiedDomain)
{
return(((XmlValueCompanyVerifiedDomain)value).Domain);
}
if (value is XmlValueDirSyncStatus)
{
return(SyncValueConvertor.ConvertDirSyncStatusToString(((XmlValueDirSyncStatus)value).DirSyncStatus));
}
if (value is AttributeSet)
{
return(SyncValueConvertor.ConvertAttributeSetToString((AttributeSet)value));
}
if (value is XmlValueValidationError)
{
return(((XmlValueValidationError)value).ErrorInfo);
}
if (value is XmlValueLicenseUnitsDetail)
{
return(SyncValueConvertor.ConvertXmlValueLicenseUnitsDetailToString((XmlValueLicenseUnitsDetail)value));
}
if (property == SyncSubscribedPlanSchema.Capability)
{
return(((XmlElement)value).OuterXml);
}
if (property == SyncCompanySchema.CompanyPartnership)
{
return(SyncValueConvertor.ConvertCompanyPartnershipToString((XmlValueCompanyPartnership)value));
}
if (property == SyncRecipientSchema.SipAddresses)
{
string text = (string)value;
if (!string.IsNullOrEmpty(text) && !text.StartsWith(ProxyAddressPrefix.SIP.ToString() + ':', StringComparison.OrdinalIgnoreCase))
{
value = ProxyAddressPrefix.SIP.ToString() + ':' + text;
}
}
else
{
if (property.Type == typeof(RemoteRecipientType))
{
return((RemoteRecipientType)value);
}
if (property.Type == typeof(RecipientTypeDetails))
{
return((RecipientTypeDetails)value);
}
if (property.Type == typeof(MailboxAuditOperations))
{
return((MailboxAuditOperations)value);
}
if (property.Type == typeof(ElcMailboxFlags))
{
return((ElcMailboxFlags)value);
}
if (property.Type == typeof(DateTime?))
{
return((DateTime?)value);
}
if (property.Type == typeof(DateTime))
{
return((DateTime)value);
}
if (property.Type == typeof(EnhancedTimeSpan))
{
return(TimeSpan.FromSeconds((double)((int)value)));
}
if (value is XmlValueRightsManagementTenantConfiguration)
{
return(((XmlValueRightsManagementTenantConfiguration)value).RightsManagementTenantConfiguration);
}
if (value is XmlValueRightsManagementTenantKey)
{
return(((XmlValueRightsManagementTenantKey)value).RightsManagementTenantKey);
}
if (value is XmlValueServiceInfo)
{
return(((XmlValueServiceInfo)value).Info);
}
if (value is int || value is bool)
{
return(value);
}
if (value is DirectoryReferenceAddressList)
{
DirectoryReferenceAddressList directoryReferenceAddressList = (DirectoryReferenceAddressList)value;
if (!directoryReferenceAddressList.TargetDeleted)
{
return(new PropertyReference(directoryReferenceAddressList.Value, directoryReferenceAddressList.TargetClass, directoryReferenceAddressList.TargetDeleted));
}
return(null);
}
else if (value is DirectoryReferenceUserAndServicePrincipal)
{
DirectoryReferenceUserAndServicePrincipal directoryReferenceUserAndServicePrincipal = (DirectoryReferenceUserAndServicePrincipal)value;
return(directoryReferenceUserAndServicePrincipal.Value);
}
}
bool noConversionRequired = property.Type == typeof(byte[]) || property.Type == typeof(string);
return(ADValueConvertor.ConvertFromADAndValidateSingleValue(value, property, noConversionRequired, out error));
}
public static string ConvertCompanyPartnershipToString(XmlValueCompanyPartnership companyPartnership)
{
return(SyncValueConvertor.ConvertToBasicXml <PartnershipValue[]>(companyPartnership.Partnerships));
}
public static string ConvertXmlValueLicenseUnitsDetailToString(XmlValueLicenseUnitsDetail licenseDetail)
{
return(SyncValueConvertor.ConvertToBasicXml <LicenseUnitsDetailValue>(licenseDetail.LicenseUnitsDetail));
}
private static object ConvertSingleValueForDirectoryProperty(SyncPropertyDefinition property, object value)
{
if (object.Equals(property.DefaultValue, value) && !property.PersistDefaultValue)
{
return(SyncValueConvertor.IgnoreValue);
}
if (value == null)
{
return(null);
}
if (typeof(DirectoryPropertyString).IsAssignableFrom(property.ExternalType) || property.ExternalType == typeof(string))
{
return(ADValueConvertor.ConvertValueToString(value, property.FormatProvider));
}
if (typeof(DirectoryPropertyGuid).IsAssignableFrom(property.ExternalType))
{
return(ADValueConvertor.ConvertValueToString(value, property.FormatProvider));
}
if (typeof(DirectoryPropertyBinary).IsAssignableFrom(property.ExternalType))
{
return(ADValueConvertor.ConvertValueToBinary(value, property.FormatProvider));
}
if (typeof(DirectoryPropertyBoolean).IsAssignableFrom(property.ExternalType))
{
return(bool.Parse(ADValueConvertor.ConvertValueToString(value, property.FormatProvider)));
}
if (typeof(DirectoryPropertyInt32).IsAssignableFrom(property.ExternalType))
{
return(int.Parse(ADValueConvertor.ConvertValueToString(value, property.FormatProvider)));
}
if (typeof(DirectoryPropertyDateTime).IsAssignableFrom(property.ExternalType))
{
Type type = value.GetType();
if (type.Equals(typeof(DateTime)))
{
return(((DateTime)value).ToUniversalTime());
}
return(DateTime.Parse(ADValueConvertor.ConvertValueToString(value, property.FormatProvider), property.FormatProvider));
}
else
{
if (typeof(DirectoryPropertyXmlServiceOriginatedResource) == property.ExternalType && value is Capability)
{
Capability capability = (Capability)value;
if (CapabilityHelper.IsAllowedSKUCapability(capability))
{
Guid skucapabilityGuid = CapabilityHelper.GetSKUCapabilityGuid(capability);
if (skucapabilityGuid != Guid.Empty)
{
return(new XmlValueServiceOriginatedResource
{
Resource = new ServiceOriginatedResourceValue
{
ServicePlanId = skucapabilityGuid.ToString("D"),
Capability = capability.ToString()
}
});
}
}
return(SyncValueConvertor.IgnoreValue);
}
if (typeof(DirectoryPropertyXmlDirSyncStatus).IsAssignableFrom(property.ExternalType))
{
string stringValue = (string)value;
return(new XmlValueDirSyncStatus
{
DirSyncStatus = SyncValueConvertor.ConvertStringToDirSyncStatus(stringValue)
});
}
if (typeof(DirectoryPropertyReferenceAddressList).IsAssignableFrom(property.ExternalType) && value is PropertyReference)
{
PropertyReference propertyReference = (PropertyReference)value;
return(new DirectoryReferenceAddressList
{
TargetClass = propertyReference.TargetObjectClass,
Value = propertyReference.TargetId,
TargetDeleted = propertyReference.TargetDeleted
});
}
throw new NotSupportedException("Conversion for external type " + property.ExternalType.Name);
}
}
