// takes a uro and converts to InstantMessage Entity
		public static InstantMessageEntity ConvertToInstantMessageEntity(IPolicyResponseObject pro)
        {
            InstantMessageEntity instantMessageEntity = new InstantMessageEntity();
            // TODO: m_InstantMessageEntity.ChannelType = Upi.UniversalRequestObject.ChannelType;

			//instantMessageEntity.ChannelType = pro.ChannelType.ToString();
            // string RecipientIPAddress;
			if (pro.Properties.ContainsKey(IPPropertyKeys.DestinationIP))
				instantMessageEntity.DestinationIP = pro.Properties[IPPropertyKeys.DestinationIP];

            // string SenderIPAddress;
			if (pro.Properties.ContainsKey(IPPropertyKeys.OriginIP))
				instantMessageEntity.OriginIP = pro.Properties[IPPropertyKeys.OriginIP];

            List<DocumentEntity> documentEntities = new List<DocumentEntity>();
			foreach (IContentItem fileInfo in pro.ContentCollection)
            {
                if (!ShouldAudit(fileInfo))
                    continue;
				DocumentEntity documentEntity = ConvertToDocumentEntity(fileInfo, pro);
                documentEntities.Add(documentEntity);
            }

            instantMessageEntity.Contents = documentEntities.ToArray();
            return instantMessageEntity;
        }
Beispiel #2
0
        public static void AddActionToContentCollection(IPolicyResponseObject pro, IAction3 action, bool skipRootContainer, bool triggeredPolicy)
        {
            ResolvedAction resAction = new ResolvedAction();
            PolicyResponseAction pra = new PolicyResponseAction();
            pra.Action = action;
            pra.InternalProperties = new MockActionPropertySet();

            for (int index = 0; index < pro.ContentCollection.Count; ++index)
            {
                ContentItem contentItem = pro.ContentCollection[index] as ContentItem;
                if (null == contentItem)
                    continue;

                if (skipRootContainer && (0 == index) && (contentItem.File.IsCollection))
                    continue;     

                if (resAction.ContentCollection == null)
                    resAction.ContentCollection = new Collection<IContentItem>();

                resAction.ContentCollection.Add(contentItem);
                resAction.ResponseAction = pra;

                if (pro.ResolvedActionCollection == null)
                    (pro as PolicyResponseObject).ResolvedActionCollection = new Collection<IResolvedAction>();
                
                if(!pro.ResolvedActionCollection.Contains(resAction))
                    pro.ResolvedActionCollection.Add(resAction);

                AddActionToContentItem(contentItem, pra, triggeredPolicy);
            }
        }
		/// <summary>
		/// This method sets the 'InternalContact' bool field to internal/external depending on email address domain name.
		/// </summary>
		/// <param name="iPro"></param>
        public static void SetMessageRouting(IPolicyResponseObject iPro)
        {
            PolicyResponseObject pro = iPro as PolicyResponseObject;

            // Should be one sender
            if (pro.UniversalRequestObject.Source.Items.Count == 0)
            {
                // What to do? Apart from not crashing?
                return;
            }
            pro.UniversalRequestObject.Source.Items[0].Properties[SMTPItemPropertyKeys.Internal] = bool.TrueString;
            string sender = pro.UniversalRequestObject.Source.Items[0].Content;

            foreach (IRoutingItem routingItem in pro.UniversalRequestObject.Destination.Items)
            {
                string recipient = routingItem.Content;
                if (GetInternal(sender, recipient))
                {
                    routingItem.Properties[SMTPItemPropertyKeys.Internal] = bool.TrueString;
                }
                else
                {
                    routingItem.Properties[SMTPItemPropertyKeys.Internal] = bool.FalseString;
                }
            }
        }
        public static HttpRequestEntity ConvertToHttpRequestEntity(IPolicyResponseObject pro)
        {
            HttpRequestEntity httpRequestEntity = new Workshare.BusinessObjects.Entities.HttpRequestEntity();
            //httpRequestEntity.ChannelType = pro.ChannelType.ToString();
            httpRequestEntity.SendDateTime = pro.ResponseDate;

            if (pro.Properties.ContainsKey(IPPropertyKeys.OriginPort))
                httpRequestEntity.OriginPort = System.Convert.ToInt32(pro.Properties[IPPropertyKeys.OriginPort], CultureInfo.InvariantCulture);

            if (pro.Properties.ContainsKey(IPPropertyKeys.OriginIP))
                httpRequestEntity.OriginIP = pro.Properties[IPPropertyKeys.OriginIP];

            if (pro.Properties.ContainsKey(IPPropertyKeys.DestinationPort))
                httpRequestEntity.DestinationPort = System.Convert.ToInt32(pro.Properties[IPPropertyKeys.DestinationPort], CultureInfo.InvariantCulture);

            if (pro.Properties.ContainsKey(IPPropertyKeys.DestinationIP))
                httpRequestEntity.DestinationIP = pro.Properties[IPPropertyKeys.DestinationIP];

            if (pro.Properties.ContainsKey(HttpRequestPropertyKeys.RequestURL))
            {
                httpRequestEntity.RequestURL = pro.Properties[HttpRequestPropertyKeys.RequestURL];
                httpRequestEntity.Description = pro.Properties[HttpRequestPropertyKeys.RequestURL]; // sic
            }

            if (pro.Properties.ContainsKey(HttpRequestPropertyKeys.RequestProtocol))
                httpRequestEntity.RequestProtocol = pro.Properties[HttpRequestPropertyKeys.RequestProtocol];

            if (pro.Properties.ContainsKey(HttpRequestPropertyKeys.RequestMethod))
                httpRequestEntity.RequestMethod = pro.Properties[HttpRequestPropertyKeys.RequestMethod];

            if (pro.Properties.ContainsKey(HttpRequestPropertyKeys.ReferrerURL))
                httpRequestEntity.ReferrerURL = pro.Properties[HttpRequestPropertyKeys.ReferrerURL];

            List<DocumentEntity> documentEntities = new List<DocumentEntity>();
            if (pro.ContentCollection != null)
            {
                foreach (IContentItem fileInfo in pro.ContentCollection)
                {
                    if (!ShouldAudit(fileInfo))
                        continue;
                    DocumentEntity documentEntity = ConvertToDocumentEntity(fileInfo, pro);
                    documentEntities.Add(documentEntity);
                }
            }

            httpRequestEntity.Contents = documentEntities.ToArray();

            return httpRequestEntity;
        }
        public static string ConvertToText(IPolicyResponseObject pro)
        {
            PolicyResponseObject Upi = pro as PolicyResponseObject; 

            string sResult = "";
            if (Upi.UniversalRequestObject.Properties.ContainsKey(MailMessagePropertyKeys.Subject))
                sResult += "Subject = " + Upi.UniversalRequestObject.Properties[MailMessagePropertyKeys.Subject] + Environment.NewLine;
            sResult += "PolicyType = " + Upi.UniversalRequestObject.PolicyType + Environment.NewLine;

            foreach (IContentItem fileInfo in Upi.ContentCollection)
            {
               sResult +=  ConvertToText(fileInfo, Upi.UniversalRequestObject);
               sResult += "===============================================";
               sResult += Environment.NewLine;
            }
            return sResult;
        }
