internal static RoutingEntity GetRoutingEntity(IUniversalRoutingEntity ure)
{
if (null == ure)
throw new ArgumentNullException("ure");
RoutingEntity routingEntity = new RoutingEntity();
routingEntity.PolicyType = ure.PolicyType.ToString();
routingEntity.RoutingType = ure.RoutingType;
if (ure.Items != null && ure.Items.Count > 0)
{
routingEntity.Items = new Workshare.PolicyContent.RoutingItem[ure.Items.Count];
int index = 0;
foreach (IRoutingItem item in ure.Items)
{
Workshare.PolicyContent.RoutingItem routingItem = new Workshare.PolicyContent.RoutingItem();
routingItem.Content = item.Content;
if (item.Properties != null && item.Properties.Count > 0)
{
routingItem.Properties = new CustomProperty[item.Properties.Count];
int propIndex = 0;
foreach( string key in item.Properties.Keys)
{
routingItem.Properties[propIndex++] = new CustomProperty(key, item.Properties[key]);
}
}
routingEntity.Items[index++] = routingItem;
}
}
return routingEntity;
}
public UniversalRequestObject()
{
m_Properties = new Dictionary<string, string>();
m_Attachments = new RequestAttachmentCollection();
m_source = new UniversalRoutingEntity();
m_source.RoutingType = RoutingTypes.Source;
m_destination = new UniversalRoutingEntity();
m_destination.RoutingType = RoutingTypes.Destination;
}
/// <summary>
/// Retrieves a RoutingItem of a given type from the RoutingEntity object.
/// </summary>
/// <param name="entity"></param>
/// <param name="type"></param>
/// <returns></returns>
List<RoutingItem> GetRoutingItemOfType(IUniversalRoutingEntity entity, string type)
{
List<RoutingItem> items = new List<RoutingItem>();
foreach (RoutingItem ri in entity.Items)
{
if (ri.Properties.ContainsKey("AddressType"))
if (ri.Properties["AddressType"].Equals(type, StringComparison.InvariantCultureIgnoreCase))
items.Add(ri);
}
return items;
}
/// <summary>
/// Determines whether a matching device type can be found in a pair of universal routing entities
/// </summary>
/// <param name="sourceEntity">Contains the device type routing item to search for</param>
/// <param name="targetEntity">Contains a collection of routing items in which to search for the source routing item</param>
/// <returns>True if a match is found</returns>
public bool IsMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
if ((null == sourceEntity) || (null == targetEntity))
return false;
// Routing types must be the same.
if (0 != string.Compare(sourceEntity.RoutingType, targetEntity.RoutingType, true, CultureInfo.InvariantCulture))
return false;
// The request types have to be the same before any processing
if (sourceEntity.PolicyType != targetEntity.PolicyType)
return false;
//must have RequestChannel property on source
if (!sourceEntity.Properties.ContainsKey(SMTPPropertyKeys.RequestChannel))
return false;
return (0 == string.Compare(sourceEntity.Properties[SMTPPropertyKeys.RequestChannel], RequestChannels.Blackberry, true, CultureInfo.InvariantCulture));
}
public bool IsMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
if ((null == sourceEntity) || (null == targetEntity))
return false;
// Routing types must be the same.
if (0 != string.Compare(sourceEntity.RoutingType, targetEntity.RoutingType, true, CultureInfo.InvariantCulture))
return false;
// The request types have to be the same before any processing
if (sourceEntity.PolicyType != targetEntity.PolicyType)
return false;
//must have RequestChannel property on source
if (!sourceEntity.Properties.ContainsKey(SMTPPropertyKeys.RequestChannel))
{
return false;
}
// FOR OUTLOOK we now have the Internal property set on incoming - so no longer
// need to resolve int/ext using mapi - we use the property!
if ((string.Compare(sourceEntity.Properties[SMTPPropertyKeys.RequestChannel], RequestChannels.Outlook, true, CultureInfo.InvariantCulture) == 0) ||
(string.Compare(sourceEntity.Properties[SMTPPropertyKeys.RequestChannel], RequestChannels.LotusNotes, true, CultureInfo.InvariantCulture) == 0))
{
return PropertyMatch(sourceEntity, targetEntity);
}
m_resolver.SetRequestChannel(sourceEntity.Properties[SMTPPropertyKeys.RequestChannel]);
//compare routing item content
string[] sourceRoutingItemContents = GetRoutingItemContents(sourceEntity);
string[] targetRoutingItemContents = GetRoutingItemContents(targetEntity);
return m_resolver.IsMemberOfGroup(sourceRoutingItemContents, targetRoutingItemContents);
}
private bool PropertyMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
bool bInternal = false;
bool bExternal = false;
bool bInternalMatch = false;
bool bExternalMatch = false;
foreach (IRoutingItem item in sourceEntity.Items)
{
string intern;
if (item.Properties.TryGetValue(SMTPItemPropertyKeys.Internal, out intern))
{
if (intern == true.ToString())
bInternal = true;
if (intern == false.ToString())
bExternal = true;
}
}
foreach (IRoutingItem item in targetEntity.Items)
{
if (item.Content == "Recipients:Internal")
bInternalMatch = true;
if (item.Content == "Recipients:Everyone")
bExternalMatch = true;
}
if (bInternalMatch && bInternal && !bExternal)
return true;
if (bExternalMatch && !bInternal && bExternal)
return true;
if (bInternalMatch && bExternalMatch && bInternal && bExternal)
return true;
return false;
}
/// <summary>
/// Extracts the content property of all routing items in an IUniversalRoutingEntity
/// </summary>
/// <param name="routingEntity">The routing entity to evaluate</param>
/// <returns>The extracted routing item contents</returns>
private string[] GetRoutingItemContents(IUniversalRoutingEntity routingEntity)
{
string[] routingItemContents = new string[routingEntity.Items.Count];
for (int i = 0; i < routingEntity.Items.Count; i++)
{
routingItemContents[i] = routingEntity.Items[i].Content;
}
return routingItemContents;
}
public bool IsNotMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
return !IsMatch(sourceEntity, targetEntity);
}
public bool IsMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
if ((null == sourceEntity) || (null == targetEntity))
{
return false;
}
// Routing types must be the same.
if (0 != string.Compare(sourceEntity.RoutingType, targetEntity.RoutingType, true, CultureInfo.InvariantCulture))
{
return false;
}
// The request types have to be the same before any processing
if (sourceEntity.PolicyType != targetEntity.PolicyType)
{
return false;
}
//we must have some routing items for there to be a match
if (0 == sourceEntity.Items.Count || (0 == targetEntity.Items.Count))
{
return false;
}
//check that the content property of the source routing item matches the content property of one
//of the target routing items
string[] sourceRoutingItemContents = new string[sourceEntity.Items.Count];
for (int i = 0; i < sourceEntity.Items.Count; i++)
{
sourceRoutingItemContents[i] = sourceEntity.Items[i].Content;
// LDAP routing can be used in removeable device policies. In these cases, the current user
// is added as a property in the source entity routing item.
if (string.IsNullOrEmpty(sourceRoutingItemContents[i]))
{
string displayName;
if ((sourceEntity.Items[i].Properties.TryGetValue(SMTPItemPropertyKeys.DisplayName, out displayName)) &&
(m_directoryAnalyzer != null) &&
(m_directoryAnalyzer.Engine != null))
{
// Display name doesn't correspond to LDAP displayname, but to SAM/UID
IAddress[] addresses = m_directoryAnalyzer.Engine.RetrieveMembersByField(FieldType.SAM, displayName, "");
if (addresses.Length == 1)
{
sourceRoutingItemContents[i] = addresses[0].Email;
}
}
}
}
string[] targetRoutingItemContents = new string[targetEntity.Items.Count];
for (int i = 0; i < targetEntity.Items.Count; i++)
{
targetRoutingItemContents[i] = targetEntity.Items[i].Content;
}
return m_directoryAnalyzer.IsMemberOfGroup(sourceRoutingItemContents, targetRoutingItemContents);
}
/// <summary>
/// Determines whether a matching device type can be found in a pair of universal routing entities
/// </summary>
/// <param name="sourceEntity">Contains the device type routing item to search for</param>
/// <param name="targetEntity">Contains a collection of routing items in which to search for the source routing item</param>
/// <returns>True if a match is found</returns>
public bool IsMatch(IUniversalRoutingEntity sourceEntity, IUniversalRoutingEntity targetEntity)
{
if ((null == sourceEntity) || (null == targetEntity))
{
return false;
}
// Routing must be the same.
if (0 != string.Compare(sourceEntity.RoutingType, targetEntity.RoutingType, true, CultureInfo.InvariantCulture))
{
return false;
}
// The request types have to be the same before any processing
if (sourceEntity.PolicyType != targetEntity.PolicyType)
{
return false;
}
//build dictionary keyed on target content types, containing target content values
Dictionary<string, List<string>> targetRoutingItemsDictionary = new Dictionary<string, List<string>>();
foreach(IRoutingItem targetRoutingItem in targetEntity.Items)
{
if (targetRoutingItem.Properties.ContainsKey(RemovableDeviceItemPropertyKeys.ContentType))
{
string key = targetRoutingItem.Properties[RemovableDeviceItemPropertyKeys.ContentType];
if (!targetRoutingItemsDictionary.ContainsKey(key))
{
List<string> routingItems = new List<string>();
routingItems.Add(targetRoutingItem.Content);
targetRoutingItemsDictionary.Add(key, routingItems);
}
else
{
targetRoutingItemsDictionary[key].Add(targetRoutingItem.Content);
}
}
}
//now, check that all target types in the dictionary have a value that matches that of an item in the source
//entity. This doesn't look particularly efficient, but I figure that we're never going to be
//copying to a large number of devices at any one time and so performance won't take a big hit.
int matchingParameters = 0;
foreach (string contentType in targetRoutingItemsDictionary.Keys)
{
foreach (string value in targetRoutingItemsDictionary[contentType])
{
bool foundValueMatchForThisContentType = false;
foreach (IRoutingItem sourceRoutingItem in sourceEntity.Items)
{
if (sourceRoutingItem.Properties.ContainsKey(RemovableDeviceItemPropertyKeys.ContentType))
{
if ((contentType == sourceRoutingItem.Properties[RemovableDeviceItemPropertyKeys.ContentType]) &&
(value == sourceRoutingItem.Content))
{
foundValueMatchForThisContentType = true;
matchingParameters++;
break;
}
}
}
if (foundValueMatchForThisContentType)
{
break;
}
}
}
if (targetRoutingItemsDictionary.Keys.Count == matchingParameters)
{
return true;
}
return false;
}
internal static string FormatRoutingEntity(IUniversalRoutingEntity dest)
{
StringBuilder sb = new StringBuilder();
Dictionary<string, bool> duplicateMap = new Dictionary<string, bool>();
if (dest != null &&
dest.Items != null &&
dest.Items.Count > 0)
{
for (int i = 0; i < dest.Items.Count; ++i)
{
IRoutingItem item = dest.Items[i];
if ( item.Content == null
|| duplicateMap.ContainsKey(item.Content))
continue;
if (i > 0)
sb.Append(';');
sb.Append(FormatRoutingItem(item));
duplicateMap[item.Content] = true;
}
}
else
{
return string.Empty;
}
return sb.ToString();
}
public bool AddressMatch(IFile file, IUniversalRoutingEntity destination, IUniversalRoutingEntity source, string[] addressTypes, string[] content)
{
if (destination == null || source == null || addressTypes == null || content == null)
return false;
foreach (string s in addressTypes)
{
List<RoutingItem> routingItems = null;
if (s.Equals(AddressType.From.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
routingItems = GetRoutingItemOfType(source, s);
}
else
{
routingItems = GetRoutingItemOfType(destination, s);
}
if (routingItems != null)
{
foreach (RoutingItem ri in routingItems)
{
if (ri != null && Match(ri.Content, content))
return true;
}
}
}
return false;
}
