@elisra-devops/docgen-skins 0.3.3

package/src/models/json/JSONRun.ts

@@ -0,0 +1,80 @@
+import { Run, WIProperty, StyleOptions } from "./wordJsonModels";
+import { defaultJsonRun } from "./default";
+import striphtml from "string-strip-html";
+import logger from "../../services/logger";
+
+const replaceBr = ({ tag, deleteFrom, deleteTo, rangesArr }) => {
+  if (tag.name === `br`) {
+    rangesArr.push(deleteFrom, deleteTo, "\n");
+  } else {
+    rangesArr.push(deleteFrom, deleteTo, " ");
+  }
+};
+
+export default class JSONRun {
+  runs: Run[];
+
+  constructor(value: string, styles: StyleOptions, fieldtype?: string) {
+    this.runs = this.generateJsonRun(value, styles, fieldtype);
+  } //constructor
+
+  generateJsonRun(value: string, style: StyleOptions, fieldtype?: string): Run[] {
+    let runs: Run[] = [];
+    let rowArray;
+    try {
+      rowArray = value.split("\n");
+      //try iterating the array
+      rowArray.forEach((text, i) => {
+        let run: Run = defaultJsonRun;
+        if (fieldtype !== "SuiteHeaderParagraphTitle") {
+          text = `${striphtml(text.toString(), { cb: replaceBr })}` || "";
+      }
+        run.text = text;
+        run.Bold = style.isBold;
+        run.Italic = style.IsItalic;
+        run.Underline = style.IsUnderline;
+        run.Size = style.Size;
+        if (run.Uri === "") {
+          run.Uri = null;
+        } else {
+          run.Uri = style.Uri;
+        }
+        run.Font = style.Font;
+        if (rowArray.length == 1) {
+          run.InsertLineBreak = style.InsertLineBreak;
+        } else {
+          run.InsertLineBreak = false;
+        }
+        if (rowArray.length - 1 == i) {
+          run.InsertLineBreak = style.InsertLineBreak;
+        }
+        run.InsertSpace = style.InsertSpace;
+        runs.push(JSON.parse(JSON.stringify(run)));
+      });
+    } catch (e) {
+      logger.silly(`${value} - cannot be splitted`);
+      runs[0] = defaultJsonRun;
+      runs[0].text = value
+        ? `${striphtml(value.toString(), { cb: replaceBr })}`
+        : ``;
+      runs[0].Bold = style.isBold;
+      runs[0].Italic = style.IsItalic;
+      runs[0].Underline = style.IsUnderline;
+      runs[0].Size = style.Size;
+      if (runs[0].Uri === "") {
+        runs[0].Uri = null;
+      } else {
+        runs[0].Uri = style.Uri;
+      }
+      runs[0].Font = style.Font;
+      runs[0].InsertLineBreak = style.InsertLineBreak;
+      runs[0].InsertSpace = style.InsertSpace;
+    }
+
+    return runs;
+  } //generateJsonRun
+
+  getRun(): Run[] {
+    return this.runs;
+  }
+} //class

package/src/models/json/default.ts

@@ -0,0 +1,24 @@
+import { Run, StyleOptions } from "./wordJsonModels";
+
+export let defaultJsonRun: Run = {
+  text: ``,
+  Bold: false,
+  Italic: false,
+  Underline: false,
+  Size: 12,
+  Uri: null,
+  Font: "Arial",
+  InsertLineBreak: false,
+  InsertSpace: true
+};
+
+export let DescriptionandProcedureStyle: StyleOptions = {
+  isBold: true,
+  IsItalic: false,
+  IsUnderline: true,
+  Size: 12,
+  Uri: null,
+  Font: "Arial",
+  InsertLineBreak: false,
+  InsertSpace: false,
+};

package/src/models/json/html/JSONHtml.ts

@@ -0,0 +1,13 @@
+import { JsonHtml } from "../wordJsonModels";
+import JSONRun from "../JSONRun";
+
+export default class JSONHtml {
+  htmlString: string = "";
+  constructor(htmlString: string) {
+    this.htmlString = htmlString;
+  } //constructor
+
+  getJSONHtml(): JsonHtml {
+    return { type: "html", Html: this.htmlString };
+  } //getJSONTable
+} //class

package/src/models/json/paragraph/JSONParagraph.ts