Beispiel #6
0
		public PolicyResponseObject ProcessActions(IPolicyResponseObject pro)
		{
			PolicyResponseObject upi = pro as PolicyResponseObject;
			if (upi == null)
				throw new PolicyEngineException("An invalid Policy Information Object was passed to the PolicyEngine.");

            ChannelType channel = PolicyTypeMappings.Lookup[upi.UniversalRequestObject.PolicyType];

			m_policyEngineCache.SetPolicyEnginesCompiledPolicySetCache(upi, channel.ToString());

			Dictionary<string, PolicyEngine> policyEngines = m_policyEngineCache.GetPolicyEnginesForChannel(channel.ToString());
			if (policyEngines.Count == 0)
				return null;

			PerformanceCounters.Instance.StartTimer(PerformanceCounters.CounterType.Actions);

			ProcessActionInfosForContentCollection(upi, policyEngines);

		    //ActionUtils.PopulateResolvedActionCollection(upi);

			PerformanceCounters.Instance.StopTimer(PerformanceCounters.CounterType.Actions, 0);

			return upi;
		}
Beispiel #7
0
		public IPolicyResponseObject ProcessRoutings(IPolicyResponseObject pro)
		{
			if (!(pro is PolicyResponseObject))
				throw new PolicyEngineException("An invalid Policy Information Object was passed to the PolicyEngine.");

			if (null == PolicyCache)
				throw new PolicyEngineException("The policy store has not been initialised.");

			RoutingProcessor routingProcessor = new RoutingProcessor(m_policyEngineCache);
			return routingProcessor.Process(pro as PolicyResponseObject);
		}
Beispiel #8
0
        private static void RemoveActionsWithEmptyContentLists(IPolicyResponseObject pro)
        {
            //remove any resolved item if no more content items are in its list.
            List<IResolvedAction> actions = new List<IResolvedAction>(pro.ResolvedActionCollection);
			actions.RemoveAll(x => x.ContentCollection == null || x.ContentCollection.Count == 0);

            ((PolicyResponseObject)pro).ResolvedActionCollection = new Collection<IResolvedAction>(actions);
        }
