IfcDoc.DocumentationISO.FormatConceptTable C# (CSharp) Method

        private static string FormatConceptTable(
            DocProject docProject,
            DocModelView docModelView,
            DocEntity entity,
            DocConceptRoot root,
            DocTemplateUsage usage,
            Dictionary<string, DocObject> mapEntity,
            Dictionary<string, string> mapSchema)
        {
            StringBuilder sb = new StringBuilder();

            DocTemplateDefinition docTemplate = null;
            DocTemplateItem[] listItems = null;
            if (usage != null)
            {
                docTemplate = usage.Definition;
                listItems = FindTemplateItems(docProject, entity, usage.Definition, docModelView);

                if (usage.Override)
                {
                    listItems = usage.Items.ToArray();
                }

                if (listItems.Length == 0)
                {
                    // scenario for referenced inner templates
                    listItems = usage.Items.ToArray();
                }
            }
            else
            {
                docTemplate = root.ApplicableTemplate;
                listItems = root.ApplicableItems.ToArray();
            }

            // new way with table
            DocModelRule[] parameters = docTemplate.GetParameterRules();
            if (parameters != null && parameters.Length > 0 && listItems.Length > 0)
            {
                // check if descriptions are provided
                bool showdescriptions = false;
                foreach (DocTemplateItem item in listItems)
                {
                    if (item.Documentation != null)
                    {
                        showdescriptions = true;
                        break;
                    }
                }

                sb.AppendLine("<table class=\"gridtable\">");

                // header
                sb.Append("<tr>");
                foreach (DocModelRule parameter in parameters)
                {
                    sb.Append("<th><b>");

                    // hack until fixed in data
                    if (parameter.Identification.Equals("Name") && docTemplate.Name.Equals("External Data Constraints"))
                    {
                        sb.Append("Column");
                    }
                    else
                    {
                        sb.Append(parameter.Identification);
                    }
                    sb.Append("</b></th>");
                }
                if (showdescriptions)
                {
                    sb.Append("<th><b>Description</b></th>");
                }
                sb.AppendLine("</tr>");

                // items
                foreach (DocTemplateItem item in listItems)
                {
                    sb.Append("<tr>");
                    foreach (DocModelRule parameter in parameters)
                    {
                        string value = item.GetParameterValue(parameter.Identification);
                        string schema = null;

                        sb.Append("<td>");
                        //if (value != null)
                        {
                            DocDefinition docDef = docTemplate.GetParameterType(parameter.Identification, mapEntity);
                            if (docDef is DocEnumeration)
                            {
                                if(value != null)
                                {
                                    schema = mapSchema[docDef.Name];

                                    sb.Append("<a href=\"../../");
                                    sb.Append(schema.ToLower());
                                    sb.Append("/lexical/");
                                    sb.Append(docDef.Name.ToLower());
                                    sb.Append(".htm\">");
                                    sb.Append(value);
                                    sb.Append("</a>");
                                }
                            }
                            else if (docDef is DocEntity && docDef.Name.Equals("IfcReference"))
                            {
                                // ...hyperlinks
                                if (value != null)
                                {
                                    string reftext = FormatReference(docProject, value);
                                    sb.Append(reftext);
                                }
                                //sb.Append(value);
                            }
                            else if (docDef is DocEntity)
                            {
                                DocTemplateDefinition docTemplateInner = null;
                                if (parameter is DocModelRuleAttribute)
                                {
                                    List<string> cols = new List<string>();
                                    List<DocTemplateItem> rows = new List<DocTemplateItem>();
                                    List<DocTemplateUsage> usages = new List<DocTemplateUsage>();

                                    DocModelRuleAttribute dma = (DocModelRuleAttribute)parameter;
                                    foreach(DocModelRule docInnerRule in dma.Rules)
                                    {
                                        if (docInnerRule is DocModelRuleEntity)
                                        {
                                            DocModelRuleEntity dme = (DocModelRuleEntity)docInnerRule;
                                            if (dme.References.Count == 1)
                                            {
                                                docTemplateInner = dme.References[0];

                                                // new: combine nested tables -- properties are shown together

                                                DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
                                                if (docConceptInner != null)
                                                {
                                                    DocModelRule[] innerparameters = docTemplateInner.GetParameterRules();
                                                    foreach (DocModelRule innerparam in innerparameters)
                                                    {
                                                        if (!cols.Contains(innerparam.Identification))
                                                        {
                                                            cols.Add(innerparam.Identification);
                                                        }
                                                    }

                                                    foreach(DocTemplateItem docItemInner in docConceptInner.Items)
                                                    {
                                                        string orderstr = docItemInner.GetParameterValue("Order");
                                                        int ordernum;
                                                        if(!String.IsNullOrEmpty(orderstr) && Int32.TryParse(orderstr, out ordernum))
                                                        {
                                                            while (rows.Count < ordernum)
                                                            {
                                                                rows.Add(null);
                                                                usages.Add(null);
                                                            }

                                                            rows[ordernum - 1] = docItemInner;
                                                            usages[ordernum - 1] = docConceptInner;
                                                        }
                                                    }
                                                }

                                                //break;

                                                /*
                                                DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
                                                if (docConceptInner != null)
                                                {
                                                    string inner = FormatConceptTable(docProject, docModelView, (DocEntity)docDef, root, docConceptInner, mapEntity, mapSchema);
                                                    sb.Append("<a href=\"../../templates/" + MakeLinkName(docTemplateInner) + ".htm\">" + docTemplateInner.Name + "</a><br/>");
                                                    sb.Append(inner);
                                                }
                                                */
                                            }
                                        }
                                    }

                                    if(rows.Count > 0)
                                    {
                                        sb.Append("<table class=\"gridtable\"><tr>");
                                        sb.Append("<th>Template</th>");
                                        foreach(string colname in cols)
                                        {
                                            sb.Append("<th>");
                                            sb.Append(colname);
                                            sb.Append("</th>");
                                        }
                                        sb.AppendLine("</tr>");

                                        for (int iSubRow = 0; iSubRow < rows.Count; iSubRow++ )
                                        {
                                            DocTemplateItem docItem = rows[iSubRow];
                                            DocTemplateUsage docUsage = usages[iSubRow];

                                            //todo: show template with link... define icon at template...
                                            if (docItem != null)
                                            {
                                                sb.Append("<tr>");
                                                sb.Append("<td><a href=\"../../templates/");
                                                sb.Append(MakeLinkName(docUsage.Definition));
                                                sb.Append(".htm\">");
                                                sb.Append(docUsage.Definition.Name);
                                                sb.Append("</a></td>");
                                                foreach (string colname in cols)
                                                {
                                                    string pval = docItem.GetParameterValue(colname);
                                                    pval = FormatField(docProject, pval, pval, pval, pval);

                                                    sb.Append("<td>");
                                                    sb.Append(pval);
                                                    sb.Append("</td>");
                                                }
                                                sb.AppendLine("</tr>");
                                            }
                                        }

                                        sb.Append("</table>");
                                    }
                                }

                                if (docTemplateInner == null && value != null && mapSchema.TryGetValue(value, out schema))
                                {
                                    sb.Append("<a href=\"../../");
                                    sb.Append(schema.ToLower());
                                    sb.Append("/lexical/");
                                    sb.Append(value.ToLower());
                                    sb.Append(".htm\">");
                                    sb.Append(value);
                                    sb.Append("</a>");
                                }
                                else if(value != null)
                                {
                                    sb.Append(value);
                                }
                            }
                            else if (docDef != null && value != null)
                            {
                                value = FormatField(docProject, value, value, docDef.Name, value);
                                sb.Append(value);
                            }
                            else if (value != null)
                            {
                                sb.Append(value);
                            }
                            else
                            {
                                sb.Append("&nbsp;");
                            }
                        }
                        sb.Append("</td>");
                    }

                    if (showdescriptions)
                    {
                        sb.Append("<td>");
                        if (item.Documentation != null)
                        {
                            sb.Append(item.Documentation);
                        }
                        else
                        {
                            sb.Append("&nbsp;");
                        }
                        sb.Append("</td>");
                    }

                    sb.AppendLine("</tr>");
                }

                sb.AppendLine("</table>");
            }
            return sb.ToString();
        }