km-web-plugin/templates/base/src/utils/em.api.js

ICE Web Plugin Initializer

import * as sdk from './em.sdk.js';

const host = 'https://api.elliemae.com/';

const methods = {
    async get(http, { url, token, headers }) {
        return http.get(url, {
            Authorization: `Bearer ${token}`,
            'Content-Type': 'application/json',
            ...headers,
        });
    },
    async del(http, { url, token, headers }) {
        return http.delete(url, {
            Authorization: `Bearer ${token}`,
            'Content-Type': 'application/json',
            ...headers,
        });
    },
    async post(http, { url, data, token, headers }) {
        return http.post(url, data, {
            Authorization: `Bearer ${token}`,
            'Content-Type': 'application/json',
            ...headers,
        });
    },
    async patch(http, { url, data, token, headers }) {
        return http.patch(url, data, {
            Authorization: `Bearer ${token}`,
            'Content-Type': 'application/json',
            ...headers,
        });
    },
    async put(http, { url, data, token, headers }) {
        return http.put(url, data, {
            Authorization: `Bearer ${token}`,
            'Content-Type': 'application/json',
            ...headers,
        });
    },
};

async function makeCall(method, url, data, headers, overrides) {
    let http = await sdk.getHttp();
    let token = await sdk.getAccessToken();
    try {
        let response = await method(http, {
            url: `${host}${url}`,
            token,
            data,
            headers,
            ...overrides,
        });
        return response;
    } catch (e) {
        sdk.log(e);
        return { body: null };
    }
}

export async function calculateEndDate(eventDate, daysOffset, calendarType) {
    let data = {
        completionBasis: {
            dateSrc: {
                source: 'event',
                eventDate: eventDate,
            },
            calendar: calendarType,
            offset: daysOffset,
            timezoneCode: 'UTC',
        },
    };
    let result = await makeCall(
        methods.post,
        'encompass/v3/calculators/timerCompletion',
        data,
    );
    return result.body;
}

export async function saveCdo(name, data) {
    const body = {
        dataObject: btoa(JSON.stringify(data)),
    };

    let response = await makeCall(
        methods.put,
        `encompass/v1/company/customObjects/${name}?view=entity`,
        JSON.stringify(body),
    );

    return response.body;
}

export async function getCdo(name) {
    const response = await makeCall(
        methods.get,
        `encompass/v1/company/customObjects/${name}`,
    );

    if (response.status === 200) {
        return JSON.parse(atob(response.body.dataObject));
    }

    return null;
}

export async function uploadAttachmentAndAssign(
    loanId,
    docId,
    attName,
    contentType,
    attBytes,
) {
    if (!loanId || attBytes == null || attBytes.length == 0) return null;

    const data = {
        file: {
            contentType: contentType,
            name: attName ?? 'Unamed',
            size: attBytes.length,
        },
        title: attName ?? 'Unamed',
        assignTo: {
            entityId: docId,
            entityType: 'Document',
        },
    };
    let url = await makeCall(
        methods.post,
        `encompass/v3/loans/${loanId}/attachmentUploadUrl`,
        data,
    );
    if (!url.body?.uploadUrl) return null;

    let result = await fetch(url.body.uploadUrl, {
        method: 'put',
        headers: {
            authorization: url.body.authorizationHeader,
        },
        body: attBytes,
    });

    return result;
}

export async function getDocument(loanId, docId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let doc = await makeCall(
        methods.get,
        `encompass/v1/loans/${loanId}/documents/${docId}`,
    );
    return doc.body;
}

export async function getDocumentsByIds(loanId, docIds) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let tasks = [];
    let docs = [];

    for (const val of docIds) {
        let task = getDocument(loanId, val)
            .then((data) => docs.push(data))
            .catch((e) => sdk.log(e));

        tasks.push(task);
    }
    await Promise.allSettled(tasks);
    return docs;
}