Beispiel #9
0
        /// <summary>
        /// This method does processing on the resolved action list in a pro.
        /// Actions in the resolved list are filtered out, if all policies where that action belongs
        /// had the property SkipVerifiedMessages = true.
        /// Also, the pro itself must be verified at the top level, or resolved actions should remain unaffected.
        /// </summary>
        /// <param name="pro"></param>
        /// <remarks>
        /// The purpose of this method is for policies that must 'skip messages that were already processed' by another Protect client.
        /// Currently the only example of this is preventing email messages sent from a machine with Protect client from being processed
        /// by a Protect Network mta.
        /// </remarks>
        public static void ResolveActionsForVerifiedResponses(IPolicyResponseObject pro)
        {
            if (pro == null || pro.ContentCollection == null || pro.ResolvedActionCollection == null ||
                pro.ResolvedActionCollection.Count == 0)
                return;

            if (!pro.VerifiedOnClient)
                return;

            foreach (IContentItem ci in pro.ContentCollection)
            {
                if (ci.PolicySetCollection == null) 
                    continue;

                Dictionary<string, List<IPolicyResponse>> actionLookup = MapActionsToPolicies(ci);

                //Which actions still apply for this content item?
                //If an action no longer applies due to Skipverified, it doesnt survive for this content item.
                List<string> blacklist = new List<string>();
                foreach (string type in actionLookup.Keys)
                {
                    if (actionLookup[type].TrueForAll(delegate(IPolicyResponse pol)
                        {
                            return pol.SkipVerifiedMessages;  
                        }))
                    {
                        blacklist.Add(type);
                    }
                }

                //for each resolved action, remove current content item from that list, if the resolved action is not in the survive list.
                foreach (IResolvedAction resolvedAction in pro.ResolvedActionCollection)
                {
                    if (resolvedAction.ContentCollection == null)
                        continue;

                    if (blacklist.Exists(delegate(string x)
                        {
                            return x == resolvedAction.ResponseAction.Type;
                        }))
                    {
                        RemoveContentItemFromResolvedAction(ci, resolvedAction);
                    }
                }
            }

            RemoveActionsWithEmptyContentLists(pro);
        }
		private List<_Document> getDocumentPolicies(IPolicyResponseObject upi)
		{
			foreach(Workshare.Policy.Engine.ContentItem content in upi.ContentCollection)
			{
				List<PolicyResponse>    policyResponses = new List<PolicyResponse>();

				foreach(PolicySetResponse set in content.PolicySetCollection)
				{
					foreach(PolicyResponse policyResponse in set.PolicyReportCollection)
					{
						// We check ActionCollection because Legacy policies all hace Active Content Channels
						// therefore policy will run through NXBRE and possibly  be triggered.  But only
						// legacy policies with Active Content channels that have Actions will have
						// policyResponse.ActionCollection.Count > 0 (JE 08.10.2010)
						if ((policyResponse.Triggered) && (policyResponse.ActionCollection.Count > 0 || shouldAllowPDFWithNoActions(upi, policyResponse)))
						{
							policyResponses.Add(policyResponse);
						}
					}
				}

				if(policyResponses.Count > 0)
				{
					_Document doc = new _Document();

					doc.Name        = content.DisplayName;
					doc.PolicyList  = policyResponses;

					_DocumentList.Add(doc);
				}
			}

			return _DocumentList;
		}
