Context.depth in mscrm plugin

Used by the platform for infinite loop prevention.
 In most cases, this property can be ignored.
Every time a running plug-in or Workflow issues a message request to the Web services
 that triggers another plug-in or Workflow to execute, the Depth property of the execution
 context is increased. If the depth property increments to its maximum value within the
 configured time limit, the platform considers this behavior an infinite loop and further plug-in or
 Workflow execution is aborted. The maximum depth (8) and time limit (one hour) are
configurable by the Microsoft Dynamics CRM administrator.

IPluginExecutionContextExtension Method

public static class IPluginExecutionContextExtension
    {
        public static Microsoft.Xrm.Sdk.Entity GetPrimaryEntity(this Microsoft.Xrm.Sdk.IPluginExecutionContext context)
        {
            var inputeParameter = context.InputParameters;
           
             if (inputeParameter.Contains("Target") &&
                 inputeParameter["Target"] is Microsoft.Xrm.Sdk.Entity)
            {
                return inputeParameter["Target"] as Microsoft.Xrm.Sdk.Entity;
            }

            return null;
        }

        public static Microsoft.Xrm.Sdk.Entity GetPreImageEntity(this Microsoft.Xrm.Sdk.IPluginExecutionContext context, string imageKey)
        {
            if (context.PreEntityImages.Contains(imageKey))
            {
                return context.PreEntityImages[imageKey];
            }

            return null;
        }
       
        public static Microsoft.Xrm.Sdk.Entity GetPostImageEntity(this Microsoft.Xrm.Sdk.IPluginExecutionContext context, string imageKey)
        {
            if (context.PostEntityImages.Contains(imageKey))
            {
                return context.PostEntityImages[imageKey];
            }

            return null;
        }
    }
}



                   Entity currentCase = context.GetPrimaryEntity();
                    Entity preCase = context.GetPreImageEntity("preImage");
                    Entity postCase = context.GetPostImageEntity("postImage");


Here we are using Extension method of .NET.