@@ -0,0 +1,76 @@
+import {
+  Paragraph,
+  Run,
+  WIData,
+  WIProperty,
+  StyleOptions,
+} from "../wordJsonModels";
+import JSONRun from "../JSONRun";
+
+export default class JSONParagraph {
+  paragraphStyles: StyleOptions;
+  paragraphTemplate: Paragraph;
+  wiId: number;
+  constructor(
+    field: WIProperty,
+    paragraphStyles: StyleOptions,
+    wiId: number,
+    headingLevel: number
+  ) {
+    this.paragraphStyles = paragraphStyles;
+    this.wiId = wiId;
+    this.paragraphTemplate = {
+      type: "paragraph",
+      runs: this.generateJsonParagraphRun(field, this.paragraphStyles),
+    };
+    if (headingLevel && field.name === "Title: ") {
+      this.paragraphTemplate.headingLevel = headingLevel;
+    } else {
+      this.paragraphTemplate.headingLevel = 0;
+    }
+  } //constructor
+
+  generateJsonParagraphRun(field: WIProperty, paragraphStyles): Run[] {
+    let jsonRun: JSONRun;
+    let runs: Run[] = [];
+    let titleStyle = JSON.parse(JSON.stringify(paragraphStyles));
+
+    titleStyle.isBold = false;
+    titleStyle.IsUnderline = true;
+    titleStyle.InsertSpace = true;
+    titleStyle.InsertLineBreak = false;
+    //adds ':' to field titles
+    if (field.name !== "") {
+      field.name += ": ";
+    }
+    //exclude titles for fields that only show values
+    if (
+      field.name !== "Title: " &&
+      field.name !== "ID: " &&
+      field.name !== "Description: " &&
+      field.name !== "text: "
+    ) {
+      paragraphStyles.Uri = field.url;
+      jsonRun = new JSONRun(field.name, titleStyle);
+      runs = [...runs, ...jsonRun.runs];
+
+      paragraphStyles.InsertLineBreak = false;
+    } //end if
+
+    if (field.name === "Title: ") {
+      paragraphStyles.Uri = field.url;
+      paragraphStyles.InsertLineBreak = false;
+      jsonRun = new JSONRun(field.value, paragraphStyles);
+      runs = [...runs, ...jsonRun.runs];
+    } else {
+      paragraphStyles.Uri = field.url;
+      jsonRun = new JSONRun(field.value, paragraphStyles);
+      runs = [...runs, ...jsonRun.runs];
+    }
+    return runs;
+  } //generateJsonParagraph
+
+  getJSONParagraph(): Paragraph {
+    return this.paragraphTemplate;
+  } //getJSONTable
+} //class

package/src/models/json/paragraph/JSONRichTextParagraph.ts

@@ -0,0 +1,84 @@
+import { Run, WIProperty, StyleOptions } from "../wordJsonModels";
+import JSONHtml from "../html/JSONHtml";
+import JSONParagraph from "./JSONParagraph";
+import JSONTable from "../table/JSONTable";
+import logger from "../../../services/logger";
+
+export default class JSONRichTextParagraph {
+  paragraphStyles: StyleOptions;
+  paragraphTemplate: any;
+  wiId: number;
+  constructor(
+    field: WIProperty,
+    paragraphStyles: StyleOptions,
+    wiId: number,
+    headingLevel: number
+  ) {
+    this.paragraphStyles = paragraphStyles;
+    this.wiId = wiId;
+    this.paragraphTemplate = this.generateJsonRichTextParagraphs(
+      field,
+      this.paragraphStyles
+    );
+    if (headingLevel && field.name === "Title: ") {
+      this.paragraphTemplate.headingLevel = headingLevel;
+    } else {
+      this.paragraphTemplate.headingLevel = 0;
+    }
+  } //constructor
+
+  generateJsonRichTextParagraphs(field: WIProperty, paragraphStyles): Run[] {
+    let titleStyle = JSON.parse(JSON.stringify(paragraphStyles));
+
+    titleStyle.isBold = true;
+    titleStyle.IsUnderline = true;
+    titleStyle.InsertSpace = true;
+    titleStyle.InsertLineBreak = false;
+
+    let richTextSkin: any[] = [];
+    //handle rich text
+    try {
+      field.richText.forEach((content) => {
+        switch (content.type) {
+          case "paragraph":
+            content.data.fields.forEach((richTextField: WIProperty) => {
+              if (/<\/?[a-z][\s\S]*>/.test(richTextField.value)) {
+                let html = new JSONHtml(richTextField.value);
+                richTextSkin.push(html.getJSONHtml());
+              } else {
+                //making sure ID is not printed
+                let paragraphSkin = new JSONParagraph(
+                  richTextField,
+                  paragraphStyles,
+                  0,
+                  0
+                );
+                richTextSkin.push(paragraphSkin.getJSONParagraph());
+              }
+            });
+            break;
+          case "picture":
+            richTextSkin.push({
+              type: "picture",
+              Path: content.data,
+            });
+            break;
+          case "table":
+            if (content.data) {
+              let tableSkin = new JSONTable(content.data, paragraphStyles, 0);
+              richTextSkin.push(tableSkin.getJSONTable());
+            }
+            break;
+        }
+      });
+      return richTextSkin;
+    } catch (e) {
+      logger.warn(e);
+      return [];
+    }
+  } //generateJsonRichTextParagraphs
+
+  getJSONRichTextParagraph(): any[] {
+    return this.paragraphTemplate;
+  } //getJSONTable
+} //class

