Exemple #1
0
        /// <summary>
        /// Execute Rules
        /// </summary>
        public static IList <FailureMessage> Execute(IEnumerable <PerformanceAdviserRule> rules)
        {
            List <FailureMessage> messages = new List <FailureMessage>();


            var document = DocumentManager.Instance.CurrentDBDocument;

            TransactionManager.Instance.EnsureInTransaction(document);

            PerformanceAdviser adviser = PerformanceAdviser.GetPerformanceAdviser();
            IList <PerformanceAdviserRuleId> rulesIdsToExecute = new List <PerformanceAdviserRuleId>();

            foreach (var rule in rules)
            {
                rulesIdsToExecute.Add(new PerformanceAdviserRuleId(rule.RuleId));
            }

            IList <Autodesk.Revit.DB.FailureMessage> failureMessages = adviser.ExecuteRules(document, rulesIdsToExecute);

            foreach (var message in failureMessages)
            {
                messages.Add(new FailureMessage(message));
            }

            TransactionManager.Instance.TransactionTaskDone();


            return(messages);
        }
Exemple #2
0
        protected override SelectionState PopulateItemsCore(string currentSelection)
        {
            Items.Clear();

            PerformanceAdviser adviser = PerformanceAdviser.GetPerformanceAdviser();
            IList <PerformanceAdviserRuleId> ruleIds = adviser.GetAllRuleIds();
            string ruleInfo = string.Empty;

            List <Revit.Elements.PerformanceAdviserRule> elements = new List <Revit.Elements.PerformanceAdviserRule>();

            foreach (PerformanceAdviserRuleId ruleId in ruleIds)
            {
                elements.Add(new Revit.Elements.PerformanceAdviserRule(ruleId));
            }

            if (!elements.Any())
            {
                Items.Add(new DynamoDropDownItem(Properties.Resources.NoWallTypesAvailable, null));
                SelectedIndex = 0;
                return(SelectionState.Done);
            }

            Items = elements.Select(x => new DynamoDropDownItem(x.Name, x)).OrderBy(x => x.Name).ToObservableCollection();
            return(SelectionState.Restore);
        }
Exemple #3
0
        public static bool GetPurgeableElements(Document doc, List <ElementId> purgeableElementIds)
        {
            var ruleIds = new List <PerformanceAdviserRuleId>();
            var ruleId  = new List <PerformanceAdviserRuleId>();

            if (GetPerformanceAdvisorRuleId(PURGE_GUID, ruleId))
            {
                ruleIds.Add(ruleId[0]);
            }
            else
            {
                return(false); // can't find rule
            }
            // execute our chosen rule
            var failureMessages = new List <FailureMessage>(PerformanceAdviser
                                                            .GetPerformanceAdviser()
                                                            .ExecuteRules(doc, ruleIds));

            try {
                if (failureMessages.Count > 0)
                {
                    // if there are many purgeable elements, we should have a failure message
                    // the failure message should have a collection of failing elements - set to our byref collection
                    purgeableElementIds.AddRange(failureMessages[0].GetFailingElements());
                    // no errors - return true
                }
                return(true);
            }
            catch { }
            return(false);
        }
Exemple #4
0
    public static void Purge(Document doc)
    {
        //The internal GUID of the Performance Adviser Rule
        const string PurgeGuid = "e8c63650-70b7-435a-9010-ec97660c1bda";

        List <PerformanceAdviserRuleId> performanceAdviserRuleIds = new List <PerformanceAdviserRuleId>();

        //Iterating through all PerformanceAdviser rules looking to find that which matches PURGE_GUID
        foreach (PerformanceAdviserRuleId performanceAdviserRuleId in PerformanceAdviser.GetPerformanceAdviser().GetAllRuleIds())
        {
            if (performanceAdviserRuleId.Guid.ToString() == PurgeGuid)
            {
                performanceAdviserRuleIds.Add(performanceAdviserRuleId);
                break;
            }
        }

        //Attempting to recover all purgeable elements and delete them from the document
        List <ElementId> purgeableElementIds = GetPurgeableElements(doc, performanceAdviserRuleIds);

        if (purgeableElementIds != null)
        {
            doc.Delete(purgeableElementIds);
        }
    }
