utilities.js

/*
Validation Style
*/
const BLUE = '#E6F7FC';
const BLUE_BORDER = '#00AAE3';
const YELLOW = '#FFF3CF';
const YELLOW_BORDER = '#FFC000';
const GREEN = '#F0F8CB';
const GREEN_BORDER = '#88A600';
const PURPLE = '#F5F2FE';
const PURPLE_BORDER = '#8A62F1';
const RED = '#FDF1F1';
const RED_BORDER = '#ED3A3A';
const BROWN = '#F7F3EE';
const BROWN_BORDER = '#AE8154';
const PINK = '#FFEFFC';
const PINK_BORDER = '#FE1FD5';
const ADDRESS_DIV_BORDER = '1px solid ';
const ADDRESS_DIV_PADDING = '5px';
const EXTENSION_ELEMENT_ATTRIBUTE = 'curam-evidence-validator';
/* 
Selectors
*/
const TABLE_ROW_DESCRIPTION_SELECTOR = 'tr[data-lix] a.field-link';
const SCRIPT_CONTAINER_SELECTOR = 'script.hidden-list-rows';
const EVIDENCE_TAB_TITLE_CRITERIA = 'Evidence';
/*
Functions
*/
async function waitForElement(selector, doc = null) {
    return new Promise((resolve) => {
        if (doc === null)
            doc = document

        const interval = setInterval(() => {
            const element = doc.querySelector(selector);
            if (element && element.textContent != null) {
                console.debug(`Waiting for ${selector} of type ${element.nodeName}`);
                if (element.nodeName === "IFRAME") {
                    if (element.contentDocument.body != null &&
                        element.contentDocument.body.textContent != "") {
                        clearInterval(interval);
                        resolve(element);
                    }
                }
                else {
                    clearInterval(interval);
                    resolve(element);
                }

            }
        }, 250);
    });
}

function getEvidenceFromXmlHttp(url) {

    const evidence = [];

    if (url !== "") {

        const xmlHttp = new XMLHttpRequest();
        try {
            xmlHttp.open('GET', url, false);
            xmlHttp.send();
        } catch (error) {
            console.error("Failed to send evidence request")
        }
        let evidenceTable = null;

        if (xmlHttp.readyState === xmlHttp.DONE) {

            try {
                const parser = new DOMParser();
                const doc = parser.parseFromString(xmlHttp.responseText, 'text/html');
                const scriptContainerRows = doc.querySelector(SCRIPT_CONTAINER_SELECTOR).innerHTML;

                evidenceTable = parseScriptTagRows(doc.querySelector(SCRIPT_CONTAINER_SELECTOR).innerHTML);

            } catch (error) {
                console.error('Failed to parse script contents in evidence request')
            }

            if (evidenceTable) {
                const descriptionFields = evidenceTable.querySelectorAll(TABLE_ROW_DESCRIPTION_SELECTOR);

                descriptionFields.forEach(descriptionField => {
                    try {
                        const { description, participant, period, updates, latestActivity } = parseRowDataFromDescriptionField(descriptionField);
                        if (isActiveEvidencePeriod(period))
                            evidence.push({ participant, description, period, updates, latestActivity });

                    } catch (error) {
                        console.error("Failed to parse evidence row")
                    }

                })
            }
        }

        return evidence;
    }
}

function parseRowDataFromDescriptionField(descriptionField) {

    let description;
    let participant;
    let period;
    let updates;
    let latestActivity;

    if (descriptionField.parentElement.outerHTML.includes(EXTENSION_ELEMENT_ATTRIBUTE) === false) {
        description = descriptionField.textContent.trim();
        participant = descriptionField.parentElement.previousElementSibling.textContent.trim();
        period = descriptionField.parentElement.nextElementSibling.textContent.trim();
        updates = descriptionField.parentElement.nextElementSibling.nextElementSibling.textContent.trim();
        latestActivity = descriptionField.parentElement.nextElementSibling.nextElementSibling.nextElementSibling.textContent.trim();
    } else {
        description = descriptionField.textContent;
        participant = descriptionField.parentElement.parentElement.previousElementSibling.textContent.trim();
        period = descriptionField.parentElement.parentElement.nextElementSibling.textContent.trim();
        updates = descriptionField.parentElement.parentElement.nextElementSibling.nextElementSibling.textConten.trim();
        latestActivity = descriptionField.parentElement.parentElement.nextElementSibling.nextElementSibling.nextElementSibling.textContent.trim();
    }

    return { description, participant, period, updates, latestActivity }
}

function createOrAddToMap(map, key, rowData, descriptionField, isVisible, scriptTag = null) {
    if (map.has(key)) {
        map.get(key).push({ rowData, descriptionField, isVisible, scriptTag });
    }
    else {
        map.set(key, [{ rowData, descriptionField, isVisible, scriptTag }])
    }
}

function formatVisibleArrayEntries(arr, colorIndex) {
    arr.forEach((entry) => {
        if (entry.descriptionField.parentElement.outerHTML.includes(EXTENSION_ELEMENT_ATTRIBUTE) === false) {
            let divWrapper = getDivWrapper(colorIndex);
            entry.descriptionField.parentNode.replaceChild(divWrapper, entry.descriptionField);
            divWrapper.appendChild(entry.descriptionField);
        }
    })
}

