public AttributeManagerPlugin()
        {
            InitializeComponent();
            Publishers = new List<Publisher>();
            LocalOptions = new List<OptionMetadata>();

            StepMapper = new Dictionary<string, Logic.Steps>
            {
                {"Create Temporary Attribute", Logic.Steps.CreateTemp},
                {"Migrate to Temporary Attribute", Logic.Steps.MigrateToTemp},
                {"Remove Existing Attribute", Logic.Steps.RemoveExistingAttribute},
                {"Create New Attribute", Logic.Steps.CreateNewAttribute},
                {"Migrate to New Attribute", Logic.Steps.MigrateToNewAttribute},
                {"Remove Temporary Attribute", Logic.Steps.RemoveTemp}
            };

            DefaultSteps = StepMapper.Keys.Cast<object>().ToArray();

            RenameSteps = new object[]
            {
                StepMapper.First(p => p.Value == Logic.Steps.CreateNewAttribute).Key,
                StepMapper.First(p => p.Value == Logic.Steps.MigrateToNewAttribute).Key,
                StepMapper.First(p => p.Value == Logic.Steps.RemoveExistingAttribute).Key
            };

            DeleteSteps = new object[]
            {
                StepMapper.First(p => p.Value == Logic.Steps.RemoveExistingAttribute).Key
            };

            cmbNewAttributeType.Visible = false;
            SetTabVisible(tabStringAttribute, false);
            SetTabVisible(tabNumberAttribute, false);
            SetTabVisible(tabOptionSetAttribute, false);

            SetCurrencyNumberVisible(false);
            SetDecimalNumberVisible(false);
            SetWholeNumberVisible(false);
            SetFloatNumberVisible(false);
            numAttFormatCmb.SelectedIndex = 0;
        }
        private void AssertCanDelete(IOrganizationService service, AttributeMetadata attribute)
        {
            Trace("Checking for Delete Dependencies for " + attribute.EntityLogicalName + "." + attribute.LogicalName);
            var depends = (RetrieveDependenciesForDeleteResponse)service.Execute(new RetrieveDependenciesForDeleteRequest
            {
                ComponentType = (int)componenttype.Attribute,
                ObjectId = attribute.MetadataId.GetValueOrDefault()
            });

            var errors = new List<string>();
            foreach (var d in depends.EntityCollection.ToEntityList<Dependency>())
            {
                var type = (componenttype)d.DependentComponentType.GetValueOrDefault();
                var dependentId = d.DependentComponentObjectId.GetValueOrDefault();
                var err = type + " " + dependentId;
                switch (type) {
                    case componenttype.EntityRelationship:
                        var response =
                            (RetrieveRelationshipResponse)service.Execute(new RetrieveRelationshipRequest { MetadataId = dependentId });
                        Trace("Entity Relationship {0} must be manually removed/added", response.RelationshipMetadata.SchemaName);
                        break;
                    case componenttype.SavedQueryVisualization:
                        var sqv = service.GetEntity<SavedQueryVisualization>(dependentId);
                            err = $"{err} ({sqv.Name} - {sqv.CreatedBy.Name})";
                        break;

                    case componenttype.SavedQuery:
                        var sq = service.GetEntity<SavedQuery>(dependentId);
                            err = $"{err} ({sq.Name} - {sq.CreatedBy.Name})";
                        break;
                }

                errors.Add(err);
            }

            if (errors.Count > 0)
            {
                throw new Exception("Dependencies found: " + Environment.NewLine + "\t" + string.Join(Environment.NewLine + "\t", errors));
            }
        }
        private void AssertCanDelete(IOrganizationService service, AttributeMetadata attribute)
        {
            Trace("Checking for Delete Dependencies for " + attribute.EntityLogicalName + "." + attribute.LogicalName);
            var depends = (RetrieveDependenciesForDeleteResponse)service.Execute(new RetrieveDependenciesForDeleteRequest
            {
                ComponentType = (int)componenttype.Attribute,
                ObjectId = attribute.MetadataId.GetValueOrDefault()
            });

            var errors = new List<string>();
            foreach (var d in depends.EntityCollection.ToEntityList<Dependency>())
            {
                var type = (componenttype)d.DependentComponentType.GetValueOrDefault();
                errors.Add(type + " " + d.DependentComponentObjectId.GetValueOrDefault());
                if (type == componenttype.EntityRelationship)
                {
                    var response =
                        (RetrieveRelationshipResponse)service.Execute(new RetrieveRelationshipRequest { MetadataId = d.DependentComponentObjectId.GetValueOrDefault() });
                    Trace("Entity Relationship {0} must be manually removed/added", response.RelationshipMetadata.SchemaName);
                }
            }

            if (errors.Count > 0)
            {
                throw new Exception("Dependencies found: " + string.Join(", ", errors));
            }
        }