package/src/models/json/paragraph/JSONTestSuiteHeaderParagraph.ts

@@ -0,0 +1,94 @@
+import {
+  Paragraph,
+  Run,
+  WIData,
+  WIProperty,
+  StyleOptions,
+} from "../wordJsonModels";
+import JSONRun from "../JSONRun";
+
+export default class JSONTestSuiteHeaderParagraph {
+  paragraphStyles: StyleOptions;
+  paragraphTemplate: Paragraph;
+  wiId: number;
+
+  constructor(
+    fields: WIProperty[],
+    paragraphStyles: StyleOptions,
+    wiId: number,
+    headingLevel: number
+  ) {
+    this.paragraphStyles = paragraphStyles;
+    this.wiId = wiId;
+    this.paragraphTemplate = {
+      type: "paragraph",
+      runs: this.generateJsonParagraphHeaderRuns(fields, this.paragraphStyles),
+    };
+
+    if (headingLevel) {
+      this.paragraphTemplate.headingLevel = headingLevel;
+    } else {
+      this.paragraphTemplate.headingLevel = 0;
+    }
+  } //constructor
+
+  generateJsonParagraphHeaderRuns(fields, paragraphStyles) {
+    let runs: any = [];
+    fields.forEach((field) => {
+      runs = [
+        ...runs,
+        ...this.generateJsonParagraphRun(field, this.paragraphStyles),
+      ];
+    });
+
+    return runs;
+  }
+  generateJsonParagraphRun(field: WIProperty, paragraphStyles): Run[] {
+    let jsonRun: JSONRun;
+    let runs: Run[] = [];
+    let titleStyle = JSON.parse(JSON.stringify(paragraphStyles));
+
+    titleStyle.isBold = false;
+    titleStyle.IsUnderline = true;
+    titleStyle.InsertSpace = true;
+    titleStyle.InsertLineBreak = false;
+    //adds ':' to field titles
+    if (field.name !== "") {
+      field.name += ": ";
+    }
+    //exclude titles for fields that only show values
+    if (
+      field.name !== "Title: " &&
+      field.name !== "ID: " &&
+      field.name !== "Description: "
+    ) {
+      paragraphStyles.Uri = field.url;
+      jsonRun = new JSONRun(field.name, titleStyle);
+      runs = [...runs, ...jsonRun.runs];
+
+      paragraphStyles.InsertLineBreak = false;
+    } //end if
+
+    if (field.name === "ID: ") {
+      field.value = `${field.value}`;
+      paragraphStyles.Uri = field.url;
+      paragraphStyles.InsertLineBreak = false;
+    }
+
+    if (field.name === "Title: ") {
+      let fieldtype = "SuiteHeaderParagraphTitle";
+      paragraphStyles.InsertLineBreak = false;
+      paragraphStyles.Uri = field.url;
+      jsonRun = new JSONRun(field.value, paragraphStyles, fieldtype);
+      runs = [...runs, ...jsonRun.runs];
+    } else {
+      jsonRun = new JSONRun(field.value, paragraphStyles);
+      runs = [...runs, ...jsonRun.runs];
+    }
+    return runs;
+  } //generateJsonParagraph
+
+  getJSONParagraph(): Paragraph {
+    return this.paragraphTemplate;
+  } //getJSONTable
+} //class

package/src/models/json/table/JSONTable.ts

