Example #1
0
        private void CreateSummaryFile()
        {
            XmlNode     node;
            XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.SUMMARY_XSLT_FILE, "Summary", out node);

            doc.AppendChild(XmlFactory.CreateSummaryXmlNode(doc, node));
            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.SUMMARY_FILE), doc);
        }
Example #2
0
        private void CreateInfofWarnCritFatalMatchesFile()
        {
            IMatchProxy matchProxy = ProxyHome.Instance.RetrieveMatchProxy(OutputKeyKeeper.Instance.AccessKey);

            XmlNode infoNode;
            XmlNode warningNode;
            XmlNode criticalNode;
            XmlNode fatalNode;

            XmlDocument infoDoc     = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_MATCHES_XSLT_FILE, "Matches", out infoNode);
            XmlDocument warningDoc  = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_MATCHES_XSLT_FILE, "Matches", out warningNode);
            XmlDocument criticalDoc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_MATCHES_XSLT_FILE, "Matches", out criticalNode);
            XmlDocument fatalDoc    = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_MATCHES_XSLT_FILE, "Matches", out fatalNode);

            infoDoc.AppendChild(infoNode);
            warningDoc.AppendChild(warningNode);
            criticalDoc.AppendChild(criticalNode);
            fatalDoc.AppendChild(fatalNode);

            // <Matches>
            //   <Match />
            // </Matches>
            int num = 1;

            foreach (IMatch match in matchProxy.Matches())
            {
                if (match.Severity == RuleSeverity.Info)
                {
                    infoNode.AppendChild(XmlFactory.CreateMatchXmlNode(infoDoc, num++, match));
                }

                if (match.Severity == RuleSeverity.Warning)
                {
                    warningNode.AppendChild(XmlFactory.CreateMatchXmlNode(warningDoc, num++, match));
                }

                if (match.Severity == RuleSeverity.Critical)
                {
                    criticalNode.AppendChild(XmlFactory.CreateMatchXmlNode(criticalDoc, num++, match));
                }

                if (match.Severity == RuleSeverity.Fatal)
                {
                    fatalNode.AppendChild(XmlFactory.CreateMatchXmlNode(fatalDoc, num++, match));
                }
            }

            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_INFO_MATCHES_XML_FILE), infoDoc);
            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_WARNING_MATCHES_XML_FILE), warningDoc);
            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_CRITICAL_MATCHES_XML_FILE), criticalDoc);
            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_FATAL_MATCHES_XML_FILE), fatalDoc);
        }
Example #3
0
        private void CreateCategoryDeclarationFile()
        {
            IConfigurationProxy proxy = ProxyHome.Instance.RetrieveConfigurationProxy(OutputKeyKeeper.Instance.AccessKey);

            XmlNode     node;
            XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_CATEGORY_DECLARATIONS_XSLT_FILE, "CategoryDeclarations", out node);

            // <CategoryDeclarations>
            //   <CategoryDeclaration />
            // </CategoryDeclarations>
            foreach (KeyValuePair <int, ICategoryDeclaration> pair in proxy.CategoryDeclarations())
            {
                node.AppendChild(XmlFactory.CreateCategoryDeclarationXmlNode(doc, pair.Value));
                doc.AppendChild(node);
            }

            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_CATEGORY_DECLARATIONS_XML_FILE), doc);
        }
Example #4
0
        private void CreateProjectDefinitionsFile()
        {
            IConfigurationProxy proxy = ProxyHome.Instance.RetrieveConfigurationProxy(OutputKeyKeeper.Instance.AccessKey);

            XmlNode     node;
            XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_PROJECT_DEFINITIONS_XSLT_FILE, "ProjectDefinitions", out node);

            //<ProjectDefinitions>
            //  <ProjectDefinition />
            //</ProjectDefinitions>
            foreach (KeyValuePair <int, IProjectDefinition> pair in proxy.Projects())
            {
                IProjectDefinition project = pair.Value;

                node.AppendChild(XmlFactory.CreateProjectDefinitionXmlNode(doc, project));
                doc.AppendChild(node);
            }

            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_PROJECT_DEFINITIONS_XML_FILE), doc);
        }
Example #5
0
        private void CreateAllMatchesFile()
        {
            IMatchProxy matchProxy = ProxyHome.Instance.RetrieveMatchProxy(OutputKeyKeeper.Instance.AccessKey);

            XmlNode     node;
            XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_MATCHES_XSLT_FILE, "Matches", out node);


            // <Matches>
            //   <Match />
            // </Matches>
            int num = 1;

            foreach (IMatch match in matchProxy.Matches())
            {
                node.AppendChild(XmlFactory.CreateMatchXmlNode(doc, num++, match));
            }
            doc.AppendChild(node);

            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_MATCHES_XML_FILE), doc);
        }
Example #6
0
        private void CreateRuleDefinitionsFile()
        {
            IConfigurationProxy proxy = ProxyHome.Instance.RetrieveConfigurationProxy(OutputKeyKeeper.Instance.AccessKey);

            XmlNode     node;
            XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_RULE_DEFINITIONS_XSLT_FILE, "RuleDefinitions", out node);

            //<RuleDefinitions>
            //  <RuleDefinition />
            //</RuleDefinitions>
            foreach (KeyValuePair <int, IProjectDefinition> projectDefinition in proxy.Projects())
            {
                foreach (KeyValuePair <int, IRuleDefinition> pair in proxy.ProjectRules(projectDefinition.Value.Id))
                {
                    IRuleDefinition ruleDefinition = pair.Value;

                    IRuleDeclaration ruleDeclaration = proxy.RuleDeclarationFromRuleId(ruleDefinition.RuleDeclarationReferenceId);
                    node.AppendChild(XmlFactory.CreateRuleDefinitionXmlNode(doc, ruleDeclaration, ruleDefinition));
                    doc.AppendChild(node);
                }
            }

            XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_RULE_DEFINITIONS_XML_FILE), doc);
        }