Related Entity Retrieve in MSCRM 2011 Plugin

 public void Execute(IServiceProvider serviceProvider)
        {
            IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
            IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
            IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
            ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));


            EntityReference target = (EntityReference)context.InputParameters["Target"];



       

            if (target.LogicalName == "new_mediationsession" || target.LogicalName == "cmu_assignedmediator")
            {
                Relationship relationShip = (Relationship)context.InputParameters["Relationship"];


                EntityReferenceCollection relatedentities = (EntityReferenceCollection)context.InputParameters["RelatedEntities"];

                foreach (EntityReference rel in relatedentities)
                {

                    if (rel.LogicalName == "cmu_assignedmediator" && relationShip.SchemaName == "cmu_cmu_assignedmediator_new_mediationsession" && context.MessageName == "Associate")
                    {


                     
                        GetMediationSession(rel, service, target, mediator);







                    }

                }

            }

        }







 public void GetMediationSession(EntityReference rel, IOrganizationService service, EntityReference target, Entity mediator)
        {

         

            QueryExpression query = new QueryExpression()
            {
                EntityName = "new_mediationsession",
                ColumnSet = new ColumnSet(true),
                LinkEntities =
                            {
                                new LinkEntity
                                    {
                                        LinkFromEntityName = "new_mediationsession",
                                        LinkFromAttributeName = "new_mediationsessionid",
                                        LinkToEntityName = "new_new_mediationsession_new_mediator",
                                        LinkToAttributeName = "new_mediationsessionid",
                                        LinkCriteria = new FilterExpression
                                            {

                                                FilterOperator = LogicalOperator.And,
                                                Conditions =
                                                    {
                                                        new ConditionExpression
                                                            {
                                                                AttributeName = "new_mediatorid",
                                                                Operator = ConditionOperator.Equal,
                                                                Values = {rel.Id}
                                                            }
                                                    }
                                            }
                                    }
                            }
            };

            EntityCollection ec = service.RetrieveMultiple(query);






Here Entity 1 is new_mediationsession,     Intersection Entity -  new_new_mediationsession_new_mediator.

and Entity 2 id is  rel.Id which triggered assosciate operation .

Here cmu_assignedmediator is the entity which triggered asssosciate message and has N:N relationship with new_mediationsession.

Retrieving activity party from email.

 protected override void Execute(CodeActivityContext executionContext)
        {
            //Create the tracing service

            try
            {
                //Create the context
                IExecutionContext context = executionContext.GetExtension<IExecutionContext>();
                IOrganizationServiceFactory serviceFactory = executionContext.GetExtension<IOrganizationServiceFactory>();
                IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
                ITracingService tracer = executionContext.GetExtension<ITracingService>();

                bool isEmailmatches = false;
                EntityReference incident = EmailActivityLookup.Get(executionContext);

                RetrieveRequest request = new RetrieveRequest();
                request.ColumnSet = new ColumnSet(new string[] { "from", "description", "subject" });
                request.Target = new EntityReference("email", incident.Id);

                string email = string.Empty;
                string senderqueue = string.Empty;
                string senderqueueFOC = string.Empty;

                bool senderqueueOutput = false;
                bool senderqueueOutputFOC = false;


             
         

           
                Guid SenderQueueId = Guid.Empty;


           

                Entity entity = (Entity)((RetrieveResponse)service.Execute(request)).Entity;

                 
             


                EntityCollection IncommingParty = null;


                IncommingParty = (EntityCollection)entity["from"];


           


                for (int i = 0; i < IncommingParty.Entities.Count; i++)
                {

                    if (IncommingParty != null && IncommingParty[i].LogicalName
                     == "activityparty")
                    {
                        EntityReference PartyReference =
                        (EntityReference)IncommingParty[i]["partyid"];


                        // Checking if email is sent by CRM Account
                        if (PartyReference.LogicalName == "systemuser")
                        {
                            // Retrieve sender Account record
                            Entity User = service.Retrieve("systemuser",
                            PartyReference.Id, new ColumnSet(true));

                            // wod_Account = new Entity("account");
                            email = User.Attributes["internalemailaddress"].ToString();


                            if (email.Contains("HotAlerts@QTHotAlerts.com") == true)
                            {
                                senderqueue = "Tier 1 Email";



                            }

                            if (email.Contains("ford.com") == true)
                            {
                               
                                senderqueue = "Tier 1 Email";


                            }

                            if (email.Contains(".ca") == true)
                            {
                             

                                senderqueueFOC = "FOC Tier 1 Email - English ";


                            }

                            if (email.Contains("icollection.com") == true)
                            {
                                senderqueue = "Tier 1 Email";

                            }



                        }


                    }






                }
             



                QueryByAttribute querybyattribute2 = new QueryByAttribute("queue");
                querybyattribute2.ColumnSet = new ColumnSet("name", "queueid");

                querybyattribute2.Attributes.AddRange("name");

                //  Value of queried attribute to return.
                querybyattribute2.Values.AddRange(senderqueue);
               
                EntityCollection retrieved2 = service.RetrieveMultiple(querybyattribute2);

                foreach (var c in retrieved2.Entities)

                // string Queueid = c.Attributes.Contains("queueid").ToString();
                {
                   SenderQueueId = c.GetAttributeValue<System.Guid>("queueid");


                }



                if (senderqueue != null && senderqueue != string.Empty)
                {


                    senderqueueOutput = true;

                }



                if (senderqueueFOC != null && senderqueueFOC != string.Empty)
                {


                    senderqueueOutputFOC = true;

                }







                this.OutSenderSearchFOC.Set(executionContext, senderqueueOutputFOC);

                this.OutSenderSearch.Set(executionContext, senderqueueOutput);

         


            }

            catch (Exception ex)
            {
                Helpers.Throw(String.Format("An error occurred in the {0} Workflow.",
                        this.GetType().ToString()),
                      ex);
            }

        }

        [ReferenceTarget("email")]
        [Input("EmailActivity")]
        public InArgument<EntityReference> EmailActivityLookup { get; set; }

             





        [Output("OutSenderSearch")]
        public OutArgument<bool> OutSenderSearch { get; set; }


        [Output("OutSenderSearchFOC")]
        public OutArgument<bool> OutSenderSearchFOC { get; set; }








     


    }



}