Exemple #5
0
        private static List <PerformanceAdviserRuleId> GetPerfromanceAdviserRuleIdForPurge()
        {
            //The internal GUID of the purge Performance Adviser Rule
            const string purgePerformanceAdviserRuleGuid = "e8c63650-70b7-435a-9010-ec97660c1bda";

            IList <PerformanceAdviserRuleId> performanceAdviserRules  = PerformanceAdviser.GetPerformanceAdviser().GetAllRuleIds();
            List <PerformanceAdviserRuleId>  performanceAdviserRuleId = performanceAdviserRules.Where(x => x.Guid.ToString() == purgePerformanceAdviserRuleGuid).ToList();

            return(performanceAdviserRuleId);
        }
Exemple #6
0
    internal static List <ElementId> GetPurgeableElements(Document doc, List <PerformanceAdviserRuleId> performanceAdviserRuleIds)
    {
        List <FailureMessage> failureMessages = PerformanceAdviser.GetPerformanceAdviser().ExecuteRules(doc, performanceAdviserRuleIds).ToList();

        if (failureMessages.Count > 0)
        {
            List <ElementId> purgeableElementIds = failureMessages[0].GetFailingElements().ToList();
            return(purgeableElementIds);
        }
        return(null);
    }
Exemple #7
0
        private List <Autodesk.Revit.DB.ElementId> GetPurgeableElementIds()
        {
            List <Autodesk.Revit.DB.FailureMessage> failureMessages = PerformanceAdviser.GetPerformanceAdviser()
                                                                      .ExecuteRules(this.InternalDocument, PerformanceAdviserRuleIds)
                                                                      .ToList();

            if (failureMessages.Count > 0)
            {
                List <ElementId> purgeableElementIds = failureMessages[0].GetFailingElements().ToList();
                return(purgeableElementIds);
            }
            return(null);
        }
        public void Get_ValidArgs()
        {
            PerformanceAdviser adviser = PerformanceAdviser.GetPerformanceAdviser();
            IList <PerformanceAdviserRuleId> ruleIds = adviser.GetAllRuleIds();
            var perf = Revit.Elements.PerformanceAdviserRule.ById(ruleIds[0].Guid.ToString());

            Assert.NotNull(perf);

            Assert.NotNull(perf.Description);

            Assert.NotNull(perf.Name);

            Assert.AreEqual(perf.GetType(), typeof(Revit.Elements.PerformanceAdviserRule));
        }
Exemple #9
0
 public static bool GetPerformanceAdvisorRuleId(string guidStr, List <PerformanceAdviserRuleId> ruleId)
 {
     foreach (PerformanceAdviserRuleId rule in PerformanceAdviser
              .GetPerformanceAdviser()
              .GetAllRuleIds())
     {
         // check if the rule Id matches our rule guid
         if (rule.Guid.ToString().Equals(guidStr))
         {
             ruleId.Add(rule); // if it does, assign it
             return(true);
         }
     }
     return(false);
 }