export async function exportAttachment(loanId, attId, callback) {
    let exportJob = await createAttachmentExportJob(loanId, attId);
    if (exportJob == null || !exportJob.ok) {
        callback?.call(null, null);
        sdk.log(exportJob);
        return;
    }

    let processing = false;
    return new Promise((resolve) => {
        let interval = setInterval(async () => {
            if (processing) return;

            processing = true;

            let status = await getExportJobStatus(exportJob.body.jobId);
            if (!['Queued', 'Running', 'Success'].includes(status.status)) {
                clearInterval(interval);
                callback?.call(status, status);
                resolve(status);
                return;
            }

            if (['Queued', 'Running'].includes(status.status)) {
                processing = false;
                return;
            }

            if ((status.status = 'Success')) {
                processing = false;
                clearInterval(interval);
                callback?.call(status, status);
                resolve(status);
                return;
            }
        }, 300);
    });
}

export async function exportAttachments(loanId, attIds, callback) {
    if (attIds == null || attIds.length == 0) return;

    let proms = [];
    let result = [];

    for (const attId of attIds) {
        let prom = exportAttachment(loanId, attId, (r) => {
            r.originalAttId = attId;
            result.push(r);
        });
        proms.push(prom);
    }

    await Promise.allSettled(proms);

    callback?.call(result, result);
    return result;
}

export async function downloadFromSkyDrive(fileUrl, authHeader) {
    let response = await fetch(fileUrl, {
        headers: {
            Authorization: authHeader,
        },
    });

    return await response.blob();
}

export async function downloadAttachments(loanId, attIds, callback) {
    if (attIds == null || attIds.length == 0) return [];

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let urls = await getAttachmentDownloadUrl(loanId, attIds);
    return new Promise(async (resolve) => {
        let atts = urls.attachments;
        let proms = [];
        let data = [];

        for (let att of atts) {
            let prom = new Promise(async (r) => {
                var headers = new Headers();

                if (att.authorizationHeader)
                    headers.append('Authorization', att.authorizationHeader);

                var result = await fetch(att.url, {
                    method: 'get',
                    headers: headers,
                });

                let obj = {
                    id: att.id,
                    url: att.url,
                    contentType:
                        att.contentType ?? result.headers.get('content-type'),
                    blob: await result.blob(),
                };

                data.push(obj);
                r(obj);
            });
            proms.push(prom);
        }

        await Promise.allSettled(proms);
        callback?.call(data, data);
        resolve(data);
    });
}

export async function getAttachmentOriginalDownloadUrls(loanId, attIds) {
    if (attIds == null || attIds.length == 0) return [];

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let att = await makeCall(
        methods.post,
        `encompass/v3/loans/${loanId}/attachmentDownloadUrl`,
        { attachments: attIds },
    );
    return att.body;
}

export async function downloadAllFromSkyDrive(
    files,
    urlProp = (f) => f.authorizationHeader,
    authProp = (f) => f.entityUri,
) {
    if (files == null || files.length == 0) return [];

    let proms = [];
    for (const file of files) {
        let auth = authProp(file);
        let uri = urlProp(file);

        if (!auth || !uri) {
            console.log('auth or uri missing for file: ', file);
            continue;
        }

        let prom = downloadFromSkyDrive(uri, auth).then((bl) => {
            file.blob = bl;
        });
        proms.push(prom);
    }

    await Promise.allSettled(proms);
    return files;
}

export async function createAttachmentExportJob(loanId, attId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let request = {
        annotationSettings: {
            visibility: ['Private', 'Public', 'Internal'],
        },
        entities: [{ entityId: attId, entityType: 'Attachment' }],
        source: {
            entityId: loanId,
            entityType: 'loan',
        },
    };

    let response = await makeCall(
        methods.post,
        'efolder/v1/exportjobs',
        request,
    );
    return response;
}

export async function getExportJobStatus(jobId) {
    if ((jobId ?? '').trim() == '') {
        sdk.log('Job id cannot be null');
        return;
    }

    let request = await makeCall(methods.get, `efolder/v1/exportjobs/${jobId}`);
    return request.body;
}

export async function getAttachmentDownloadUrl(loanId, attIds) {
    if (attIds == null || attIds.length == 0) return [];

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let att = await makeCall(
        methods.post,
        `encompass/v3/loans/${loanId}/attachmentDownloadUrl`,
        { attachments: attIds },
    );
    return att.body;
}