Beispiel #11
0
		private bool RemoveZipFilesInFolder(ActionData data,
											IPolicyResponseObject pro,
											bool bRemoved)
		{
			if (data.FileType == FileType.Folder)
			{
				int i = 0;
				while (i < data.Nested.Count)
				{
					if (!RemoveZipFilesInFolder(data.Nested[i] as ActionData, pro, bRemoved))
						++i;
				}
			}
			else if (data.FileType == FileType.ZIP)
			{
				foreach (ResolvedAction resAction in pro.ResolvedActionCollection)
				{
					foreach (ContentItem ci in resAction.ContentCollection)
					{
						if (ContainedinPRO(data.Properties["FileName"], ci.File as File))
						{
							if (!bRemoved)
								return false;
							if (data.Parent.Nested.Count > 0)
							{
								data.Parent.Nested.Remove(data);
								return true;
							}
						}
					}
				}
				if (!bRemoved && data.Parent.Nested.Count > 0)
				{
					data.Parent.Nested.Remove(data);
					return true;
				}
			}
			return false;
		}
        // takes a pro and converts to ActiveContentAlert Entity
        public static ActiveContentAlertEntity2 ConvertToActiveContentAlertEntity(IPolicyResponseObject pro)
        {
            ActiveContentAlertEntity2 activeContentAlertEntity = new ActiveContentAlertEntity2();
            //activeContentAlertEntity.ChannelType = pro.ChannelType.ToString();
            activeContentAlertEntity.SendDateTime = pro.ResponseDate;

            if (pro.Properties.ContainsKey(Workshare.Policy.Interfaces.ActiveContentPropertyKeys.UserName))
                activeContentAlertEntity.UserName = pro.Properties[Workshare.Policy.Interfaces.ActiveContentPropertyKeys.UserName];

            if (pro.Properties.ContainsKey(Workshare.Policy.Interfaces.ActiveContentPropertyKeys.MachineName))
                activeContentAlertEntity.MachineLocator = pro.Properties[Workshare.Policy.Interfaces.ActiveContentPropertyKeys.MachineName];

            if (pro.Properties.ContainsKey(Workshare.Policy.Interfaces.ActiveContentPropertyKeys.Application))
                activeContentAlertEntity.Application = pro.Properties[Workshare.Policy.Interfaces.ActiveContentPropertyKeys.Application];

            if (pro.ContentCollection != null)
            {
                if (pro.ContentCollection.Count > 0)
                    activeContentAlertEntity.SourceFileName = pro.ContentCollection[0].Name;
            }



            List<DocumentEntity> documentEntities = new List<DocumentEntity>();
            foreach (IContentItem fileInfo in pro.ContentCollection)
            {
                if (!ShouldAudit(fileInfo))
                    continue;

                DocumentEntity documentEntity = ConvertToDocumentEntity(fileInfo, pro);
                documentEntities.Add(documentEntity);
            }

            activeContentAlertEntity.Document = documentEntities[0];
            return activeContentAlertEntity;
        }
        public static MailMessageEntity ConvertToMailMessageEntity(IPolicyResponseObject pro)
        {
            MailMessageEntity m_MailMessageEntity = new MailMessageEntity();

            if ((pro != null) && (pro.RoutingInformation != null))
            {
                //m_MailMessageEntity.ChannelType = pro.ChannelType.ToString();
                m_MailMessageEntity.ContentType = pro.ChannelDetail;

                List<ContactEntity> recipientsTo = new List<ContactEntity>();
                List<ContactEntity> recipientsBCC = new List<ContactEntity>();
                List<ContactEntity> recipientsCC = new List<ContactEntity>();

                IUniversalRoutingEntity source = GetRoutingEntity(pro, RoutingTypes.Source.ToString());

                if (source != null)
                {
                    if (source.Items.Count == 1 && source.Items[0].Properties[SMTPItemPropertyKeys.AddressType] == AddressType.From)
                        m_MailMessageEntity.SenderContact = ExtractContact(source.Items[0]);
                }

                IUniversalRoutingEntity destination = GetRoutingEntity(pro, RoutingTypes.Destination.ToString());

                if (destination != null)
                {
                    foreach (IRoutingItem item in destination.Items)
                    {
                        if (item.Properties[SMTPItemPropertyKeys.AddressType] == AddressType.To)
                            recipientsTo.Add(ExtractContact(item));

                        if (item.Properties[SMTPItemPropertyKeys.AddressType] == AddressType.BCC)
                            recipientsBCC.Add(ExtractContact(item));

                        if (item.Properties[SMTPItemPropertyKeys.AddressType] == AddressType.CC)
                            recipientsCC.Add(ExtractContact(item));
                    }

                    m_MailMessageEntity.RecipientsTo = recipientsTo.ToArray();
                    m_MailMessageEntity.RecipientsBCC = recipientsBCC.ToArray();
                    m_MailMessageEntity.RecipientsCC = recipientsCC.ToArray();
                }

                m_MailMessageEntity.SendDateTime = pro.ResponseDate;
            }

            List<DocumentEntity> documentEntities = new List<DocumentEntity>();

            if ((pro != null) && (pro.ContentCollection != null))
            {
                foreach (IContentItem contentItem in pro.ContentCollection)
                {
                    DocumentEntity documentEntity = ProEntityConverter.ConvertToDocumentEntity(contentItem, pro);
                    documentEntities.Add(documentEntity);

                    if (contentItem.Type == "Email")
                    {
                        if (contentItem.Properties.ContainsKey("Subject"))
                            m_MailMessageEntity.Subject = contentItem.Properties["Subject"];
                    }
                }
            }

            m_MailMessageEntity.Attachments = documentEntities.ToArray();

            return m_MailMessageEntity;
        }
        private static IUniversalRoutingEntity GetRoutingEntity(IPolicyResponseObject pro, string type)
        {
            if (pro.RoutingInformation == null)
                return null;

            IUniversalRoutingEntity entity = pro.RoutingInformation[0];

            if (entity.RoutingType == type)
                return entity;

            if (pro.RoutingInformation.Count == 2)
            {
                entity = pro.RoutingInformation[1];

                if (entity.RoutingType == type)
                    return entity;
            }

            return null;
        }
