C# FilterExpression.AddCondition方法代码示例

        public void When_executing_a_query_expression_with_2_filters_combined_with_an_or_filter_right_result_is_returned()
        {
            var context = new XrmFakedContext();
            var contact1 = new Entity("contact") { Id = Guid.NewGuid() }; contact1["fullname"] = "Contact 1"; contact1["firstname"] = "First 1";
            var contact2 = new Entity("contact") { Id = Guid.NewGuid() }; contact2["fullname"] = "Contact 2"; contact2["firstname"] = "First 2";

            context.Initialize(new List<Entity>() { contact1, contact2 });

            var qe = new QueryExpression() { EntityName = "contact" };
            qe.ColumnSet = new ColumnSet(true);
            

            var filter1 = new FilterExpression();
            filter1.AddCondition(new ConditionExpression("fullname", ConditionOperator.Equal, "Contact 1"));

            var filter2 = new FilterExpression();
            filter2.AddCondition(new ConditionExpression("fullname", ConditionOperator.Equal, "Contact 2"));

            qe.Criteria = new FilterExpression(LogicalOperator.Or);
            qe.Criteria.AddFilter(filter1);
            qe.Criteria.AddFilter(filter2);

            var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList();

            Assert.True(result.Count == 2);
        }

        /// <summary>
        /// Obtains all users corresponding to the search filter
        /// </summary>
        /// <param name="value">Search filter</param>
        /// <returns>List of users matching the search filter</returns>
        public List<Entity> GetUsers(string value)
        {
            var users = new List<Entity>();

            var ceStatus = new ConditionExpression("isdisabled", ConditionOperator.Equal, false);

            var feStatus = new FilterExpression();
            feStatus.AddCondition(ceStatus);

            var qe = new QueryExpression("systemuser");
            qe.ColumnSet = new ColumnSet("systemuserid", "fullname", "lastname", "firstname", "domainname", "businessunitid");
            qe.AddOrder("lastname", OrderType.Ascending);
            qe.Criteria = new FilterExpression();
            qe.Criteria.Filters.Add(new FilterExpression());
            qe.Criteria.Filters[0].FilterOperator = LogicalOperator.And;
            qe.Criteria.Filters[0].Filters.Add(feStatus);
            qe.Criteria.Filters[0].Filters.Add(new FilterExpression());
            qe.Criteria.Filters[0].Filters[1].FilterOperator = LogicalOperator.Or;

            if (value.Length > 0)
            {
                bool isGuid = false;

                try
                {
                    Guid g = new Guid(value);
                    isGuid = true;
                }
                catch
                { }

                if (isGuid)
                {
                    var ce = new ConditionExpression("systemuserid", ConditionOperator.Equal, value);
                    qe.Criteria.Filters[0].Filters[1].AddCondition(ce);
                }
                else
                {
                    var ce = new ConditionExpression("fullname", ConditionOperator.Like, value.Replace("*", "%"));
                    var ce2 = new ConditionExpression("firstname", ConditionOperator.Like, value.Replace("*", "%"));
                    var ce3 = new ConditionExpression("lastname", ConditionOperator.Like, value.Replace("*", "%"));
                    var ce4 = new ConditionExpression("domainname", ConditionOperator.Like, value.Replace("*", "%"));

                    qe.Criteria.Filters[0].Filters[1].AddCondition(ce);
                    qe.Criteria.Filters[0].Filters[1].AddCondition(ce2);
                    qe.Criteria.Filters[0].Filters[1].AddCondition(ce3);
                    qe.Criteria.Filters[0].Filters[1].AddCondition(ce4);
                }
            }

            foreach (var record in service.RetrieveMultiple(qe).Entities)
            {
                users.Add(record);
            }

            return users;
        }

        /// <summary>
        /// Executes the plug-in.
        /// </summary>
        /// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
        /// <see cref="IPluginExecutionContext"/>,
        /// <see cref="IOrganizationService"/>
        /// and <see cref="ITracingService"/>
        /// </param>
        /// <remarks>
        /// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
        /// The plug-in's Execute method should be written to be stateless as the constructor
        /// is not called for every invocation of the plug-in. Also, multiple system threads
        /// could execute the plug-in at the same time. All per invocation state information
        /// is stored in the context. This means that you should not use global variables in plug-ins.
        /// </remarks>
        protected void ExecutePricingTypeUpdate(LocalPluginContext localContext)
        {
            if (localContext == null)
            {
                throw new ArgumentNullException("localContext");
            }

            // TODO: Implement your custom Plug-in business logic.

            IPluginExecutionContext context = localContext.PluginExecutionContext;
            IOrganizationService service = localContext.OrganizationService;
            Guid quoteProductID = (Guid)((Entity)context.InputParameters["Target"]).Id;
            ColumnSet set = new ColumnSet();
            set.AllColumns = true;
            var quote = service.Retrieve("quote", quoteProductID, set);


            if (context.Depth > 1)
            {
                return;
            }
            else
            {

                //First I get the base values that I need for the calculations

                var pricingType = (OptionSetValue)quote["new_pricingtype"];

                ConditionExpression condition = new ConditionExpression();
                condition.AttributeName = "quoteid";
                condition.Operator = ConditionOperator.Equal;
                condition.Values.Add(quoteProductID);

                FilterExpression filter = new FilterExpression();
                filter.AddCondition(condition);

                QueryExpression query = new QueryExpression();
                query.EntityName = "quotedetail";
                query.ColumnSet = new ColumnSet(true);
                query.Criteria = filter;

                EntityCollection quotedetails = service.RetrieveMultiple(query);

                foreach (var detail in quotedetails.Entities)
                {
                    detail["new_pricingtype"] = new OptionSetValue(pricingType.Value);
                    service.Update(detail);
                }


                service.Update(quote);

            }
        }

        private IEnumerable<FilterExpression> GetConditionExpressionCollection(
            IEnumerable<Domain.Sql.DynamicRecord> originRecords, 
            IEnumerable<string> compoundKey, 
            AvailableValueConfiguration availableValueConfiguration)
        {
            var filters = new List<FilterExpression>();

            foreach (var record in originRecords)
            {
                var filter = new FilterExpression(LogicalOperator.And);

                foreach (var destinationAttribute in compoundKey)
                {
                    var currentField =availableValueConfiguration.Fields.First(x => x.DestinationAttribute == destinationAttribute);

                    if (record.Values[currentField.OriginColumn] == null)
                    {
                        filter.AddCondition(new ConditionExpression(destinationAttribute, ConditionOperator.Null));
                    }
                    else if (currentField.DestinationType == DestinationType.DateTime)
                    {
                        filter.AddCondition(new ConditionExpression(destinationAttribute, ConditionOperator.On, record.Values[currentField.OriginColumn]));
                    }
                    else if (currentField.DestinationType == DestinationType.EntityReference)
                    {
                        filter.AddCondition(new ConditionExpression(destinationAttribute, ConditionOperator.On, null));
                    }
                    else
                    {
                        filter.AddCondition(new ConditionExpression(destinationAttribute, ConditionOperator.Equal, record.Values[currentField.OriginColumn]));
                    }
                }

                filters.Add(filter);
            }

            return filters;
        }

        private static bool isDuplicate(string clientid, IOrganizationService orgservice)
        {
            //we search CRM to see if clientid is already in use and return true if it is and false otherwise
            var query = new QueryExpression("account");
            var columns = new ColumnSet();
            var filter = new FilterExpression();

            columns.AddColumn("ergo_clientid");
            filter.AddCondition("ergo_clientid", ConditionOperator.Equal, clientid);
            query.ColumnSet = columns;
            query.Criteria.AddFilter(filter);

            if(orgservice.RetrieveMultiple(query).Entities.Any()) return true;
            return false;
        }

        public static FilterExpression CreateFilterExpression(CrmQuery crmQuery)
        {
            if (crmQuery == null)
                return null;

            FilterExpression filterExpression =
                new FilterExpression(OperatorMapper.GetMappedOperator(crmQuery.LogicalOperator));

            foreach (CrmAttributeCriterion condition in crmQuery.Conditions)
            {
                ConditionOperator conditionOperator = OperatorMapper.GetMappedOperator(condition.ConditionOperator);
                ConditionExpression conditionExpression = new ConditionExpression(condition.AttributeName, conditionOperator, condition.AttributeValue);
                filterExpression.AddCondition(conditionExpression);
            }
            return filterExpression;
        }

        public static FilterExpression ToFilterExpression(this XElement elem, XrmFakedContext ctx)
        {
            var filterExpression = new FilterExpression();

            filterExpression.FilterOperator = elem.GetAttribute("type").Value.Equals("and") ? 
                                                    LogicalOperator.And : LogicalOperator.Or;

            //Process other filters recursively
            var otherFilters = elem
                        .Elements() //child nodes of this filter
                        .Where(el => el.Name.LocalName.Equals("filter"))
                        .Select(el => el.ToFilterExpression(ctx))
                        .ToList();


            //Process conditions
            var conditions = elem
                        .Elements() //child nodes of this filter
                        .Where(el => el.Name.LocalName.Equals("condition"))
                        .Select(el => el.ToConditionExpression(ctx))
                        .ToList();

            foreach (var c in conditions)
                filterExpression.AddCondition(c);

            foreach (var f in otherFilters)
                filterExpression.AddFilter(f);

            return filterExpression;
        }

        private IEnumerable<FilterExpression> GetFiltersPersonasJuridicas(IEnumerable<PersonaJuridica> sqlPersonasJuridicas)
        {
            var filters = GetFilters<PersonaJuridica>(
                sqlPersonasJuridicas,
                x =>
                {
                    var filter = new FilterExpression(LogicalOperator.And);

                    filter.AddCondition(new ConditionExpression("name", ConditionOperator.Equal, x.RazonSocial));

                    return filter;
                });

            return filters;
        }

        /// <summary>
        ///     Gets the plugins steps.
        /// </summary>
        /// <param name="crmSerivce">The CRM serivce.</param>
        /// <param name="conditions">The conditions.</param>
        /// <returns>EntityCollection.</returns>
        public static EntityCollection GetPluginsSteps(IOrganizationService crmSerivce,
            params ConditionExpression[] conditions)
        {
            var query = new QueryExpression
            {
                EntityName = EntityName.sdkmessageprocessingstep,
                ColumnSet = new ColumnSet(true)
            };

            query.Criteria.AddCondition(sdkmessageprocessingstep.ishidden, ConditionOperator.Equal, false);
            query.Criteria.AddCondition(sdkmessageprocessingstep.iscustomizable, ConditionOperator.Equal, true);
            query.Criteria.AddCondition(sdkmessageprocessingstep.customizationlevel, ConditionOperator.GreaterEqual, 1);

            var orFilter = new FilterExpression
            {
                FilterOperator = LogicalOperator.Or
            };

            orFilter.AddCondition(sdkmessageprocessingstep.name, ConditionOperator.DoesNotBeginWith, "Workflow");
            orFilter.AddCondition(sdkmessageprocessingstep.name, ConditionOperator.DoesNotBeginWith, "ObjectModel");
            orFilter.Conditions.AddRange(conditions);

            query.Criteria.Filters.AddRange(orFilter);
            return crmSerivce.RetrieveMultiple(query);
        }

        private void FillRequestList()
        {
            #region Create Table
            DataTable dtb = new DataTable();
            dtb.Columns.Add("ticketnumber");
            dtb.Columns.Add("title");
            dtb.Columns.Add("casetypecode");
            dtb.Columns.Add("description");
            dtb.Columns.Add("statecode");
            dtb.Columns.Add("state");
            dtb.Columns.Add("incidentid");
            dtb.Columns.Add("helpdesk_requesterconfirm");
            dtb.Columns.Add("helpdesk_statusdescription");
            #endregion

            #region Get Record From Crm
            QueryExpression query = new QueryExpression("incident");
            query.ColumnSet = new ColumnSet(true);
            OrderExpression _Order = new OrderExpression("createdon", OrderType.Descending);
            query.Orders.Add(_Order);
            FilterExpression _filterCustomer = new FilterExpression(LogicalOperator.And);
            _filterCustomer.AddCondition("customerid", ConditionOperator.Equal, new Guid("{" + Session["Personnelid"].ToString() + "}"));

            query.Criteria = new FilterExpression(LogicalOperator.And);
            query.Criteria.AddFilter(_filterCustomer);

            if (SelectType.SelectedValue.Trim() == "2" || SelectType.SelectedValue.Trim() == "3")
            {
                FilterExpression _filterState = new FilterExpression();
                if (SelectType.SelectedValue.Trim() == "2")
                {
                    _filterState.FilterOperator = LogicalOperator.And;
                    _filterState.AddCondition("statecode", ConditionOperator.Equal, 0);
                }
                else if (SelectType.SelectedValue.Trim() == "3")
                {
                    _filterState.FilterOperator = LogicalOperator.Or;
                    _filterState.AddCondition("statecode", ConditionOperator.Equal, 1);
                    _filterState.AddCondition("statecode", ConditionOperator.Equal, 2);
                }
                query.Criteria.AddFilter(_filterState);
            }
            EntityCollection retrieved = crmService.RetrieveMultiple(query);
            #endregion

            #region Fill DataTable
            if (retrieved != null && retrieved.Entities.Count > 0)
            {
                for (int i = 0; i < retrieved.Entities.Count; i++)
                {
                    DataRow dr = dtb.NewRow();
                    dr["ticketnumber"] = retrieved.Entities[i].Attributes["ticketnumber"].ToString();
                    if (retrieved.Entities[i].Contains("helpdesk_requesterconfirm") && retrieved.Entities[i].Attributes["helpdesk_requesterconfirm"] != null)
                        dr["helpdesk_requesterconfirm"] = retrieved.Entities[i].Attributes["helpdesk_requesterconfirm"].ToString();
                    else
                        dr["helpdesk_requesterconfirm"] = false;
                    if (retrieved.Entities[i].Attributes.Contains("title"))
                        dr["title"] = retrieved.Entities[i].Attributes["title"].ToString();

                    int CaseType = 0;
                    if (retrieved.Entities[i].Attributes.Contains("casetypecode"))
                    {
                        CaseType = ((OptionSetValue)retrieved.Entities[i].Attributes["casetypecode"]).Value;
                    }
                    dr["casetypecode"] = GetOptionsSetTextOnValue(crmService, "incident", "casetypecode", CaseType, 1065);
                    if (retrieved.Entities[i].Attributes.Contains("description"))
                        dr["description"] = retrieved.Entities[i].Attributes["description"].ToString();
                    if (((OptionSetValue)retrieved.Entities[i].Attributes["statecode"]).Value == 0)
                    {
                        dr["statecode"] = getStatuscode(((OptionSetValue)retrieved.Entities[i].Attributes["statuscode"]).Value);
                        dr["state"] = 0;
                    }
                    else
                    {
                        dr["statecode"] = GetStateTextOnValue(crmService, "incident", "statecode", ((OptionSetValue)retrieved.Entities[i].Attributes["statecode"]).Value, 1065);
                        dr["state"] = ((OptionSetValue)retrieved.Entities[i].Attributes["statecode"]).Value;
                    }
                    dr["incidentid"] = retrieved.Entities[i].Attributes["incidentid"].ToString();
                    if (retrieved.Entities[i].Contains("helpdesk_statusdescription") && retrieved.Entities[i].Attributes["helpdesk_statusdescription"] != null)
                        dr["helpdesk_statusdescription"] = getStatusDesccode(((OptionSetValue)retrieved.Entities[i].Attributes["helpdesk_statusdescription"]).Value);
                    if (((OptionSetValue)retrieved.Entities[i].Attributes["statecode"]).Value == 1)
                        dr["helpdesk_statusdescription"] = getStatusDesccode(3);
                    dtb.Rows.Add(dr);
                }
            }
            #endregion

            RequestView.DataSource = dtb;
            RequestView.DataBind();
        }

        private IEnumerable<FilterExpression> GetFiltersPersonasFisicas(IEnumerable<PersonaFisica> sqlPersonasFisicas)
        {
            var filters = GetFilters<PersonaFisica>(
                sqlPersonasFisicas,
                sqlPersonaFisica =>
                {
                    var filter = new FilterExpression(LogicalOperator.And);

                    var pais = this.crmPaisDao.GetObjectByCode(sqlPersonaFisica.PaisId.ToString());
                    filter.AddCondition(new ConditionExpression("bsv_pais", ConditionOperator.Equal, pais.Id));
                    var tipoDocumentoId = sqlPersonaFisica.TipoDocumentoId;
                    filter.AddCondition(new ConditionExpression("bsv_tipo_de_documento", ConditionOperator.Equal, tipoDocumentoId));
                    var numeroDocumento = sqlPersonaFisica.NumeroDocumento;
                    filter.AddCondition(new ConditionExpression("bsv_no_de_documento", ConditionOperator.Equal, numeroDocumento));

                    return filter;
                });

            return filters;
        }

        private Guid findConsultantID(string consultantName, IOrganizationService service)
        {
            consultantName = findConsultantName(consultantName, service);
            EventLog.saveMessage("The consultant full name is " + consultantName);

            ConditionExpression condition = new ConditionExpression();
            condition.AttributeName = "fullname";
            condition.Operator = ConditionOperator.Equal;
            condition.Values.Add(consultantName);

            FilterExpression filter = new FilterExpression();
            filter.AddCondition(condition);

            QueryExpression query = new QueryExpression();
            query.EntityName = "systemuser";
            query.ColumnSet = new ColumnSet(true);
            query.Criteria = filter;


            try
            {
                EntityCollection result = service.RetrieveMultiple(query);
                var accountid = Guid.Empty;

                accountid = result.Entities.FirstOrDefault().Id;
                return accountid;
            }
            catch (Exception)
            {
                EventLog.saveMessage("No such user exist in the CRM Database - " + consultantName);
                return new Guid("64FA3858-E5B8-E311-ABB3-00155D0A4E33");
            }
        }

        /// <summary>
        ///     Retrieves the name of the multiple by entity.
        /// </summary>
        /// <param name="crmService">The CRM service.</param>
        /// <param name="entityName">Name of the entity.</param>
        /// <param name="allColumns">if set to <c>true</c> [all columns].</param>
        /// <param name="columns">The columns.</param>
        /// <returns>Dictionary&lt;Guid, Entity&gt;.</returns>
        public static Dictionary<Guid, Entity> RetrieveMultipleByEntityName(IOrganizationService crmService,
            string entityName,
            bool allColumns = false,
            params string[] columns)
        {
            var keycolumns = XrmMetadataHelperFunctions.GetEntityPrimaryColumns(crmService, entityName);

            var criteria = new FilterExpression();

            if (string.CompareOrdinal(entityName, EntityName.connection) == 0)
            {
                criteria.AddCondition(systementity.ismaster, ConditionOperator.Equal, true);
            }

            return RetrieveMultiple(crmService,
                new QueryExpression(entityName)
                {
                    ColumnSet = columns.Length == 0
                        ? ((!allColumns && !string.IsNullOrEmpty(keycolumns.Value))
                            ? new ColumnSet(keycolumns.Key, keycolumns.Value, systementity.createdon,
                                systementity.createdby)
                            : new ColumnSet(XrmMetadataHelperFunctions.GetNonSystemColumns(crmService, entityName,
                                DiffXrmXml.Exceptions)))
                        : new ColumnSet(columns),
                    Distinct = true,
                    Criteria = criteria
                }
                );
        }

        /// <summary>
        /// Executes the plug-in.
        /// </summary>
        /// <param name="localContext">The <see cref="LocalPluginContext"/> which contains the
        /// <see cref="IPluginExecutionContext"/>,
        /// <see cref="IOrganizationService"/>
        /// and <see cref="ITracingService"/>
        /// </param>
        /// <remarks>
        /// For improved performance, Microsoft Dynamics CRM caches plug-in instances.
        /// The plug-in's Execute method should be written to be stateless as the constructor
        /// is not called for every invocation of the plug-in. Also, multiple system threads
        /// could execute the plug-in at the same time. All per invocation state information
        /// is stored in the context. This means that you should not use global variables in plug-ins.
        /// </remarks>
        protected void ExecuteInvoiceVATer(LocalPluginContext localContext)
        {
            if (localContext == null)
            {
                throw new ArgumentNullException("localContext");
            }

            // TODO: Implement your custom Plug-in business logic.

            IPluginExecutionContext context = localContext.PluginExecutionContext;
            IOrganizationService service = localContext.OrganizationService;
            Guid invoiceID = (Guid)((Entity)context.InputParameters["Target"]).Id;
            ColumnSet set = new ColumnSet();
            set.AllColumns = true;
            var invoice = service.Retrieve("invoice", invoiceID, set);


            if (context.Depth > 1)
            {
                return;
            }
            else
            {
                var totalamount = (Money)invoice["totallineitemamount"];
                var discount = (Money)invoice["totaldiscountamount"];

                var VAT = (OptionSetValue)invoice["new_vat"];
                var tax = totalamount.Value * VAT.Value / 100;

                ConditionExpression condition = new ConditionExpression();
                condition.AttributeName = "invoiceid";
                condition.Operator = ConditionOperator.Equal;
                condition.Values.Add(invoiceID);

                FilterExpression filter = new FilterExpression();
                filter.AddCondition(condition);

                QueryExpression query = new QueryExpression();
                query.EntityName = "invoicedetail";
                query.ColumnSet = new ColumnSet(true);
                query.Criteria = filter;

                EntityCollection invoicedetails = service.RetrieveMultiple(query);

                foreach (var detail in invoicedetails.Entities)
                {
                    bool isLocked = (bool)detail.Attributes["invoiceispricelocked"];

                    if (isLocked)
                    {
                        //It is really important to unlock both the Invoice and the Order!
                        UnlockInvoicePricingRequest unlockInvoice = new UnlockInvoicePricingRequest();
                        unlockInvoice.InvoiceId = ((EntityReference)detail.Attributes["invoiceid"]).Id;
                        UnlockInvoicePricingResponse unlockInvoiceResponse = (UnlockInvoicePricingResponse)service.Execute(unlockInvoice);
                    }

                    var quantity = (decimal)detail["quantity"];
                    var priceperunit = (Money)detail["priceperunit"];
                    var teamleader = (OptionSetValue)detail["new_tldiscount"];

                    //Then I calculate the manual discount and baseamount, for the further calculations
                    detail.Attributes["manualdiscountamount"] = new Money((priceperunit.Value * teamleader.Value / 100) * quantity);
                    var manualdiscountamount = (Money)detail.Attributes["manualdiscountamount"];
                    detail.Attributes["baseamount"] = new Money(priceperunit.Value * quantity);
                    var baseamount = (Money)detail["baseamount"];

                    //finally I calculate the tax
                    detail["new_vat"] = new OptionSetValue(VAT.Value);
                    var taxDetail = (baseamount.Value - manualdiscountamount.Value) * VAT.Value / 100;
                    detail.Attributes["tax"] = new Money(taxDetail); //tax

                    service.Update(detail);
                }

                invoice["new_totalamountincludingvat"] = new Money((totalamount.Value - discount.Value) + tax);

                service.Update(invoice);
            }
        }

        /// <summary>
        ///     Enables or disable workflow steps.
        /// </summary>
        /// <param name="crmService">The CRM service.</param>
        /// <param name="enableWorkflow">if set to <c>true</c> [enable workflow].</param>
        /// <param name="conditions">The conditions.</param>
        public static void EnableOrDisableWorkflowSteps(IOrganizationService crmService, bool enableWorkflow,
            params ConditionExpression[] conditions)
        {
            const string fetchWorkflow =
                @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
              <entity name='workflow'>
                <attribute name='workflowid' />
                <attribute name='name' />
                <order attribute='name' descending='false' />
                <filter type='and'>
                  <condition attribute='type' operator='eq' value='1' />
                  <filter type='or'>
                    <condition attribute='category' operator='eq' value='0' />
                    <filter type='and'>
                      <condition attribute='category' operator='eq' value='1' />
                      <condition attribute='languagecode' operator='eq-userlanguage' />
                    </filter>
                  </filter>
                  <condition attribute='statecode' operator='eq' value='1' />
                </filter>
              </entity>
            </fetch>";

            var request = new FetchXmlToQueryExpressionRequest
            {
                FetchXml = fetchWorkflow
            };
            var response = crmService.Execute(request) as FetchXmlToQueryExpressionResponse;
            if (response == null) return;

            var orFilter = new FilterExpression
            {
                FilterOperator = LogicalOperator.Or
            };

            orFilter.AddCondition(workflow.name, ConditionOperator.DoesNotBeginWith, "Workflow");
            orFilter.AddCondition(workflow.name, ConditionOperator.DoesNotBeginWith, "ObjectModel");
            orFilter.Conditions.AddRange(conditions);

            response.Query.Criteria.Filters.AddRange(orFilter);

            var results = crmService.RetrieveMultiple(response.Query);
            var activatedWorkflowIds = results.Entities.ToList();

            // Enable auditing on the organization.
            // First, get the organization's ID from the system user record.
            var currentUserId = ((WhoAmIResponse) crmService.Execute(new WhoAmIRequest())).UserId;

            activatedWorkflowIds.ForEach(workflowRecord =>
            {
                try
                {
                    crmService.Execute(new AssignRequest
                    {
                        Assignee = new EntityReference(EntityName.systemuser, currentUserId),
                        Target = new EntityReference(EntityName.workflow, workflowRecord.Id)
                    });

                    var statecode = enableWorkflow
                        ? new OptionSetValue((int) sdkmessageprocessingstep_enums.statecode.Enabled)
                        : new OptionSetValue((int) sdkmessageprocessingstep_enums.statecode.Disabled);

                    var statuscode = enableWorkflow
                        ? new OptionSetValue((int) sdkmessageprocessingstep_enums.statuscode.Enabled)
                        : new OptionSetValue((int) sdkmessageprocessingstep_enums.statuscode.Disabled);

                    crmService.Execute(new SetStateRequest
                    {
                        EntityMoniker = new EntityReference(EntityName.workflow, workflowRecord.Id),
                        State = statecode,
                        Status = statuscode
                    });
                }
                catch (FaultException<OrganizationServiceFault> orgex)
                {
                    orgex.Message.TraceError(orgex);
                }
            });
        }