ca-mfe-page-scoring-ui/src/components/StepTracker/updateRGRModalData.js

This is a react shell for the SPGI Platform MFE implementation

import moment from 'moment';

const modelType = 'RG';
const ScoreModelObjName = {
    'fn': 'funpdScoreModel',
    'cm': 'cmScoreModel',
    'epd': 'epdScoreModel'
};
const modelIdentityObj = {
    'fn': 'cmsWidget',
    'cm': 'cmScoreModel',
    'epd': 'expectedpdWidget'
};
const RGRModalData = {
    isNewSUItoRGRFlow: true,
    rgLatest: true,
    modelType,
    EpdBucket: null,
    finalScores: null,
    selectedFinStatement: null,
    AdjustmentsForRollover: null,
    QAdjPDScore: {},
    genSeriesSUI: [],
    SUICompanyInfo: {},
    currScoringData: null,
    middleScoringData: { overallScoreModel: {} },
    rgModel: { overallScoreModel: {} },
    generatedRgScore : null,
    macroInputs: {
        scoringData: {
            request: null,
            data: {
                outputs: [],
                modelDataFN: null,
                modelDataCM: null,
                userInputs: {}
            }
        }
    },
    isLatestDateArray: [],
    Period: {}
};

function transformBenchmarkScore(score) {
    const { oneToHundred, letterGrade, rawPd, observationCount } = score;
    const onetoNineScale = -1; // change in case of 1-9 scale
    const calculatedRawPd = rawPd * 100;
    const riskCategory = '';

    return [
        oneToHundred,
        onetoNineScale,
        letterGrade,
        calculatedRawPd,
        rawPd,
        riskCategory,
        observationCount
    ];
}

const updateRgData = (scoredTrackerData, isEpd, loadCurrScoreData) => {
    if (RGRModalData?.middleScoringData?.overallScoreModel) {
        RGRModalData.middleScoringData.overallScoreModel = scoredTrackerData?.riskGaugeData || null;
    }
    if(loadCurrScoreData){
        RGRModalData.currScoringData = {
            overallScoreModel: scoredTrackerData?.riskGaugeData || null
        };
    }
    if (RGRModalData?.rgModel?.overallScoreModel) {

        const data = scoredTrackerData?.riskGaugeData;

        const lastValidScore = data?.scoreAnalysis?.slice().reverse()
            .find(item => item.benchmarkScore && Object.keys(item.benchmarkScore).length > 0);

        const transformedScoreAnalysis = lastValidScore ?
            [{ ...lastValidScore, benchmarkScore: transformBenchmarkScore(lastValidScore.benchmarkScore) }] : [];

        const rgScore = data?.riskGaugeScore?.rgScore || {};
        const rgAdjustedScore = data?.rgAdjustedScore || {};

        const creditScore = rgScore.oneToHundred && !Number.isNaN(rgScore.oneToHundred) ?
        rgScore.oneToHundred : 0;
        const pd = rgScore.rawPd && !Number.isNaN(rgScore.rawPd) ? rgScore.rawPd * 100 : 0;
        const pdAdjRawPd = rgAdjustedScore.rawPd && !Number.isNaN(rgAdjustedScore.rawPd) ?
            rgAdjustedScore.rawPd * 100 : 0;

        RGRModalData.rgModel.overallScoreModel = {
            noData: false,
            creditRating: rgScore.letterGrade || '',
            creditScore,
            pd,
            isEpd,
            isPropData: false,
            pdAdjRawPd,
            isLowerModelVersion: false,
            rgLowerModelVersion: null,
            creditScoreOneToNine: 0,
            scoreAnalysis: transformedScoreAnalysis
        };
    }
};

const loadMacroInputs = (scoredTrackerData, userInfo) => {
    const scoringData = scoredTrackerData?.generatedScore?.scoringData || [];
    if (RGRModalData?.macroInputs?.scoringData?.data) {
        RGRModalData.macroInputs.scoringData.data.outputs = scoringData;
        RGRModalData.macroInputs.scoringData.data.userInputs = {
            userId: userInfo?.userId,
            userName: userInfo?.userName
        };
    }
    if (RGRModalData?.macroInputs?.scoringData) {
        RGRModalData.macroInputs.scoringData.request = {
            ...scoredTrackerData?.generateScorePayload
        };
        if (RGRModalData.macroInputs.scoringData.request.loadInputsRequest) {
            RGRModalData.macroInputs.scoringData.request.loadInputsRequest = {
                ...RGRModalData.macroInputs.scoringData.request.loadInputsRequest,
                caModel: 'RG'
            };
        }
    }
};

const updateCompanyInfo = (companyData, selectedValues, companySelectedData) => {
    const countryCode = companySelectedData?.country?.value;
    const industryCode = companySelectedData?.industry?.value?.toString();
    const companyType = companySelectedData?.type?.label;

    RGRModalData.SUICompanyInfo = {
        ...companyData,
        countryCode,
        industryCode,
        companyType
    };
    RGRModalData.selectedFinStatement = moment(selectedValues?.financialStatement?.value).format('YYYY-MM-DD');
    RGRModalData.Period = {
        FiscalQuarter: selectedValues?.financialStatement?.fiscalQuarter,
        FiscalYear: selectedValues?.financialStatement?.fiscalYear,
        PeriodDate: selectedValues?.financialStatement?.periodDate,
        PeriodType: selectedValues?.financialStatement?.periodType
    };
};