Beispiel #15
0
		public static Response GetResponse( IPolicyResponseObject pro)
		{
			if (null == pro)
				throw new ArgumentNullException("pro");

			Response response = new Response();

			response.PolicyType = pro.PolicyType.ToString();
			response.ResponseDate = pro.ResponseDate;

			int index = 0;
			if (pro.ContentCollection != null && pro.ContentCollection.Count > 0)
			{
				response.Contents = new Workshare.PolicyContent.ContentItem[pro.ContentCollection.Count];
				bool useFiles = false;
				foreach (IContentItem ici in pro.ContentCollection)
				{
					if (ici.Properties.ContainsKey(ContentItemAdaptor.ContentDataSourceKey))
					{
						useFiles = true;
						break;
					}
				}

				foreach (IContentItem proContentItem in pro.ContentCollection)
				{
					if (!proContentItem.Properties.ContainsKey(ContentItemAdaptor.ContentDataSourceKey) && useFiles)
					{
						proContentItem.Properties[ContentItemAdaptor.ContentDataSourceKey] = string.Empty;
					}
					Workshare.PolicyContent.ContentItem contentItem = ContentItemAdaptor.GetContentItem(proContentItem);
					response.Contents[index++] = contentItem;
				}
			}

			List<CustomProperty> properties = new List<CustomProperty>();
			if (pro.Properties != null)
			{
				foreach (string key in pro.Properties.Keys)
				{
					properties.Add(new CustomProperty(key, pro.Properties[key]));
				}
			}
			properties.Add(new CustomProperty(PolicyConstants.ClientVerified, pro.VerifiedOnClient.ToString()));
			response.Properties = properties.ToArray();

			if (pro.ResolvedActionCollection != null && pro.ResolvedActionCollection.Count > 0)
			{
				index = 0;

				response.ResolvedActions = new Workshare.PolicyContent.ResolvedAction[pro.ResolvedActionCollection.Count];
				foreach (IResolvedAction ra in pro.ResolvedActionCollection)
				{
					response.ResolvedActions[index++] = ResolvedActionAdaptor.GetResolvedAction(ra);
				}
			}

			if (pro.RoutingInformation != null && pro.RoutingInformation.Count > 0)
			{
				index = 0;
				response.Routing = new RoutingEntity[pro.RoutingInformation.Count];
				foreach(IUniversalRoutingEntity ure in pro.RoutingInformation)
				{
					response.Routing[index++] = RoutingEntityAdaptor.GetRoutingEntity(ure);
				}
			}

			return response;
		}
Beispiel #16
0
		public IUniversalRequestObject ExecuteActions(IPolicyResponseObject upi)
		{
			ActionExecuter executer = new ActionExecuter(m_progressCallback);
			return executer.ExecuteActions(upi, ref m_container);
		}
        internal static DocumentEntity ConvertToDocumentEntity(IContentItem fileInfo, IPolicyResponseObject uro)
        {
            if (fileInfo == null)
                return null;

            DocumentEntity documentEntity = new DocumentEntity();
            List<PolicySetEventEntity> policyEvents = new List<PolicySetEventEntity>();

            // Can't actually do much populating if this is null
            documentEntity.ContentType = fileInfo.Type;
            documentEntity.Name = fileInfo.Name;

            InitialiseFileEntityMetadata(documentEntity, fileInfo);

            if (fileInfo.PolicySetCollection != null)
            {
                foreach (IPolicySetResponse policySetInfo in fileInfo.PolicySetCollection)
                {
                    PolicySetEventEntity PolicySet = new PolicySetEventEntity();
                    PolicySet.EventDate = policySetInfo.Date;
                    PolicySet.PolicySetName = policySetInfo.Name;
                    List<PolicyEntity> PolicyEntities = new List<PolicyEntity>();

                    if (policySetInfo.PolicyReportCollection != null)
                    {
                        foreach (IPolicyResponse policyInfo in policySetInfo.PolicyReportCollection)
                        {
                            if (!ProEntityConverter.ShouldAudit(policyInfo))
                                continue;

                            PolicyEntity PolicyEntity = new PolicyEntity();

                            PolicyEntity.PolicyName = policyInfo.Name;
                            PolicyEntity.Triggered = policyInfo.Triggered;

                            List<ExpressionEntity> expressionList = new List<ExpressionEntity>();
                            if (policyInfo.ExpressionCollection != null)
                            {
                                foreach (IExpressionResponse expressionInfo in policyInfo.ExpressionCollection)
                                {
                                    if (!expressionInfo.Triggered)
                                        continue;

                                    ExpressionEntity expression = new ExpressionEntity();
                                    expression.ExpressionName = expressionInfo.Name;
                                    expression.ExpressionRating = expressionInfo.Rating;
                                    expression.ExpressionType = "CONDITION";
                                    expression.ExpressionTriggered = expressionInfo.Triggered;

                                    // IMPORTANT!! these not put to the audit trail as is storing personal info. bad.
                                    List<ExpressionPropertyEntity> expressionProperty = new List<ExpressionPropertyEntity>();
                                    expression.ExpressionProperties = expressionProperty.ToArray();

                                    expressionList.Add(expression);
                                }
                            }

                            if (policyInfo.Routing != null)
                            {
                                ExpressionEntity routing = new ExpressionEntity();
                                routing.ExpressionName = policyInfo.Routing.Name;
                                routing.ExpressionRating = policyInfo.Routing.Rating;
                                routing.ExpressionType = "ROUTING";
                                routing.ExpressionTriggered = true;

                                // IMPORTANT!! these not put to the audit trail as is storing personal info. bad.
                                List<ExpressionPropertyEntity> expressionProperty = new List<ExpressionPropertyEntity>();
                                routing.ExpressionProperties = expressionProperty.ToArray();

                                expressionList.Add(routing);
                            }
                            PolicyEntity.Expressions = expressionList.ToArray();

                            List<PolicyPropertyEntity> policyPropList = new List<PolicyPropertyEntity>();
                            if (policyInfo.Properties != null)
                            {
                                foreach (KeyValuePair<string, string> de in policyInfo.Properties)
                                {
                                    PolicyPropertyEntity prop = new PolicyPropertyEntity();
                                    prop.Name = de.Key;
                                    prop.PropertyValue = de.Value;
                                    policyPropList.Add(prop);
                                }
                            }
                            PolicyEntity.PolicyProperties = policyPropList.ToArray();

                            List<ActionEntity> acList = new List<ActionEntity>();
                            if (policyInfo.ActionCollection != null)
                            {
                                foreach (IPolicyResponseAction actionInfo in policyInfo.ActionCollection)
                                {
                                    ActionEntity ae = ConvertActionEntity(actionInfo);

                                    if (ae != null)
                                        acList.Add(ae);
                                }
                            }
                            PolicyEntity.Actions = acList.ToArray();
                            PolicyEntities.Add(PolicyEntity);
                        }
                    }
                    PolicySet.Policies = PolicyEntities.ToArray();
                    policyEvents.Add(PolicySet);
                }
            }
            documentEntity.DocumentEvents = policyEvents.ToArray();
            return documentEntity;
        }