@@ -0,0 +1,75 @@
+import logger from "../../../services/logger";
+import {
+  Table,
+  TableRow,
+  WIQueryResults,
+  WIData,
+  WIProperty,
+  StyleOptions,
+} from "../wordJsonModels";
+import JSONTableRow from "./JSONTableRow";
+export default class JSONTable {
+  tableTemplate: Table;
+  tableStyles: StyleOptions;
+
+  constructor(
+    data: WIQueryResults,
+    tableStyles: StyleOptions,
+    headingLvl: number
+  ) {
+    this.tableStyles = tableStyles;
+    this.tableTemplate = {
+      type: "table",
+      headingLevel: headingLvl,
+      Rows: this.generateJsonRows(data, this.tableStyles),
+    };
+  }
+
+  generateJsonRows(data: any, tableStyles: StyleOptions): TableRow[] {
+    let rows: TableRow[] = [];
+    let headersRowData: WIData = this.headersRowAdapter(data[0]);
+
+    let style2 = {
+      isBold: true,
+      IsItalic: false,
+      IsUnderline: false,
+      Size: 12,
+      Uri: null,
+      Font: "Arial",
+      InsertLineBreak: false,
+      InsertSpace: false,
+    };
+    let headersRow = new JSONTableRow(headersRowData, style2);
+
+    rows.push(headersRow.getRow());
+
+    data.forEach((rowData: WIData) => {
+      let row = new JSONTableRow(rowData, tableStyles);
+      rows.push(row.getRow());
+    });
+
+    return rows;
+  } //generateJsonRows
+
+  headersRowAdapter(data: WIData): WIData {
+    let headerValuesWi;
+    try {
+      headerValuesWi = data.fields.map((field: WIProperty) => {
+        return { name: "header", value: field.name };
+      });
+
+    } catch (error) {
+      logger.error(`no fields to append`);
+    }
+    return {
+      url: "",
+      fields: headerValuesWi,
+      Source: 999999999999,
+      level: data.level,
+    };
+  } //headersRowAdapter
+
+  getJSONTable(): Table {
+    return this.tableTemplate;
+  } //getJSONTable
+} //class

package/src/models/json/table/JSONTableCell.ts