const updateLatestDateArray = isAsOfDateToday => {
    const RIModelIdentity = {
        modelIdentity: 'overallRiskIdentity',
        model: modelType,
        isLatest: isAsOfDateToday
    };
    RGRModalData.isLatestDateArray = [RIModelIdentity];
};

const updateGeneratedScoreData = ({
    scoredTrackerData,
    isPitAdjSelected,
    loadPitAdj,
    isAsOfDateToday,
    companyData,
    selectedValues,
    companySelectedData,
    isLatestFinStmt,
    sizeAdjustmentData,
    models,
    isEpd
}) => {
    const [scoringData] = scoredTrackerData?.generatedScore?.scoringData || [];
    const scoredData = scoredTrackerData?.riskGaugeData || [];
    const rgScore = scoredData?.riskGaugeScore?.rgScore || {};
    const rgAdjustedScore = scoredData?.rgAdjustedScore || {};
    if(scoringData){
        const updatedInputsRequest = {

            countryIsoCode: companySelectedData?.country?.value,
            industryCode: companySelectedData?.industry?.value?.toString(),

            companyType: companyData?.companyType,
            publicPrivate: companyData?.companyType,
            name: companyData?.companyName,
            companyId: Number(companyData?.companyId),

            asOfDate: selectedValues?.asOfDate,
            periodType: selectedValues?.financialStatement?.periodType,
            currencyIso: selectedValues?.financialStatement?.currencyCode,
            restatementType: selectedValues?.financialStatement?.restatementType,

            periodQuarter: {
                quarter: selectedValues?.financialStatement?.fiscalQuarter,
                calendarYear: selectedValues?.financialStatement?.fiscalYear,
                year: selectedValues?.financialStatement?.fiscalYear,
                fiscalQuarter: selectedValues?.financialStatement?.fiscalQuarter,
                fiscalYear: selectedValues?.financialStatement?.fiscalYear,
                currencyIso: selectedValues?.financialStatement?.currencyCode,
                restatementType: selectedValues?.financialStatement?.restatementType,
                statementDate: moment(
                    selectedValues[isEpd ? 'selectPeriod' : 'financialStatement']?.periodDate || null
                ).format('YYYY-MM-DD')
            }
        };
        const ScoreModelData = {};

        Object.keys(ScoreModelObjName).forEach( mf => {
            if(mf in scoringData){
                const inpReq = {
                    inputsRequest: {
                        ...updatedInputsRequest,
                        caModel: mf.toUpperCase(),
                        modelId : models[mf.toUpperCase()]
                    }
                };
                const isEpdFamily = Boolean(mf === 'epd');
                const data = {
                    modelFamily: mf.toUpperCase(),
                    metrics: scoringData[mf],
                    ...(isEpdFamily ? {
                        widgetModelRequest: inpReq,
                       ...sizeAdjustmentData
                    }: inpReq),
                    pitAdjustments: {
                        creditCycle: isPitAdjSelected,
                        pitAdjustmentDate: loadPitAdj?.currentResp?.pitAdjustmentDate
                    },
                    isSui: true,
                    isLatest: isAsOfDateToday
                };
                ScoreModelData[ScoreModelObjName[mf]] = {
                    reqPayload: {
                        ...data,
                        ...(isEpdFamily ? sizeAdjustmentData : {})
                    }
                };
                if(isEpdFamily && sizeAdjustmentData?.epdBucket){
                    RGRModalData.EpdBucket = sizeAdjustmentData?.epdBucket;
                }

                const getValRGScore = score => (score !== undefined && score !== null
                    && !Number.isNaN(score)) ? score : null;

                RGRModalData.generatedRgScore = getValRGScore(rgAdjustedScore.rawPd) || getValRGScore(rgScore.rawPd);

                RGRModalData.isLatestDateArray = [
                    {
                        isLatest: isAsOfDateToday,
                        model: mf.toUpperCase(),
                        modelIdentity: modelIdentityObj[mf]
                    },
                    ...RGRModalData.isLatestDateArray
                ];
            }
        });
        RGRModalData.middleScoringData = {
            ...RGRModalData.middleScoringData,
            ...ScoreModelData
        };
        if(isLatestFinStmt){
            RGRModalData.currScoringData = {
                ...RGRModalData.currScoringData,
                ...ScoreModelData
            };
        }
    }
};

const updateRGRModalData = ({
    scoredTrackerData,
    selectedValues,
    companyData,
    companySelectedData,
    userInfo,
    isEpd,
    isPitAdjSelected,
    loadPitAdj,
    isAsOfDateToday,
    isLatestFinStmt,
    sizeAdjustmentData,
    scoringFinInputs,
    models
}) => {
    updateRgData(scoredTrackerData, isEpd, isLatestFinStmt);
    loadMacroInputs(scoredTrackerData, userInfo);
    updateCompanyInfo(companyData, selectedValues, companySelectedData);
    updateLatestDateArray(isAsOfDateToday);
    updateGeneratedScoreData({
        scoredTrackerData,
        isPitAdjSelected,
        loadPitAdj,
        isAsOfDateToday,
        companyData,
        selectedValues,
        companySelectedData,
        isLatestFinStmt,
        sizeAdjustmentData,
        scoringFinInputs,
        models,
        isEpd
    });
    RGRModalData.rgLatest = isLatestFinStmt;
    return { ...RGRModalData };
};

export default updateRGRModalData;