export async function getAttachment(loanId, attId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let att = await makeCall(
        methods.get,
        `encompass/v3/loans/${loanId}/attachments/${attId}`,
    );
    return att.body;
}

export async function getMediaUrl(loanId, attId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let url = await makeCall(
        methods.post,
        `encompass/v1/loans/${loanId}/attachments/${attId}/url`,
    );
    return url.body;
}

export async function getAttachments(loanId, attIds) {
    if (attIds == null || attIds.length == 0) return [];

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let tasks = [];
    let atts = [];

    for (const val of attIds) {
        let task = getAttachment(loanId, val)
            .then((data) => atts.push(data))
            .catch((e) => sdk.log(e));

        tasks.push(task);
    }

    await Promise.allSettled(tasks);
    return atts;
}

export async function getLoanDocuments(loanId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let t = 'something';
    let docs = await makeCall(
        methods.get,
        `encompass/v3/loans/${loanId}/documents`,
    );
    alert(docs);
    return docs.body;
}

export async function getLoanUnassignedAttCount(loanId) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let docs = await makeCall(
        methods.get,
        `encompass/v3/loans/${loanId}/attachments`,
    );
    return docs.body.filter((b) => !b.assignedTo).length;
}

export async function getUsers() {
    let response = await makeCall(methods.get, 'encompass/v1/company/users');

    return response.body;
}

export async function getCurrentUserEligibleRoles() {
    let response = await makeCall(
        methods.get,
        'encompass/v3/users/me/eligibleRoles',
    );
    return response.body;
}

export async function setFields(fields, loanId, merge = true) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let parsedFields = [];
    for (const [prop, value] of Object.entries(fields))
        parsedFields.push({ id: prop, value });

    let response = await makeCall(
        methods.post,
        `encompass/v3/loans/${loanId}/fieldWriter`,
        parsedFields,
    );

    if (merge) await (await sdk.getLoan()).merge();

    return response.body;
}

export async function setField(
    fieldId,
    fieldValue,
    loanId = false,
    merge = true,
) {
    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let response = await makeCall(
        methods.post,
        `encompass/v3/loans/${loanId}/fieldWriter`,
        [{ id: fieldId, value: fieldValue }],
    );

    if (merge) await (await sdk.getLoan()).merge();

    return response.body;
}

export async function getCurrntUserDetails() {
    let response = await makeCall(
        methods.get,
        'encompass/v3/users/me?entities=all',
    );
    return response.body;
}

export async function applyLoanProgram(programName, loanId) {
    if ((programName ?? '').trim() == '') return;

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}?view=entity&templateType=loanProgram&templatePath=Public:\\${programName}&ignoreEmptyLoanProgramValues=true&ignoreEmptyClosingCostValues=false`,
        {},
    );
    return response.body;
}

export async function applyTemplateSet(templateName, loanId) {
    if ((templateName ?? '').trim() == '') return;

    if (!loanId) loanId = (await sdk.getLoanAll()).loan.id;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}?view=entity&templateType=templateSet&templatePath=Public:\\${templateName}&ignoreEmptyClosingCostValues=true&ignoreEmptyLoanProgramValues=true&ignoreEmptyLoanProgramClosingCostValues=true`,
        {},
    );
    return response.body;
}

export async function removeVODs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/vods?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOLs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/vols?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOMs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/reoProperties?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOOIs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/otherIncomeSources?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOOAs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/otherAssets?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOGGs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/giftsGrants?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeBorrowerVOEs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/borrower/employment?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeCoBorrowerVOEs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/coborrower/employment?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeBorrowerVORs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/borrower/residences?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeCoBorrowerVORs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/coborrower/residences?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOALs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/additionalloans?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}

export async function removeVOOLs(loanId, applicationId, vIds) {
    if ((vIds ?? []).length == 0) return;

    let response = await makeCall(
        methods.patch,
        `encompass/v3/loans/${loanId}/applications/${applicationId}/otherLiabilities?action=delete`,
        vIds.map((a) => ({ id: a.id })),
    );
    return response.body;
}