CRM 2011 Opportunity Bug

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using app.Crm;
using apollo.Crm.Security;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using Microsoft.Crm.Sdk.Messages;

namespace apollo.Crm.Plugin.Security
{
    /// <summary>
    /// Applies the default share state to an entity record. Relies on the following configuration settings:
    /// - DefaultShare - Global, BusinessUnitHierarchy, BusinessUnit,
    /// <settings>
    ///     <setting name="DefaultShare">
    ///         <value>BusinessUnitHierarchy</value>
    ///     </setting>
    /// </settings>
    /// This plugin should be registered with a PostImage called Target.
    /// </summary>
    public class GranularSecurity
        : IPlugin
    {
        #region ---------------------------------------- Constructor ------------------------------------------------
        public GranularSecurity(string config, string secureConfig)
        {
            this.Configuration = new app.Crm.Configuration.Plugin(config);
            this.SecureConfiguration = new app.Crm.Configuration.Plugin(secureConfig);
        }
        #endregion
        #region ---------------------------------------- Properties -------------------------------------------------
        public app.Crm.Configuration.Plugin Configuration
        { get; set; }
        public app.Crm.Configuration.Plugin SecureConfiguration
        { get; set; }
        #endregion
        #region ---------------------------------------- Methods ----------------------------------------------------
        public void Execute(IServiceProvider serviceProvider)
        {
            try
            {
                // Obtain the execution context from the service provider.
                IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
                // Get a reference to the Organization service.
                IOrganizationServiceFactory factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
                IOrganizationService service = factory.CreateOrganizationService(context.UserId);
                EntityReference entity = new EntityReference(context.PrimaryEntityName, context.PrimaryEntityId);
                if ((context.MessageName.Equals("Create") || context.MessageName.Equals("Update") || context.MessageName.Equals("Assign")) && !context.SharedVariables.Contains("GranularSecurity"))
                {
                    app.Crm.Configuration.AppSettings.GetInstance().Context.ApplyNew();
                    // Used to determine if the plugin has been called within the current execution context
                    context.SharedVariables.Add("GranularSecurity", true);
                    Common.LogTrace(string.Format("Executing GranularSecurity plugin for {2} of {0} entity id {1}.", context.PrimaryEntityName, context.PrimaryEntityId, context.MessageName));
                    // Get Input Parameters
                    Entity input = null;
                    if (context.MessageName != "Assign") input = (Entity)context.InputParameters["Target"];
                    // Get Post Image
                    Entity postImage = (Entity)context.PostEntityImages["Target"];
                    // Get Pre Image if available
                    Entity preImage = null;
                    if (context.MessageName.Equals("Assign") || context.MessageName.Equals("Update")) preImage = (Entity)context.PreEntityImages["Target"];
                    if (context.PrimaryEntityName == "opportunity")
                    {
                        applyGranularSecurity(service, entity, input, preImage, postImage, context.MessageName);
                    }
                    else //if ((context.MessageName.Equals("Create") || context.MessageName.Equals("Assign")) && (context.PrimaryEntityName == "quote" || context.PrimaryEntityName == "salesorder"))
                    {
                        applyParentalSecurity(service, entity, postImage);
                    }
                }
            }
            catch (Exception ex)
            {
                Common.LogException(ex);
                throw;
            }
        }

        /// <summary>
        /// Applies granular security to a record based on secure record attributes and plugin configuration.
        /// See opportunity for an example.
        /// </summary>
        /// <param name="service"></param>
        /// <param name="entity"></param>
        /// <param name="input"></param>
        /// <param name="preImage"></param>
        /// <param name="postImage"></param>
        private void applyGranularSecurity(IOrganizationService service, EntityReference entity, Entity input, Entity preImage, Entity postImage, string messageName)
        {
            // Get the record owner
            DataLayer.SystemUser owner = new DataLayer.SystemUser(service, postImage.GetAttributeValue<EntityReference>("ownerid").Id);
            // Has the record security status changed?
            // NB. Even if the attribute has not changed it is being included in the input attributes 
            // --> pre image hack is to work around this.
            if (secureStatusHasChanged(input, preImage))
            {
                // Apply Security Settings
                if (input.GetAttributeValue<bool>("app_securityfirewalled") != true)
                {
                    SecurityUtility.ApplyCascadeDefaultShares(service, Configuration, entity, owner);
                }
                else
                {
                    SecurityUtility.RemoveCascadeAllShares(service, entity, owner);
                    // Now ensure that the record is still visible to management
                    if (postImage.GetAttributeValue<bool>("app_securityvisibletomanagement") == true)
                    {
                        SecurityUtility.ApplyCascadeManagementShare(service, entity, owner);
                    }
                }
            }
            else if (visibleToManagementStatusHasChanged(input, preImage))
            {
                // The visible to managment status has changed but only apply management 
                // shares though if the record is secure.
                if (postImage.GetAttributeValue<bool>("app_securityfirewalled") == true)
                {
                    if (input.GetAttributeValue<bool>("app_securityvisibletomanagement") == true)
                    {
                        SecurityUtility.ApplyCascadeManagementShare(service, entity, owner);
                    }
                    else
                    {
                        SecurityUtility.RemoveCascadeManagementShare(service, entity, owner);
                    }
                }
            }
            else if (messageName.Equals("Assign"))
            {
                // cascade re-assign to quotes, orders
                SecurityUtility.CascadeAssign(service, entity, owner);
                // remove all current shares
                SecurityUtility.RemoveCascadeAllShares(service, entity, owner);
                // apply shares
                if (postImage.GetAttributeValue<bool>("app_securityfirewalled") == true)
                {
                    if (postImage.GetAttributeValue<bool>("app_securityfirewalled") == true)
                    {
                        // apply management share if required
                        SecurityUtility.ApplyCascadeManagementShare(service, entity, owner);
                    }
                }
                else
                {
                    // apply default shares
                    SecurityUtility.ApplyCascadeDefaultShares(service, Configuration, entity, owner);
                }
            }
        }
        private void applyParentalSecurity(IOrganizationService service, EntityReference entity, Entity postImage)
        {
            if (postImage.GetAttributeValue<EntityReference>("opportunityid") != null)
            {
                // Cascade parental shares where the record has an opportunity id
                DataLayer.Opportunity opportunity = new DataLayer.Opportunity(service, postImage.GetAttributeValue<EntityReference>("opportunityid").Id);
                if (!opportunity.IsSecureRecord)
                {
                    SecurityUtility.ApplyDefaultShares(service, Configuration, entity, opportunity.Owner);
                }
                else if (opportunity.IsSecureRecord && opportunity.IsVisibleToManagement)
                {
                    SecurityUtility.ApplyManagementShare(service, entity, opportunity.Owner);
                }
            }
            else
            {
                // If the record is owned by a user -> Apply Default Shares
                if (postImage.GetAttributeValue<int>("owneridtype") == 8)
                {
                    DataLayer.SystemUser owner = new DataLayer.SystemUser(service, postImage.GetAttributeValue<Guid>("ownerid"));
                    SecurityUtility.ApplyDefaultShares(service, Configuration, entity, owner);
                }
            }
        }
        /// <summary>
        /// Compares the input parameters to the pre image to determine if the value has changed.
        /// This should not be necessary but is required as Opportunity is including parameters 
        /// that have not changed in the inputparameters. 
        /// <param name="opportunityInput"></param>
        /// <param name="opportunityPreImage"></param>
        /// <returns></returns>
        private bool secureStatusHasChanged(Entity opportunityInput, Entity opportunityPreImage)
        {
            bool retVal = false;
            if (opportunityInput != null)
            {
                if (opportunityInput.Attributes.Contains("app_securityfirewalled"))
                {
                    if (opportunityPreImage == null)
                    {
                        retVal = true;
                    }
                    else
                    {
                        if (opportunityPreImage.GetAttributeValue<bool>("app_securityfirewalled") != opportunityInput.GetAttributeValue<bool>("app_securityfirewalled"))
                        {
                            retVal = true;
                        }
                    }
                }
            }
            return retVal;
        }
        /// <summary>
        /// Compares the input parameters to the pre image to determine if the value has changed.
        /// This should not be necessary but is required as Opportunity is including parameters 
        /// that have not changed in the inputparameters. #DodgyJavascript
        /// </summary>
        /// <param name="opportunityInput"></param>
        /// <param name="opportunityPreImage"></param>
        /// <returns></returns>
        private bool visibleToManagementStatusHasChanged(Entity opportunityInput, Entity opportunityPreImage)
        {
            bool retVal = false;
            if (opportunityInput != null)
            {
                if (opportunityInput.Attributes.Contains("app_securityvisibletomanagement"))
                {
                    if (opportunityPreImage == null)
                    {
                        retVal = true;
                    }
                    else
                    {
                        if (opportunityPreImage.GetAttributeValue<bool>("app_securityvisibletomanagement") != opportunityInput.GetAttributeValue<bool>("app_securityvisibletomanagement"))
                        {
                            retVal = true;
                        }
                    }
                }
            }
            return retVal;
        }
        #endregion
    }
}

Select allOpen in new window