Beispiel #18
0
		public IPolicyResponseObject ProcessActions(IPolicyResponseObject pro)
		{
			ActionProcessor processor = new ActionProcessor(m_PolicyCache, m_policyEngineCache);
			m_Pro = processor.ProcessActions(pro);
			if (m_Pro != null)
				ActionUtils.PopulateResolvedActionCollection(m_Pro);
			return m_Pro;
		}
 public static bool ShouldAudit(IPolicyResponseObject pro)
 {
     foreach (IContentItem fileInfo in pro.ContentCollection)
     {
         if (ShouldAudit(fileInfo))
             return true;
     }
     return false;
 }
Beispiel #20
0
		/// <summary>
		/// Executes actions specified in the PolicyResponseObject. Supports both file and folder based
		/// actions.
		/// </summary>
		/// <param name="pro">PolicyResponseObject with ResolvedActions and ContentItems</param>
		/// <param name="container">ContentItems in a hierarchy structure</param>
		/// <returns></returns>
		public IUniversalRequestObject ExecuteActions(IPolicyResponseObject pro, ref IContainer container)
		{
			MimeEngine mimeEngine = new MimeEngine();
			mimeEngine.ProgressCallback = _progressCallback;

			PolicyResponseObject realPro = pro as PolicyResponseObject;
			if (realPro == null)
				throw new PolicyEngineException("Invalid policy response object passed to the ActionExecuter");

			// for now just do this fudge - cull this at earliest opportunity Laku 25/07/07
			// the handling of the block and alert actions should be within the action processor
			if (ContainsBlockAction(realPro.ResolvedActionCollection))
			{
				container.Files.Clear();
				return CreateOutputUro(realPro, container);
			}

			#region process resolved actions
			// builds the master list of items into a hierarchy
			ActionData masterData = new ActionData(container, GetReadableContent);
			List<Guid> collections = new List<Guid>();

			PolicyResponseAction pra = null;
			ActionData workingSet = null;
			try
			{
				foreach (ResolvedAction resAction in pro.ResolvedActionCollection)
				{
					if (resAction.ContentCollection.Count <= 0)
						continue;
					pra = resAction.ResponseAction as PolicyResponseAction;
					if (pra.IsExceptionAction)
					{
						mimeEngine.ExceptionAction = pra;
						continue;
					}

					if (pra.Action.Capabilities.SupportsMime && !mimeEngine.Actions.ContainsKey(resAction))
					{
						mimeEngine.Actions[resAction] =
							GetActionOfTypeFromContentItem(realPro, resAction.ContentCollection[0], resAction.ResponseAction.Type).InternalProperties as ActionPropertySet;
						if (masterData.FileType == FileType.Email)
							continue;
					}

					collections.Clear();
					ActionData.GetAllCollectionId(masterData, collections);

					workingSet = new ActionData(masterData, new Predicate<ActionData>(delegate(ActionData item)
					{
						string supportedFileType = FileTypeToSupportedFileTypeString(item.FileType);

						if (item.FileType == FileType.Folder || item.FileType == FileType.Selection)
							return true;

						if (!pra.Action.SupportedFileCollection.Supports(supportedFileType))
							return false;

						if (item.Underworld != null && item.Underworld.Parent != null)
						{
							IFile parent = item.Underworld.Parent as IFile;
							if (parent != null && parent.FileType == FileType.ZIP)// && !pra.Action.SupportedFileCollection.Supports(".zip"))
								if (Array.IndexOf(pra.Action.SupportedFileCollection.UnsupportedFiles(), ".zip") >= 0)
									return false;
						}

						foreach (ContentItem ci in resAction.ContentCollection)
						{
							if (ci.File.UniqueIdentifier == item.Underworld.UniqueIdentifier &&
								pra.Action.SupportedFileCollection.Supports(supportedFileType))
							{
								return true;
							}
						}

						return false;
					}), GetReadableContent);

					if (ActionUtils.DoesActionSupportFolders((resAction.ResponseAction as PolicyResponseAction).Action))
					{
						//magic
						IActionProperty prop = null;
						ActionData firstLevelData = workingSet.Nested[0] as ActionData;

						if (workingSet.Nested.Count > 0)
							pra = FindContentAction(realPro, firstLevelData, resAction, true);

						bool bZipAllFolder = false;

						if (pra.InternalProperties.SystemProperties.TryGetValue("FileType", out prop))
						{
							if (workingSet.FileType == FileType.Email)
								prop.Value = ".email";
							else
							{
								prop.Value = ".fld";
								IActionProperty zipAttr = null;
								if (pra.InternalProperties.TryGetValue("ZIPAttachedFiles", out zipAttr) &&
									(bool) zipAttr.Value)
								{
									bZipAllFolder = true;
									if (workingSet.Nested.Count > 0)
										RemoveZipFilesInFolder(workingSet.Nested[0] as ActionData, pro, false);
								}
							}
						}

						ExecuteAction(pra, workingSet);
						if (masterData.Nested.Count > 0 && bZipAllFolder)
						{
							RemoveZipFilesInFolder(masterData.Nested[0] as ActionData, pro, true);
						}
					}
					else
					{
						foreach (ActionData item in workingSet.GetAllLeafs())
						{
							PolicyResponseAction actionToExecute = FindContentAction(realPro, item, resAction, false);

							ExecuteAction(actionToExecute, item);
						}
					}
					ActionData.Merge(masterData, workingSet, true);
					ActionData.PruneEmptyCollections(masterData, collections);
					pra.Executed = true;
				}

			}
			catch (AbortActionException abortThis)
			{
				// handle abort scenario
				PolicyActionException somethingWrong =
					new PolicyActionException(string.Format(CultureInfo.InvariantCulture, "Operation was aborted by action {0}", pra.Type), abortThis);

				somethingWrong.ExceptionHandling = ActionExceptionHandling.Abort;

				throw somethingWrong;
			}
			catch (Exception e)
			{
				throw CreateActionException(pra.Type, realPro, e, false);
			}
			#endregion

			if (masterData.Nested.Count != 0)
				container = ContentToPackedContainer(masterData);
			else
				container.Files.Clear();

			// Synchronise the URO with the changes to the attachments
			IUniversalRequestObject outputUro = CreateOutputUro(realPro, container);

			try
			{
				// The MIME actions will modify the URO directly            
				mimeEngine.ExecuteActions(outputUro);

				UniversalResponseObjectHelper.CopyProperties(outputUro, realPro.UniversalRequestObject);
				UniversalResponseObjectHelper.CopyRouting(outputUro, realPro.UniversalRequestObject);

			}
			catch (AbortActionException abortThis)
			{
				// handle abort scenario
				PolicyActionException somethingWrong =
					 new PolicyActionException(string.Format(CultureInfo.InvariantCulture, "Operation was aborted by action {0}", pra.Type), abortThis);

				somethingWrong.ExceptionHandling = ActionExceptionHandling.Abort;

				throw somethingWrong;
			}
			catch (Exception e)
			{
				throw CreateActionException(pra.Type, realPro, e, true);
			}

			return outputUro;
		}
		/// -----------------------------------------------------------------------------
		/// 
		private void internalInitialize(IPolicyResponseObject pro)
		{
			if(pro != null)
			{
				List<_Document> documentList = getDocumentPolicies(pro);

				processDocumentList(documentList);
			}
		}
