@mikezimm/fps-core-v7/lib/banner/FPSWebPartClass/getCert.js

Library of reusable core interfaces, types and constants migrated from fps-library-v2

/**
 * 2024-09-07:  Migrated from the same folder in fps-library-v2/banner/features/FPSWebPartClass/...
 */
// import { IPreConfigSettings } from "../../common/PropPaneHelp/preconfig/IPreConfig";
// import { CurrentHostLC } from "../../logic/Strings/getSiteCollectionUrlFromLink";
import { CurrentHostLC } from "../../components/molecules/source-props/WindowLocationConstants";
import { upperFirstLetter } from "../../logic/Strings/stringCase";
import { msPerDay } from "../../logic/Time/constants";
import { getDateFromNow } from "../../logic/Time/getDateFromNow";
import { interpretStr } from "../bannerX/Misc/Logic/Checks/interpretStr";
import { FPSMasterCerts } from "../features/Misc/fpsDefaults";
import { ecrptMe } from "../features/Tricky/logfun";
import { decrpt, encrpt } from "../features/Tricky/verify";
/**
 * Gets last valid cert in the array
 * @param _IFPSCert
 * @returns
 */
const lic = upperFirstLetter(ecrptMe('lW$Jkn1', decrpt, encrpt), true); // L<+oz~)
const wi = ecrptMe('mW>=', decrpt, encrpt); // ~<=#
const expd = ecrptMe('1mHW/JT', decrpt, encrpt).toUpperCase(); // )3y<eoc
const exp = ecrptMe('1mHW/J', decrpt, encrpt); // )3y<eo
const now = new Date();
const ExpiredCert = {
    tenant: '*',
    expiration: getDateFromNow(-1),
    expired: true,
    warnD: 79,
    warned: true,
    sulStr: '',
    sulDate: '',
    sulGiver: '',
    sulMess: '',
    sulNotify: '',
    sulScope: '',
    sulVersion: '',
    sulTricky: [],
    sulVal: false,
    daysToExpire: -1,
    expirationDStr: 'License Invalid',
    expirationMsg: 'License Invalid',
    notify: ``,
};
export function getCert(_IFPSCert, enableSUL, sUCode, gitCode) {
    if (!gitCode)
        alert('Required !gitCode');
    const testSUL = enableSUL === true ? sUCode ? sUCode : 'required SUL Code' : '';
    // let defaultCert: IFPSCert = null;
    // let defaultMaster: IFPSCert = null;
    // if (!_IFPSCert || _IFPSCert.length === 0) return ExpiredCert;
    // let current : IFPSCert = ExpiredCert;
    // let foundWPCert = false;
    // let foundMasterCert = false;
    // Establish the host to look for
    const urlParameters = new URLSearchParams(window.location.search);
    let findTenant = urlParameters.get('simulateTenant');
    // Added ability to test other tenants
    if (!findTenant) {
        findTenant = CurrentHostLC.split('.')[0];
    }
    else {
        console.log('URL Params: simulateTenant = ', findTenant);
    }
    let MasterCert = getCertFromArray(FPSMasterCerts, findTenant);
    let WPCert = getCertFromArray(_IFPSCert, findTenant);
    // Merge WPCert into MasterCert
    let MergedCert = {
        tenant: MasterCert.tenant,
        expiration: WPCert.expiration ? WPCert.expiration : MasterCert.expiration,
        notify: WPCert.notify ? WPCert.notify : MasterCert.notify,
        sulStr: testSUL,
        sulDate: '',
        sulGiver: '',
        sulMess: ``,
        sulScope: '',
        sulVersion: '',
        sulTricky: [],
        sulNotify: '',
        sulVal: false,
        warnD: typeof WPCert.warnD === 'number' ? WPCert.warnD : MasterCert.warnD,
        forced: JSON.parse(JSON.stringify(MasterCert.forced ? MasterCert.forced : [])),
        preset: JSON.parse(JSON.stringify(MasterCert.preset ? MasterCert.preset : [])),
        trickyEmails: JSON.parse(JSON.stringify(MasterCert.trickyEmails ? MasterCert.trickyEmails : [])),
        trickyLytics: JSON.parse(JSON.stringify(MasterCert.trickyLytics ? MasterCert.trickyLytics : [])),
    };
    if (WPCert.forced && WPCert.forced.length > 0 && MergedCert.forced)
        MergedCert.forced.push(...JSON.parse(JSON.stringify(WPCert.forced))); // Add .WPCert.forced to end so they over-ride the Master
    if (WPCert.preset && WPCert.preset.length > 0 && MergedCert.preset)
        MergedCert.preset.unshift(...JSON.parse(JSON.stringify(WPCert.preset))); // Add .WPCert.preset to beginning so they over-ride the Master
    if (WPCert.trickyEmails && WPCert.trickyEmails.length > 0 && MergedCert.trickyEmails)
        MergedCert.trickyEmails.push(...JSON.parse(JSON.stringify(WPCert.trickyEmails))); // Purely additive to the Master
    if (WPCert.trickyLytics && WPCert.trickyLytics.length > 0 && MergedCert.trickyLytics)
        MergedCert.trickyLytics.push(...JSON.parse(JSON.stringify(WPCert.trickyLytics))); // Purely additive to the Master
    MergedCert = updateThisCert(MergedCert);
    if (MergedCert.sulStr)
        MergedCert = updateSulStr(MergedCert, testSUL, gitCode);
    // Get the MasterCert for findTenant
    // let MasterCert : IFPSCert = ExpiredCert;
    // FPSMasterCerts.map( ( cert, idx ) => {
    //   const tenant = ecrptMe(cert.tenant, decrpt, encrpt);
    //   if ( cert.tenant === '*' ) { defaultMaster = cert; }
    //   //Must be in exact tenant or have a default
    //   if ( foundMasterCert === false && findTenant.indexOf( `${tenant}`) === 0 ) { // Found matching tenant cert
    //     MasterCert = updateThisCert( cert, tenant );
    //     foundMasterCert = true;
    //   } else if ( foundMasterCert === false && defaultMaster && idx === FPSMasterCerts.length -1 ) {
    //     // Found a defaultMaster and did not find a matching cert yet... use defaultMaster
    //     MasterCert = updateThisCert( defaultMaster, cert.tenant );
    //   }
    // });
    // Get the WPCert for findTenant and merge into Master
    // _IFPSCert.map( ( cert, idx ) => {
    //   const tenant = ecrptMe(cert.tenant, decrpt, encrpt);
    //   if ( cert.tenant === '*' ) { defaultCert = cert; }
    //   //Must be in exact tenant or have a default
    //   if ( foundWPCert === false && findTenant.indexOf( `${tenant}`) === 0 ) { // Found matching tenant cert
    //     current = updateThisCert( cert, tenant );
    //     foundWPCert = true;
    //   } else if ( foundWPCert === false && defaultCert && idx === _IFPSCert.length -1 ) {
    //     // Found a defaultCert and did not find a matching cert yet... use defaultCert
    //     current = updateThisCert( defaultCert, cert.tenant );
    //   }
    // });
    return MergedCert;
}
function getCertFromArray(FPSCerts, findTenant) {
    if (!FPSCerts || FPSCerts.length === 0)
        return ExpiredCert;
    let defaultCert = {};
    let foundCert = false;
    let current = ExpiredCert;
    // Get the WPCert for findTenant and merge into Master
    FPSCerts.map((cert, idx) => {
        const tenant = ecrptMe(cert.tenant, decrpt, encrpt);
        if (cert.tenant === '*') {
            defaultCert = cert;
        }
        //Must be in exact tenant or have a default
        if (foundCert === false && findTenant.indexOf(`${tenant}`) === 0) { // Found matching tenant cert
            // current = updateThisCert( cert, tenant );
            current = cert;
            foundCert = true;
        }
        else if (foundCert === false && defaultCert && idx === FPSCerts.length - 1) {
            // Found a defaultCert and did not find a matching cert yet... use defaultCert
            // current = updateThisCert( defaultCert, cert.tenant );
            current = defaultCert;
        }
    });
    const result = JSON.parse(JSON.stringify(current));
    result.expiration ? result.expiration = new Date(result.expiration) : getDateFromNow(-1);
    return result;
}
// function updateThisCert( cert: IFPSCert, tenant: string ) : IFPSCert {
function updateThisCert(cert) {
    const warnD = cert.warnD ? cert.warnD : 0;
    const now = new Date();
    // https://github.com/mikezimm/fps-library-v2/issues/174
    // If warnDate is in the future, daysToExpire will be +. IF negative, it has passed
    let daysToExpire = (cert.expiration.getTime() - now.getTime()) / msPerDay;
    let warnDate = new Date(cert.expiration);
    warnDate.setDate(warnDate.getDate() - warnD);
    // Updated to test expiration
    let expired = now > cert.expiration ? true : false;
    let warned = now > warnDate ? true : false;
    const urlParameters = new URLSearchParams(window.location.search);
    let simu1ateCertIsExpired = urlParameters.get('simu1ateCertIsExpired');
    let simu1ateCertIsWarned = urlParameters.get('simu1ateCertIsWarned');
    // NOTE:  These can be generic test because paramters are always strings.
    //    So "false" would be considered true and be run
    if (simu1ateCertIsExpired)
        expired = JSON.parse(simu1ateCertIsExpired);
    if (simu1ateCertIsWarned)
        warned = JSON.parse(simu1ateCertIsWarned);
    let dat = `${cert.expiration.toLocaleDateString()}`;
    if (daysToExpire <= 7)
        dat += ` @ ${cert.expiration.toLocaleTimeString()}`;
    const pre = `${lic} ${expired === true ? '' : wi} ${expired === true ? expd : exp} `;
    const newCert = {
        tenant: cert.tenant,
        expiration: cert.expiration,
        daysToExpire: daysToExpire,
        notify: cert.notify,
        sulStr: cert.sulStr,
        sulDate: '',
        sulGiver: '',
        sulNotify: cert.sulNotify,
        sulMess: cert.sulMess,
        sulVal: cert.sulVal,
        sulScope: cert.sulScope,
        sulVersion: cert.sulVersion,
        sulTricky: cert.sulTricky,
        expired: expired,
        expirationDStr: `${dat}`,
        expirationMsg: expired === true || warned ? `${pre} ${dat}` : ``,
        warnD: warnD,
        warned: warned,
    };
    // https://github.com/mikezimm/fps-library-v2/issues/180
    if (cert.trickyEmails) {
        newCert.trickyEmails = cert.trickyEmails;
    }
    if (cert.trickyLytics) {
        newCert.trickyLytics = cert.trickyLytics;
    }
    if (cert.forced) {
        newCert.forced = cert.forced;
    }
    if (cert.preset) {
        newCert.preset = cert.preset;
    }
    return newCert;
}
export const ISULKeysArr = ['warnD', 'date', 'add'];
export function isStringValidSULDate(str) {
    // Regular expression to match the date format YYYY/MM/DD
    const regex1 = /^\d{4}-\d{2}-\d{2}$/;
    const regex2 = /^\d{4}-\d{1}-\d{2}$/;
    // If the string doesn't match the format, return false
    if (!regex1.test(str) && !regex2.test(str)) {
        return null;
    }
    // Split the dateString into parts
    const [year, month, day] = str.split('-').map(Number);
    // Create a Date object using the extracted parts
    const result = new Date(year, month - 1, day);
    return result;
}
function updateSulStr(cert, sulStr, gitCode) {
    let valWD = false;
    let valEx = false;
    let valUrl = false;
    let valScope = false;
    let valEmail = false;
    let valGivenBy = false;
    let valGivenDate = false;
    let valVersion = false;
    let valTmails = false;
    const sulStrX = ecrptMe(sulStr, decrpt, encrpt);
    const [warnD, dateS, url, sulScope, keyMail, givenBy, givenDate, keyTricky, keyVersion] = interpretStr(sulStrX);
    const keyTrickyEmails = keyTricky ? keyTricky.split(',').map((str) => str.trim()) : [];
    const SULWarnD = parseInt(warnD);
    if (warnD && SULWarnD > -1)
        valWD = true;
    const SULExpDate = isStringValidSULDate(dateS);
    if (SULExpDate)
        valEx = true;
    if (url && window.location.href.toLocaleLowerCase().indexOf(url.toLocaleLowerCase()) === 0)
        valUrl = true;
    if (sulScope && (sulScope.toLocaleLowerCase() === gitCode.toLocaleLowerCase() || sulScope.toLocaleLowerCase() === 'AllFPS'.toLocaleLowerCase()))
        valScope = true;
    if (keyMail && keyMail.indexOf('@') > 0)
        valEmail = true;
    if (givenBy)
        valGivenBy = true;
    if (givenDate)
        valGivenDate = true;
    if (valWD === true && valEx === true && valUrl === true && valScope && valEmail && valGivenBy && valGivenDate) {
        const now = new Date();
        let daysToExpire = (SULExpDate.getTime() - now.getTime()) / msPerDay;
        let warnDate = new Date(SULExpDate);
        warnDate.setDate(warnDate.getDate() - SULWarnD);
        let expired = now > SULExpDate ? true : false;
        let warned = now > warnDate ? true : false;
        let dat = `${SULExpDate.toLocaleDateString()}`;
        if (daysToExpire <= 7)
            dat += ` @ ${SULExpDate.toLocaleTimeString()}`;
        const mess = `${ecrptMe(`Ei>WT SWkf>J L]J 4Cv1H]J`, decrpt, encrpt)}`; // Ve=<c S<z&=o Ugo L1/)lgo
        const pre = `SUL ${lic} ${expired === true ? '' : wi} ${expired === true ? expd : exp} `;
        cert.sulMess = mess;
        cert.sulVal = true;
        cert.sulDate = givenDate,
            cert.sulGiver = givenBy,
            cert.sulScope = sulScope;
        cert.expiration = SULExpDate;
        cert.sulNotify = keyMail;
        cert.daysToExpire = daysToExpire;
        cert.expired = expired;
        cert.expirationDStr = `${dat}`;
        cert.expirationMsg = expired === true || warned ? `${pre} ${dat}` : ``;
        cert.warnD = SULWarnD;
        cert.warned = warned;
    }
    else {
        const eW = `${valWD === true ? '' : 'nrw'.split('').reverse().join('')}`;
        const eU = `${valUrl === true ? '' : 'rul'.split('').reverse().join('')}`;
        const eE = `${valEx === true ? '' : 'eta'.split('').reverse().join('')}`;
        const eS = `${valScope === true ? '' : 'ocs'.split('').reverse().join('')}`;
        const eM = `${valEmail === true ? '' : 'iam'.split('').reverse().join('')}`;
        const eB = `${valGivenBy ? '' : 'yb'.split('').reverse().join('')}`;
        const eD = `${valGivenDate ? '' : 'gdt'.split('').reverse().join('')}`;
        const mess = `${ecrptMe(`v,)QX,7Dcimn0J$>d/k$Cv//]/bGdvA$`, decrpt, encrpt)}: Code: ${eW}-${eE}-${eU}-${eS}-${eM}-${eB}-${eD}`; // _z>Fvzl7Pe~~To+-ouz.1/euguw|o/a.
        cert.sulMess = mess;
        cert.sulVal = false;
        cert.sulScope = `${sulScope} vs ${gitCode}`;
        cert.expiration = now;
        cert.daysToExpire = 0;
        cert.expired = true;
        cert.expirationDStr = `${now}`;
        cert.expirationMsg = mess;
        cert.warnD = 0;
        cert.warned = true;
    }
    // Always add sulVersion to object
    if (keyVersion)
        cert.sulVersion = keyVersion;
    if (keyTrickyEmails.length > 0) {
        cert.sulTricky = keyTrickyEmails;
        if (!cert.trickyEmails)
            cert.trickyEmails = [];
        if (!cert.trickyLytics)
            cert.trickyLytics = [];
        // Always add all keyTrickyEmails to both Lytics and Emails for full support
        cert.trickyEmails.push(...keyTrickyEmails);
        cert.trickyLytics.push(...keyTrickyEmails);
    }
    return cert;
}
//# sourceMappingURL=getCert.js.map