@@ -0,0 +1,117 @@
+import { extname } from "path";
+import {
+  TableCell,
+  Run,
+  Attachment,
+  WIProperty,
+  MultipeValuesWIProperty,
+  StyleOptions,
+  JsonHtml,
+} from "../wordJsonModels";
+import JSONRun from "../JSONRun";
+import logger from "../../../services/logger";
+
+export default class JSONTableCell {
+  cell: TableCell;
+  constructor(data: WIProperty, tableStyles: StyleOptions) {
+    this.cell = this.generateJsonCell(data, tableStyles);
+  }
+
+  generateJsonCell(
+    data: WIProperty | MultipeValuesWIProperty,
+    styles
+  ): TableCell {
+    let runs: Run[] = [];
+    let attachments: Attachment[] = [];
+    let HtmlData: string = ""
+
+    //multiple values
+    if (
+      typeof data.value !== "string" &&
+      typeof data.value !== "number" &&
+      data.value
+    ) {
+      data.value.forEach((runData) => {
+        //check if photo type
+        if (this.isPictureUri(runData.tableCellAttachmentLink)) {
+          let attachment = {
+            type: "Picture",
+            path: runData.tableCellAttachmentLink,
+          };
+          attachments.push(attachment);
+        } 
+        else if(/<[^>]*>/.test(runData.value)) {
+          HtmlData = runData.value || "";
+        }
+        else {
+          styles.Uri = runData.relativeUrl
+            ? runData.relativeUrl
+            : runData.Uri
+            ? runData.Uri
+            : null;
+          styles.InsertLineBreak = false;
+          let jsonRun = new JSONRun(runData.value, styles);
+          runs = [...runs, ...jsonRun.getRun()];
+        }
+      });
+    }
+    else if(/<[^>]*>/.test(data.value)) {
+      HtmlData = data.value || "";
+    }
+     else {
+      styles.Uri = data.relativeUrl
+        ? data.relativeUrl
+        : data.url
+        ? data.url
+        : null;
+      let text = data.value || "";
+      let jsonRun = new JSONRun(`${text}`, styles);
+      runs = [...runs, ...jsonRun.getRun()];
+    }
+    if (HtmlData!= "")
+    {
+      let Html:JsonHtml = {
+        type:"html",
+        Html:HtmlData
+      }
+      return {
+        attachments: attachments,
+        Paragraphs: [
+          {
+            Runs: runs,
+          },
+        ],
+        Html
+      };
+    }
+    else{
+      return {
+        attachments: attachments,
+      Paragraphs: [
+        {
+          Runs: runs,
+        },
+      ],
+    };
+  }
+} //generateJsonCells
+
+  isPictureUri(uri: string) {
+    try {
+      let fileExt = extname(uri);
+      logger.debug(`attachment extension: ${fileExt}`);
+      if (fileExt == ".PNG" || fileExt == ".jpg") {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (e) {
+      logger.error(`error parsing file extension for : ${uri}`);
+      return false;
+    }
+  }
+
+  getJsonCell(): TableCell {
+    return this.cell;
+  }
+} //class

package/src/models/json/table/JSONTableRow.ts

@@ -0,0 +1,34 @@
+import {
+  TableRow,
+  TableCell,
+  WIData,
+  WIProperty,
+  StyleOptions
+} from "../wordJsonModels";
+import JSONTableCell from "./JSONTableCell";
+
+export default class JSONTableRow {
+  row: TableRow;
+
+  constructor(data: WIData, tableStyles: StyleOptions) {
+    this.row = this.generateJsonRow(data, tableStyles);
+  } //constructor
+
+  generateJsonRow(data: WIData, styles: StyleOptions): TableRow {
+    let tableCells: TableCell[] = [];
+
+    data.fields.forEach((wiProperty: WIProperty) => {
+      if (wiProperty.name === "id") {
+        styles.Uri = data.url;
+      }
+      let jsonTableCell = new JSONTableCell(wiProperty, styles);
+      tableCells.push(JSON.parse(JSON.stringify(jsonTableCell.getJsonCell())));
+    });
+
+    return { Cells: tableCells };
+  } //generateJsonRow
+
+  getRow(): TableRow {
+    return this.row;
+  } //getRow
+} //class

package/src/models/json/wordJsonModels.ts

@@ -0,0 +1,97 @@
+export interface StyleOptions {
+  isBold: boolean;
+  IsItalic: boolean;
+  IsUnderline: boolean;
+  Size: number;
+  Uri: string;
+  Font: string;
+  InsertLineBreak: boolean;
+  InsertSpace: boolean;
+}
+export interface DocumentSkin {
+  templatePath: string;
+  contentControls: ContetControlSkin[];
+}
+export interface ContetControlSkin {
+  title: string;
+  wordObjects: any[]; //can be table or paragraph or file
+}
+export interface JsonHtml {
+  type: string;
+  Html: string;
+}
+export interface TableRow {
+  Cells: TableCell[];
+}
+export interface TableCell {
+  attachments?: Attachment[];
+  Paragraphs: [
+    {
+      Runs: Run[];
+    }
+  ];
+  Html?:JsonHtml
+}
+export interface Paragraph {
+  type: string;
+  headingLevel?: number;
+  runs: Run[];
+}
+export interface Attachment {
+  type: string;
+  path: string;
+}
+export interface Run {
+  text: string;
+  Bold: boolean;
+  Italic: boolean;
+  Underline: boolean;
+  Size: number;
+  Uri: string;
+  Font: string;
+  InsertLineBreak: boolean;
+  InsertSpace: boolean;
+}
+export interface WorkItemData {}
+
+export interface Table {
+  type: string;
+  headingLevel: number;
+  Rows: TableRow[];
+}
+export interface WIQueryResults {
+  columns: WIColumns[];
+  workItems: WIData[];
+  asOf: string;
+  queryResultType: number;
+  queryType: number;
+}
+export interface WIData {
+  url: string;
+  fields: WIProperty[];
+  Source: number;
+  level: number;
+}
+export interface WIProperty {
+  name: string;
+  value: any;
+  url?: string;
+  relativeUrl?: string;
+  attachmentLink?: string;
+  relativeAttachmentLink?: string;
+  richText?: any[];
+}
+export interface MultipeValuesWIProperty {
+  name: string;
+  value: any[];
+  url?: string;
+  relativeUrl?: string;
+  attachmentLink?: string;
+  relativeAttachmentLink?: string;
+  richText?: any[];
+}
+export interface WIColumns {
+  name: string;
+  referenceName: string;
+  url: string;
+}