function formatHiddenArrayEntries(arr, colorIndex){
    arr.forEach((entry) => {
        if (entry.descriptionField.parentElement.outerHTML.includes(EXTENSION_ELEMENT_ATTRIBUTE) === false) {
            let divWrapper = getDivWrapper(colorIndex);
            entry.descriptionField.parentNode.replaceChild(divWrapper, entry.descriptionField);
            divWrapper.appendChild(entry.descriptionField);
            entry.scriptTag.innerHTML = entry.scriptTag.innerHTML.replaceAll("  ", " ").replace(entry.descriptionField.outerHTML, divWrapper.outerHTML)
        }
    })
}

function parseScriptTagRows(scriptInnerHtml) {

    let evidenceTable = document.createDocumentFragment();
    evidenceTable.append(document.createElement('tbody'));
    evidenceTable.querySelector('tbody').innerHTML = scriptInnerHtml;

    return evidenceTable;
}

function isActiveEvidencePeriod(period) {
    if (period.endsWith('-')) {
        return true;
    }

    return false;
}

async function getFirstEvidenceRowOnPage(pageTitle, evidenceType) {

    console.debug(`Getting first row of '${pageTitle.textContent}' evidence`);

    const iframeTitle = await waitForElement(`iframe[title*="${pageTitle.textContent.trim()}"]`);

    let evidenceTables = document.querySelectorAll(EVIDENCE_TABLE_IFRAME_SELECTOR);
    let activeIframeSelector = EVIDENCE_TABLE_IFRAME_SELECTOR;
    let activeCaseId = iframeTitle
        .getAttribute(CONTENT_URL_ATTRIBUTE)
        .split("?")[1]
        .split("&")
        .find((s) => { return s.includes(CONTENT_URL_CASEID_CRITERIA) });

    if (evidenceTables.length > 1) {

        evidenceTables.forEach(table => {
            var contentUrl = table.getAttribute(CONTENT_URL_ATTRIBUTE);
            if (contentUrl.includes(activeCaseId) && contentUrl.includes(evidenceType)) {
                activeIframeSelector = `#${table.id}`;
            }
        })
    } else if (evidenceTables.length === 1) {
        activeIframeId = evidenceTables[0].id
    }
    const iframe = await waitForElement(activeIframeSelector);
    addRefreshObserver(iframe);

    return waitForElement(EVIDENCE_TABLE_ROWS_SELECTOR, iframe.contentDocument.documentElement);

}


function addRefreshObserver(currentFrame){
    const refreshObserverConfig = {
        attributeFilter: ["title"]
    };
    const refreshObserver = new MutationObserver(function (mutations) {
        // We need only first event and only new value of the title
        mutations.forEach(mutation => {
            if (mutation.target.title.includes(EVIDENCE_TAB_TITLE_CRITERIA))
                handleTitleElement(document.querySelector(ACTIVE_PAGE_TITLE_SELECTOR))
        })
    });

    refreshObserver.observe(currentFrame, refreshObserverConfig);

    console.debug("Added Refresh Observer")
}


function getAddreessBorderColor(index) {
    if (index > 5) index = index % 6;

    switch (index) {
        case 0:
            return YELLOW_BORDER;
        case 1:
            return BLUE_BORDER;
        case 2:
            return GREEN_BORDER;
        case 3:
            return PURPLE_BORDER;
        case 4:
            return BROWN_BORDER;
        case 5:
            return PINK_BORDER;
    }
}

function getWrapperBackgroundColor(index) {
    if (index > 5) index = index % 6;

    switch (index) {
        case 0:
            return YELLOW;
        case 1:
            return BLUE;
        case 2:
            return GREEN;
        case 3:
            return PURPLE;
        case 3:
            return BROWN;
        case 5:
            return PINK;

    }
}
function getDivWrapper(index) {

    const element = document.createElement('div');
    element.style.backgroundColor = getWrapperBackgroundColor(index);
    element.style.border = ADDRESS_DIV_BORDER + getAddreessBorderColor(index);
    element.style.padding = ADDRESS_DIV_PADDING;
    element.setAttribute(EXTENSION_ELEMENT_ATTRIBUTE, '');

    return element;

}

function saveUsageData(titleElement, activeCaseId) {

    const usageData = getUsageData(titleElement)
    usageData.caseId = activeCaseId.split(`${CONTENT_URL_CASEID_CRITERIA}=`)[1];

    chrome.runtime.sendMessage({ action: "usageTracking", usageData })
}

function saveErrorData(usageData, error) {
    usageData.error = error.stack.replace(/[\r\n]/gm, '');;
    chrome.runtime.sendMessage({ action: "usageTracking", usageData });
}

function getUsageData(titleElement) {

    const pageTitle = titleElement.textContent.split(" - ")[0]
    const name = document.querySelector(CURRENT_USER_SELECTOR).textContent.split("Welcome ")[1];
    const timestamp = new Date().toISOString();

    return { name, pageTitle, timestamp, caseId: null, error: null }

}