Exemple #10
0
        /// <summary>
        /// Implement this method as an external command for Revit.
        /// </summary>
        /// <param name="commandData">An object that is passed to the external application
        /// which contains data related to the command,
        /// such as the application object and active view.</param>
        /// <param name="message">A message that can be set by the external application
        /// which will be displayed if a failure or cancellation is returned by
        /// the external command.</param>
        /// <param name="elements">A set of elements to which the external application
        /// can add elements that are to be highlighted in case of failure or cancellation.</param>
        /// <returns>Return the status of the external command.
        /// A result of Succeeded means that the API external method functioned as expected.
        /// Cancelled can be used to signify that the user cancelled the external operation
        /// at some point. Failure should be returned if the application is unable to proceed with
        /// the operation.
        /// </returns>
        public Result Execute(ExternalCommandData commandData, ref string message, Autodesk.Revit.DB.ElementSet elements)
        {
            //A list of rule information to be used below
            List <RuleInfo> ruleInfoList = new List <RuleInfo>();

            #region Get Rule info through iteration from PerformanceAdviser

            ///Here, we query the information about rules registered in PerformanceAdviser so that
            ///we can later decide in a dialog which rules we want to run.

            PerformanceAdviser performanceAdviser = PerformanceAdviser.GetPerformanceAdviser();


            ICollection <PerformanceAdviserRuleId> allIds = performanceAdviser.GetAllRuleIds();
            foreach (PerformanceAdviserRuleId ruleID in allIds)
            {
                string ruleName        = performanceAdviser.GetRuleName(ruleID);
                string ruleDescription = performanceAdviser.GetRuleDescription(ruleID);
                bool   isEnabled       = performanceAdviser.IsRuleEnabled(ruleID);

                //We want to mark user-defined (API) rules, so we check to see if the current rule ID is
                //equal to the rule ID we created.
                bool isOurRule = (ruleID == FlippedDoorCheck.Id);

                RuleInfo oneRule = new RuleInfo(ruleID, isOurRule, ruleName, ruleDescription, isEnabled);
                ruleInfoList.Add(oneRule);
            }

            #endregion

            #region Prepare and show UI

            //This dialog box will allow the user to select and run performance rules, so it needs
            //the PerformanceAdviser and active document passed to it.
            TestDisplayDialog tdd = new TestDisplayDialog(PerformanceAdviser.GetPerformanceAdviser(), commandData.Application.ActiveUIDocument.Document);

            foreach (RuleInfo r in ruleInfoList)
            {
                /// Add the rule data we just collected in the previous loop the the dialog box
                /// we are about to show.
                tdd.AddData(r.RuleName, r.IsOurRule, r.IsEnabled);
            }

            tdd.ShowDialog();
            #endregion

            return(Autodesk.Revit.UI.Result.Succeeded);
        }
        public void Execute_ValidResult()
        {
            PerformanceAdviser adviser = PerformanceAdviser.GetPerformanceAdviser();
            IList <PerformanceAdviserRuleId> ruleIds = adviser.GetAllRuleIds();
            var perf = Revit.Elements.PerformanceAdviserRule.ById(ruleIds[0].Guid.ToString());
            List <Revit.Elements.PerformanceAdviserRule> rules = new List <Revit.Elements.PerformanceAdviserRule>()
            {
                perf
            };

            var messages = Revit.Elements.PerformanceAdviserRule.Execute(rules);

            foreach (var msg in messages)
            {
                Assert.IsTrue(msg.GetType() == typeof(Revit.Elements.FailureMessage));
                Assert.IsNotNull(msg.Description);
                Assert.IsNotNull(msg.Severity);
            }
        }
        private void PurgeDocument(Document doc)
        {
            Guid guid = new Guid("e8c63650-70b7-435a-9010-ec97660c1bda");

            var performanceAdviser = PerformanceAdviser.GetPerformanceAdviser();

            List <PerformanceAdviserRuleId> ruleId = new List <PerformanceAdviserRuleId>();

            var allRuleIds = performanceAdviser.GetAllRuleIds();

            foreach (var r in allRuleIds)
            {
                if (r.Guid == guid)
                {
                    ruleId.Add(r);
                }
            }

            for (int i = 0; i < 3; i++)
            {
                var failureMessages = performanceAdviser.ExecuteRules(doc, ruleId);

                if (failureMessages.Count > 0)
                {
                    var purgableElementIds = failureMessages[0].GetFailingElements();

                    foreach (ElementId id in purgableElementIds)
                    {
                        if (doc.GetElement(id) != null)
                        {
                            try
                            {
                                doc.Delete(id);
                            }
                            catch { }
                        }
                    }
                }
            }
        }
        public static bool GetPurgableElementTypes(this Document doc, out ICollection <ElementId> purgableTypeIds)
        {
            try
            {
                using (var adviser = PerformanceAdviser.GetPerformanceAdviser())
                {
                    var rules = adviser.GetAllRuleIds().Where(x => x.Guid == PurgePerformanceAdviserRuleId).ToList();
                    if (rules.Count > 0)
                    {
                        var results = adviser.ExecuteRules(doc, rules);
                        if (results.Count > 0)
                        {
                            purgableTypeIds = new HashSet <ElementId>(results[0].GetFailingElements());
                            return(true);
                        }
                    }
                }
            }
            catch (Autodesk.Revit.Exceptions.InternalException) { }

            purgableTypeIds = default;
            return(false);
        }
Exemple #14
0
        public override string ToString()
        {
            PerformanceAdviser adviser = PerformanceAdviser.GetPerformanceAdviser();

            return(string.Format("{0} : {1}", adviser.GetRuleName(this.InternalId), adviser.GetRuleDescription(this.InternalId)));
        }