Beispiel #22
0
		private static bool UpdateIncidentProperties(IPolicyResponseObject response)
		{
			bool bIncidentRaised = false;
			
			if (response.ContentCollection == null)
				return false;

			foreach (IContentItem contentItem in response.ContentCollection)
			{
				foreach (IPolicySetResponse policySet in contentItem.PolicySetCollection)
				{
					foreach (IPolicyResponse policy in policySet.PolicyReportCollection)
					{
						if ((policy.Routing != null) && (policy.Routing.Properties != null))
						{
							Dictionary<string, string> WorkflowProps = new Dictionary<string, string>(policy.Properties);
							Dictionary<string, string> NonWorkflowProps = new Dictionary<string, string>(policy.Properties);

							WorkflowProps[IncidentPropertyKeys.CloseIncident] = bool.TrueString;

							foreach (KeyValuePair<string, string> property in policy.Routing.Properties)
							{
								if (property.Key == "RaiseIncidentWorklist" && !string.IsNullOrEmpty(property.Value))
								{
									bIncidentRaised = true;
									WorkflowProps[IncidentPropertyKeys.Incident] = bool.TrueString;
									WorkflowProps[IncidentPropertyKeys.Worklist] = property.Value;
								}
								else
								{
									if (property.Key == "CloseIncident" && !string.IsNullOrEmpty(property.Value))
										WorkflowProps[IncidentPropertyKeys.CloseIncident] = property.Value;
									else
										NonWorkflowProps[property.Key] = property.Value;
								}
							}

							policy.Properties.Clear();
							foreach (KeyValuePair<string, string> kvp in WorkflowProps)
								policy.Properties.Add(kvp.Key, kvp.Value);

							policy.Routing.Properties.Clear();
							foreach (KeyValuePair<string, string> kvp in NonWorkflowProps)
								policy.Routing.Properties.Add(kvp.Key, kvp.Value);
						}
					}
				}
			}

			return bIncidentRaised;
		}
		public static RemovableStorageEntity ConvertToRemovableTransferEntity(IPolicyResponseObject pro)
		{
			RemovableStorageEntity removableStorageEntity = new RemovableStorageEntity();
			removableStorageEntity.InspectionDateTime = pro.ResponseDate;
            removableStorageEntity.MachineLocator = System.Environment.MachineName;

			if (pro.RoutingInformation.Count > 0)
			{
				IUniversalRoutingEntity sourceRouting = GetRoutingEntity(pro, RoutingTypes.Source);
				IUniversalRoutingEntity destinationRouting = GetRoutingEntity(pro, RoutingTypes.Destination);

				if (sourceRouting != null)
				{
					if (sourceRouting.Items.Count > 0)
					{
                        if (sourceRouting.Items[0].Properties.ContainsKey(Workshare.Policy.Routing.SMTPItemPropertyKeys.DisplayName))
                            removableStorageEntity.UserName = sourceRouting.Items[0].Properties[Workshare.Policy.Routing.SMTPItemPropertyKeys.DisplayName];
                        else
    						removableStorageEntity.UserName = sourceRouting.Items[0].Content;
					}
				}

				if (destinationRouting != null)
				{
					foreach (IRoutingItem routing in destinationRouting.Items)
					{
						if (routing.Properties.ContainsKey(RemovableDeviceItemPropertyKeys.ContentType))
						{
                            switch (routing.Properties[RemovableDeviceItemPropertyKeys.ContentType])
							{
                                case RemovableDeviceItemContentTypes.DeviceType:
									removableStorageEntity.DeviceType = routing.Content;
									break;

                                case RemovableDeviceItemContentTypes.VolumeID:
									removableStorageEntity.DeviceID = routing.Content;
									break;

                                case RemovableDeviceItemContentTypes.VolumeName:
									removableStorageEntity.DeviceName = routing.Content;
									break;
							}
						}
					}
				}
			}

			List<DocumentEntity> fileEntities = new List<DocumentEntity>();
			foreach (IContentItem fileInfo in pro.ContentCollection)
			{
				if (!ShouldAudit(fileInfo))
					continue;

				DocumentEntity fileEntity = ConvertToDocumentEntity(fileInfo, pro);
				fileEntities.Add(fileEntity);
			}
			removableStorageEntity.Files = fileEntities.ToArray();

			return removableStorageEntity;
		}
        private void EnforcePolicy()
        {
            m_policyResponseObject = null;

            if (m_engine == null || m_uroIn == null)
                throw new System.NullReferenceException("Give me something to work with!");

            m_policyResponseObject = m_engine.ProcessPolicies(RunAt.Client, m_uroIn, ProcessLevel.Actions);
        }
		private bool shouldAllowPDFWithNoActions(IPolicyResponseObject upi, PolicyResponse policyResponse)
		{
			bool decision = false;

			if (upi.ContentCollection.Count > 0 && upi.ContentCollection[0].Type	== "PDFDocument")
			{
				if (policyResponse.Description == "Clean Policy."
					&& policyResponse.Name == "Hidden PDF Data Policy")
				{
					for (int i = 0; i < policyResponse.ExpressionCollection.Count; i++)
					{
						// policyResponse.ExpressionCollection[0].Name == "Cleans PDF documents of hidden data."
						if (policyResponse.ExpressionCollection[i].ExpressionDetailCollection.Count > 0)
						{
							decision = true;
							break;
						}
					}
				}
			}
			return decision;
		}