internal static void AddFileToUro(IUniversalRequestObject uro, TempFile tempFile)
{
RequestAttachment requestAttachment = new RequestAttachment();
requestAttachment.FileName = tempFile.FullPath;
requestAttachment.Name = Path.GetFileName(tempFile.FullPath);
requestAttachment.File = new Workshare.FCS.Lite.Interface.File(tempFile.FullPath, Path.GetFileNameWithoutExtension(tempFile.FullPath));
requestAttachment.ContentType = RequestObjectContentType.DOC;
uro.Attachments.Add(requestAttachment);
}
static public void CopyProperties(IUniversalRequestObject sourceUro, IUniversalRequestObject targetUro)
{
if ((null == sourceUro) || (null == targetUro))
return;
foreach (KeyValuePair<string, string> propertyPair in sourceUro.Properties)
{
targetUro.Properties[propertyPair.Key] = propertyPair.Value;
}
}
private void ProcessSender(IUniversalRequestObject uro)
{
string senderAddress = m_emailProxy.Sender.EmailAddress;
string senderName = m_emailProxy.Sender.Name;
IRoutingItem routingItem = new RoutingItem(senderAddress);
routingItem.Properties[SMTPItemPropertyKeys.DisplayName] = senderName;
routingItem.Properties[SMTPItemPropertyKeys.AddressType] = AddressType.From;
routingItem.Properties[SMTPItemPropertyKeys.Internal] = m_emailProxy.Sender.Internal.ToString();
uro.Source.Items.Add(routingItem);
}
static public string BuildUroMessage(string s, IUniversalRequestObject uro)
{
StringBuilder sb = new StringBuilder(s);
sb.AppendFormat("{0}RequestType {1}", Environment.NewLine, uro.PolicyType.ToString());
sb.AppendFormat("{0}DateTime ", Environment.NewLine, uro.DataTimeStamp.ToString(CultureInfo.InvariantCulture));
if (uro.Source != null && uro.Source.Items.Count > 0)
{
sb.AppendFormat("{0}Routing Source Request Type {1}", Environment.NewLine, uro.Source.PolicyType);
sb.AppendFormat("{0}Routing Source Routing Type {1}", Environment.NewLine, uro.Source.RoutingType);
foreach (IRoutingItem routingItem in uro.Source.Items)
{
sb.AppendFormat("{0}Routing Source {1}", Environment.NewLine, routingItem.Content);
foreach (KeyValuePair<string, string> kvp in routingItem.Properties)
{
sb.AppendFormat("{0} Routing Source Property {1} = {2}", Environment.NewLine, kvp.Key, kvp.Value);
}
}
}
if (uro.Destination != null && uro.Destination.Items.Count > 0)
{
sb.AppendFormat("{0}Routing Destination Request Type {1}", Environment.NewLine, uro.Destination.PolicyType);
sb.AppendFormat("{0}Routing Destination Routing Type {1}", Environment.NewLine, uro.Destination.RoutingType);
foreach (IRoutingItem routingItem in uro.Destination.Items)
{
sb.AppendFormat("{0}Routing Destination {1}", Environment.NewLine, routingItem.Content);
foreach (KeyValuePair<string, string> kvp in routingItem.Properties)
{
sb.AppendFormat("{0} Routing Destination Property {1} = {2}", Environment.NewLine, kvp.Key, kvp.Value);
}
}
}
foreach (KeyValuePair<string, string> kvp in uro.Properties)
{
if (kvp.Key == MailMessagePropertyKeys.Body || kvp.Key == MailMessagePropertyKeys.FormattedBody || kvp.Key == MailMessagePropertyKeys.MimeContent)
continue;
sb.AppendFormat("{0}{1} : {2}", Environment.NewLine, kvp.Key, kvp.Value);
}
if (uro.Attachments != null)
{
sb.AppendFormat("{0} {1} attachments.", Environment.NewLine, uro.Attachments.Count.ToString(CultureInfo.InvariantCulture));
foreach (RequestAttachment rqa in uro.Attachments)
{
sb.AppendFormat("{0}{1}", Environment.NewLine, rqa.Name);
}
}
return sb.ToString();
}
private Stream GetMimeStream(IUniversalRequestObject uro)
{
UroToMime uroToMime = new UroToMime(uro);
using (MimeProxy mimeProxy = uroToMime.Convert())
{
if (null == mimeProxy)
return null;
return new MemoryStream(mimeProxy.MimeContentBytes());
}
}
public static Request GetRequest(IUniversalRequestObject uroIn)
{
if (null == uroIn)
throw new ArgumentNullException("uroIn");
Request requestOut = new Request();
requestOut.DateTime = uroIn.DataTimeStamp;
requestOut.Source = RoutingEntityAdaptor.GetRoutingEntity(uroIn.Source);
requestOut.Destination = RoutingEntityAdaptor.GetRoutingEntity(uroIn.Destination);
requestOut.PolicyType = uroIn.PolicyType.ToString();
requestOut.Properties = new CustomProperty[0];
if ( uroIn.Properties != null && uroIn.Properties.Count > 0)
{
List<CustomProperty> props = new List<CustomProperty>();
foreach (KeyValuePair<string, string> pair in uroIn.Properties)
{
props.Add(new CustomProperty(pair.Key, pair.Value));
}
requestOut.Properties = props.ToArray();
}
requestOut.Attachments = new Attachment[0];
if ( uroIn.Attachments != null && uroIn.Attachments.Count > 0)
{
bool returnFile = uroIn.Properties.ContainsKey(RequestAdaptor.PassContentAsFileProperty);
List<Attachment> attachments = new List<Attachment>();
foreach (RequestAttachment attachment in uroIn.Attachments)
{
attachments.Add( returnFile ? AttachmentAdaptor.GetAttachmentAsFile(attachment) : AttachmentAdaptor.GetAttachment(attachment));
}
requestOut.Attachments = attachments.ToArray();
}
RequestAttachment mimeAttachment = uroIn.OriginalContentBytes;
if ( mimeAttachment != null)
{
CustomProperty mimeProperty = new CustomProperty(SMTPPropertyTags.OriginalMimeContent,
mimeAttachment.Data.AsString(mimeAttachment.Data.Length, Encoding.Unicode));
CustomProperty[] oldProps = requestOut.Properties;
List<CustomProperty> newProps = new List<CustomProperty>(oldProps);
newProps.Add(mimeProperty);
requestOut.Properties = newProps.ToArray();
}
return requestOut;
}
static public void CopyRouting(IUniversalRequestObject sourceUro, IUniversalRequestObject targetUro)
{
if ((null == sourceUro) || (null == targetUro))
return;
if (sourceUro.Source != null)
{
targetUro.Source = sourceUro.Source.Clone() as UniversalRoutingEntity;
}
if (sourceUro.Destination != null)
{
targetUro.Destination = sourceUro.Destination.Clone() as UniversalRoutingEntity;
}
}
public void Monitor(RunAt runat, IUniversalRequestObject uro, bool ProcessRoutingsAlso)
{
try
{
IPolicyResponseObject upi = ProcessConditions(runat, uro);
if (ProcessRoutingsAlso)
ProcessRoutings(upi);
}
catch (System.Exception e)
{
Logger.LogError(e);
#if DEBUG
Logger.LogError(PolicyResponseLogHelper.GetDisplayNames(m_Pro));
#endif
throw;
}
}
public IUniversalRequestObject Enforce(RunAt runat, IUniversalRequestObject uro)
{
try
{
IPolicyResponseObject upi = ProcessConditions(runat, uro);
ProcessRoutings(upi);
ProcessActions(upi);
uro = ExecuteActions(upi);
return uro;
}
catch (System.Exception e)
{
Logger.LogError(e);
#if DEBUG
Logger.LogError(PolicyResponseLogHelper.GetDisplayNames(m_Pro));
#endif
throw;
}
}
static public string[] GetRecipientAddressList(IUniversalRequestObject uro)
{
if ( null == uro)
throw new Workshare.Policy.Exceptions.ArgumentNullException("uro", "Invalid request object");
if (null == uro.Destination)
return new string[] { };
int addressCount = uro.Destination.Items.Count;
if (addressCount == 0)
return new string[] { };
ClearDuplicateAddresses(uro.Destination.Items);
string[] addresses = new string[addressCount];
int i = 0;
foreach (IRoutingItem routingItem in uro.Destination.Items)
{
addresses[i++] = routingItem.Content;
}
return addresses;
}
public void Convert(RequestChannel requestChannel, IUniversalRequestObject uro)
{
uro.PolicyType = PolicyType.ClientEmail;
uro.DataTimeStamp = DateTime.Now;
//These properties must all be set or else this email will be misinterpreted as the incorrect FileType.
uro.Properties[MailMessagePropertyKeys.FileHeader] = String.Empty;
uro.Properties[MailMessagePropertyKeys.Body] = m_emailProxy.BodyText;
uro.Properties[MailMessagePropertyKeys.FormattedBody] = m_emailProxy.FormattedBodyText;
uro.Properties[MailMessagePropertyKeys.Subject] = m_emailProxy.Subject;
uro.Properties[SMTPPropertyKeys.RequestChannel] = requestChannel.ToString();
uro.Destination.Properties[SMTPPropertyKeys.RequestChannel] = requestChannel.ToString();
uro.Source.Properties[SMTPPropertyKeys.RequestChannel] = requestChannel.ToString();
uro.Source.Items.Clear();
uro.Source.PolicyType = uro.PolicyType;
uro.Destination.PolicyType = uro.PolicyType;
ProcessSender(uro);
ProcessToRecipients(uro);
ProcessCcRecipients(uro);
ProcessBccRecipients(uro);
ProcessAttachments(uro);
ProcessHeaders(uro);
if (m_emailProxy.MimeSize < 3000000) // only for less than 3 Megabytes! (arbitrarily chosen figure)
{
uro.Properties[MailMessagePropertyKeys.MimeContent] = m_emailProxy.MimeContent;
}
else
{
uro.Properties[MailMessagePropertyKeys.LargeMimeContent] = "True"; // as was too large
}
}
private void ProcessHeaders(IUniversalRequestObject uro)
{
switch (m_emailProxy.Priority)
{
case Priority.High:
uro.Properties[MailMessagePropertyKeys.xPriority] = "1";
break;
case Priority.Normal:
uro.Properties[MailMessagePropertyKeys.xPriority] = "3";
break;
case Priority.Low:
uro.Properties[MailMessagePropertyKeys.xPriority] = "5";
break;
}
}
private string AddAttachment(IUniversalRequestObject uro, IEmailAttachment attachment)
{
RequestAttachment requestAttachment = new RequestAttachment();
string attachmentName = attachment.DisplayName;
requestAttachment.ContentType = MimeAttachmentsProxy.GetContentType(attachment);
requestAttachment.ContentId = attachment.ContentId;
requestAttachment.ContentItemIndex = attachment.ContentItemIndex;
requestAttachment.Name = attachmentName;
requestAttachment.FileName = attachment.FileName;
requestAttachment.File = new Workshare.FCS.Lite.Interface.File(attachment.FileName, attachment.DisplayName);
requestAttachment.IsSignature = attachment.IsSignature;
uro.Attachments.Add(requestAttachment);
return attachmentName;
}
private void DiscardOldAttachments(IUniversalRequestObject uro)
{
foreach (RequestAttachment attachment in uro.Attachments)
{
attachment.Dispose();
}
uro.Attachments.Clear();
}
private void ProcessAttachments(IUniversalRequestObject uro)
{
if (m_emailProxy.Attachments.Count == 0)
{
return;
}
DiscardOldAttachments(uro);
StringBuilder attachmentsPropString = new StringBuilder();
foreach (IEmailAttachment attachment in m_emailProxy.Attachments)
{
attachmentsPropString.AppendFormat("{0} ", AddAttachment(uro, attachment));
}
uro.Properties[MailMessagePropertyKeys.Attachments] = attachmentsPropString.ToString();
}
private void ProcessBccRecipients(IUniversalRequestObject uro)
{
foreach (IEmailRecipient recipient in m_emailProxy.BccRecipients)
{
ProcessRecipient(uro, recipient, AddressType.BCC);
}
}
private void ProcessRecipient(IUniversalRequestObject uro, IEmailRecipient recipient, string addressType)
{
IRoutingItem routingItem = new RoutingItem(recipient.EmailAddress);
routingItem.Properties[SMTPItemPropertyKeys.DisplayName] = recipient.Name.Trim();
routingItem.Properties[SMTPItemPropertyKeys.AddressType] = addressType;
routingItem.Properties[SMTPItemPropertyKeys.Internal] = recipient.Internal.ToString();
routingItem.Properties[EmailProperties.ModifiedKey] = bool.FalseString;
AddReadOnlyAttribute(routingItem);
AddOrReplaceDestinationRoutingItem(uro, routingItem);
}
private void AddOrReplaceDestinationRoutingItem(IUniversalRequestObject uro, IRoutingItem routingItem)
{
IRoutingItem destinationRoutingItem = FindDestinationRoutingItem(uro, routingItem);
if (null == destinationRoutingItem)
{
uro.Destination.Items.Add(routingItem);
}
else
{
string readOnlyValue;
if (destinationRoutingItem.Properties.TryGetValue(EmailProperties.ReadOnlyKey, out readOnlyValue))
{
if (System.Convert.ToBoolean(readOnlyValue, System.Globalization.CultureInfo.InvariantCulture))
return;
}
if (!IsSmtpAddress(routingItem.Content))
return;
if (destinationRoutingItem.Content != routingItem.Content)
{
destinationRoutingItem.Properties[EmailProperties.ModifiedKey] = bool.TrueString;
foreach (KeyValuePair<string, string> propertyPair in destinationRoutingItem.Properties)
{
routingItem.Properties[propertyPair.Key] = propertyPair.Value;
}
uro.Destination.Items.Remove(destinationRoutingItem);
uro.Destination.Items.Add(routingItem);
}
}
}
private static IPolicyResponseObject GetPolicyResponseFromScanner(IBaseContentScanner scanner, IUniversalRequestObject uro, ProcessLevel level, bool skipDiscovery)
{
Workshare.Policy.Interfaces.ProcessLevel translatedProcessLevel =
(Workshare.Policy.Interfaces.ProcessLevel) Enum.Parse(typeof(Workshare.Policy.Interfaces.ProcessLevel), level.ToString());
Logger.LogDebug(string.Format(CultureInfo.InvariantCulture, Properties.Resources.LOG_CALLING_SCANNER, scanner));
scanner.SkipDiscovery = skipDiscovery;
return scanner.Scan(uro, translatedProcessLevel);
}
public ReturnData(PolicyResponseObject pro, IUniversalRequestObject uro, IContainer container)
{
this.pro = pro;
this.uro = uro;
this.container = container;
}
private void SetupPolicyProcessor(GeneralPolicyProcessor gpp, IUniversalRequestObject uro)
{
gpp.Source = uro.Source;
gpp.Destination = uro.Destination;
string[] addresses = AddressUtilities.GetRecipientAddressList(uro);
gpp.RecipientList = addresses;
gpp.CurrentRunAtMode = m_runAt;
}
private void SetupPolicyProcessor(GeneralPolicyProcessor gpp, IUniversalRequestObject uro)
{
Logger.LogTrace("ContentScanner: SetupPolicyProcessor ENTER");
gpp.Source = uro.Source;
gpp.Destination = uro.Destination;
string[] addresses = AddressUtilities.GetRecipientAddressList(uro);
gpp.RecipientList = addresses;
gpp.CurrentRunAtMode = m_runAt;
Logger.LogTrace("ContentScanner: SetupPolicyProcessor EXIT");
}
public IPolicyResponseObject Scan(IUniversalRequestObject uro, ProcessLevel processLevel)
{
PerformanceCounters.Instance.StartTimer(PerformanceCounters.CounterType.ContentScan);
PolicyResponseObject pro = new PolicyResponseObject();
GeneralPolicyProcessor gpp = GetGeneralPolicyProcessor(uro);
if ( null == gpp)
return pro;
try
{
SetupPolicyProcessor(gpp, uro);
InitialisePro(pro, uro);
ProcessExpressions(gpp, pro);
if (processLevel >= ProcessLevel.Routing)
{
ProcessRouting(gpp, pro);
if (processLevel >= ProcessLevel.Actions)
{
ProcessActions(gpp, pro, m_skipDiscovery);
}
}
}
finally
{
TearDownPolicyProcessor(gpp);
PerformanceCounters.Instance.StopTimer(PerformanceCounters.CounterType.ContentScan, 0);
}
return pro;
}
private static string ConvertToText(IContentItem content, IUniversalRequestObject uro)
{
ContentItem fileInfo = content as ContentItem;
string sResult = "";
sResult += "FileName = " + fileInfo.File.DisplayName + Environment.NewLine;
sResult += "ContentType = " + fileInfo.File.FileType.ToString() + Environment.NewLine;
// InitialiseFileEntityMetadata(documentEntity, fileInfo);
// documentEntity.DocumentSource; Never seems to get set -> passed from action to docEntity
// public List<CustomPropertyEntity> DocumentCustomProperties = null;
int iPolicyInfoSetCount = 0;
foreach (IPolicySetResponse policySet in fileInfo.PolicySetCollection)
{
PolicySetResponse policySetInfo = policySet as PolicySetResponse;
sResult += "policySetInfo[" + iPolicyInfoSetCount.ToString(CultureInfo.InvariantCulture) + "]";
sResult += Environment.NewLine;
iPolicyInfoSetCount++;
sResult += "\tEventDate = " + policySetInfo.Date.ToString() + Environment.NewLine;
sResult += "\tPolicyName = " + policySetInfo.Name + Environment.NewLine;
int iPolicyInfoCount = 0;
foreach (Workshare.Policy.Engine.PolicyResponse policyInfo in policySetInfo.PolicyReportCollection)
{
sResult += "\tpolicyInfo[" + iPolicyInfoCount.ToString(CultureInfo.InvariantCulture) + "]";
sResult += Environment.NewLine;
iPolicyInfoCount++;
sResult += "\t\tConditionRuleName = " + policyInfo.Name + Environment.NewLine;
sResult += "\t\tAudit = " + policyInfo.Audit.ToString() + Environment.NewLine;
sResult += "\t\tViolated = " + policyInfo.Triggered.ToString() + Environment.NewLine;
if (policyInfo.ExpressionCollection != null)
{
int iExpressionInfoCount = 0;
foreach (IExpressionResponse expression in policyInfo.ExpressionCollection)
{
ExpressionResponse expressionInfo = expression as ExpressionResponse;
sResult += "\t\texpressionInfo[" + iExpressionInfoCount.ToString(CultureInfo.InvariantCulture) + "]";
sResult += Environment.NewLine;
iExpressionInfoCount++;
sResult += "\t\t\tConditionData = " + expressionInfo.Name + Environment.NewLine;
if (expressionInfo.Rating != null)
sResult += "\t\t\tConditionRating = " + expressionInfo.Rating.ToString() + Environment.NewLine;
sResult += "\t\t\tConditionType = " + "CONDITION" + Environment.NewLine;
sResult += "\t\t\tConditionViolated = " + expressionInfo.Triggered.ToString() + Environment.NewLine;
if (expressionInfo.Properties != null && expressionInfo.Properties.Count > 0)
{
int iExpressionPropertiesCount = 0;
foreach (IExpressionDetail expressionDetail in expressionInfo.ExpressionDetailCollection)
{
sResult += "\t\t\tExpressionProperties[" + iExpressionPropertiesCount.ToString(CultureInfo.InvariantCulture) + "] = ";
sResult += expressionDetail.Name + " = " + expressionDetail.Value + Environment.NewLine;
iExpressionPropertiesCount++;
}
}
}
}
if (policyInfo.InternalProperties != null)
{
int ipolicyInfoPropertiesCount = 0;
foreach (DictionaryEntry de in policyInfo.InternalProperties)
{
sResult += "\t\tpolicyInfoProperties[" + ipolicyInfoPropertiesCount.ToString(CultureInfo.InvariantCulture) + "] = ";
ipolicyInfoPropertiesCount++;
sResult += de.Key.ToString() + " = " + de.Value.ToString() + Environment.NewLine;
}
}
if (policyInfo.ActionCollection != null)
{
int iActionInfoCount = 0;
foreach (IPolicyResponseAction ai in policyInfo.ActionCollection)
{
PolicyResponseAction actionInfo = ai as PolicyResponseAction;
sResult += "\t\tactionInfo[" + iActionInfoCount.ToString(CultureInfo.InvariantCulture) + "]";
sResult += Environment.NewLine;
iActionInfoCount++;
sResult += "\t\t\tActionData = " + actionInfo.Name + Environment.NewLine;
sResult += "\t\t\tActionOverriden = " + actionInfo.Overridden.ToString() + Environment.NewLine;
sResult += "\t\t\tActionProcessed = " + actionInfo.Processed.ToString() + Environment.NewLine;
sResult += "\t\t\tActionRating = " + actionInfo.Rating + Environment.NewLine;
sResult += "\t\t\tActionType = " + actionInfo.Type + Environment.NewLine;
// ae.?? = actionInfo.Description;
if (actionInfo.InternalProperties != null && actionInfo.InternalProperties.Count > 0)
{
int iActionInfoPropertiesCount = 0;
foreach (KeyValuePair<string, Workshare.Policy.Action.IActionProperty> de in actionInfo.InternalProperties)
{
sResult += "\t\tActionInfoProperties[" + iActionInfoPropertiesCount.ToString(CultureInfo.InvariantCulture) + "] = ";
iActionInfoPropertiesCount++;
sResult += de.Key.ToString() + " = " + de.Value.DefaultDisplayName + Environment.NewLine;
}
}
}
}
}
}
return sResult;
}
private GeneralPolicyProcessor GetGeneralPolicyProcessor(IUniversalRequestObject uro)
{
if (0 == uro.Attachments.Count && m_zeroAttachmentGpp != null)
{
return m_zeroAttachmentGpp;
}
return m_gpp;
}
private IRoutingItem FindDestinationRoutingItem(IUniversalRequestObject uro, IRoutingItem routingItem)
{
foreach (IRoutingItem destinationRoutingItem in uro.Destination.Items)
{
if ((destinationRoutingItem.Properties[SMTPItemPropertyKeys.DisplayName] == routingItem.Properties[SMTPItemPropertyKeys.DisplayName]) &&
(destinationRoutingItem.Properties[SMTPItemPropertyKeys.AddressType] == routingItem.Properties[SMTPItemPropertyKeys.AddressType]))
{
return destinationRoutingItem;
}
}
return null;
}
public void Execute(IUniversalRequestObject uro)
{
IPolicyResponseObject response = engine.ProcessPolicies(RunAt.Client, uro, ProcessLevel.Actions);
Process(response.XMLReport);
}
private void InitialisePro(PolicyResponseObject pro, IUniversalRequestObject uro)
{
pro.RunAt = m_runAt;
pro.UniversalRequestObject = uro;
pro.PolicyType = uro.PolicyType;
pro.ChannelDetail = uro.Properties.ContainsKey("RequestChannel") ? uro.Properties["RequestChannel"] : "";
RoutingInfoHelper.PopulateRoutingInfo(pro);
ContainerBuilder containerBuilder = new ContainerBuilder(pro);
containerBuilder.CreateContainerFromUro();
}
public PolicyResponseObject Process(RunAt runat, IUniversalRequestObject uro, out IContainer container)
{
if (null == uro)
throw new PolicyEngineException("An invalid Universal Request Object was passed to the PolicyEngine.");
PolicyResponseObject pro = new PolicyResponseObject();
pro.RunAt = runat;
pro.UniversalRequestObject = uro;
pro.PolicyType = uro.PolicyType;
pro.ChannelDetail = uro.Properties.ContainsKey("RequestChannel") ? uro.Properties["RequestChannel"] : "";
// Conditions may use some routing information
// hence it is populated here.
PopulateRoutingInfo(pro);
Logger.LogDebug(PolicyResponseLogHelper.BuildUroMessage("ProcessConditions. input uro: ", uro));
OnPolicyProgress(new ExecuteEventArgs(null, "", status.Started));
ChannelType channel = PolicyTypeMappings.Lookup[uro.PolicyType];
m_policyEngineCache.SetPolicyEnginesCompiledPolicySetCache(pro, channel.ToString());
Logger.LogDebug("Process Conditions: PolicySetCacheSet");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
OnPolicyProgress(new ExecuteEventArgs(null, "", status.Started));
Logger.LogDebug("Process Conditions: Properties Added");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
AddFiles(pro, out container);
Logger.LogDebug("Process Conditions: Files Added");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
OnPolicyProgress(new ExecuteEventArgs(null, "", status.Started));
string[] addresses = AddressUtilities.GetRecipientAddressList(pro);
Logger.LogDebug("Process Conditions: Addresses Set");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
OnPolicyProgress(new ExecuteEventArgs(null, "", status.Started));
if (0 == m_policyEngineCache.GetPolicyEnginesForChannel(channel.ToString()).Count)
{
Logger.LogInfo("Warning: Processing content against no policy sets.");
return pro;
}
Logger.LogDebug("Process Conditions: About to process fileinfo objects");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
foreach (ContentItem fi in pro.ContentCollection)
{
StartPerformanceCounterForFileType(fi.File.FileType);
ProcessFileAgainstPolicyEngines(pro, runat, addresses, fi);
StopPerformanceCounterForFileType(fi.File.FileType, fi.Size);
}
Logger.LogDebug("Process Conditions: Completed");
#if DEBUG
Logger.LogDebug(PolicyResponseLogHelper.GetDisplayNames(pro));
#endif
return pro;
}
public UroToMime(IUniversalRequestObject uro)
{
m_uro = uro;
}
