@sap/xsodata/lib/processor/resourceProcessorDeleteLinks.js

Expose data from a HANA database as OData V2 service with help of .xsodata files.

'use strict';

const async = require('async');
const connect = require('../db/connect');
const sqlDeleteLinks = require('./../sql/createDeleteLinksStatements');
const dataCollectorLinks = require('./../sql/dataCollectorLinks');
const dataCollectorDeleteLinks = require('./../sql/dataCollectorDeleteLinks');
const serializer = require('./../serializer/serializer');
const exitProcessor = require('./exitProcessor');
const utils = require('./../utils/utils');
const { eventDeleteLinks } = require('./eventActionHandler');

const eventBefore = eventDeleteLinks.eventBefore;
const eventAfter = eventDeleteLinks.eventAfter;
const eventPrecommit = eventDeleteLinks.eventPrecommit;
const eventPostCommit = eventDeleteLinks.eventPostCommit;

function insertTmpTableToRealTable(context, asyncDone) {
    const dbSeg = context.oData.dbSegmentLast;
    const entityType = dbSeg.entityType;
    const create = (entityType.modifications || {}).update || {};

    if (create.using) {
        exitProcessor.executeExit(
            create.using,
            'using',
            'delete',
            context,
            asyncDone
        );
    } else {
        dataCollectorLinks.insertTmpTableToRealTable(context, asyncDone);
    }
}

function executeDelete(context, asyncDone) {
    const dbSeg = context.oData.dbSegmentLast;
    const entityType = dbSeg.entityType;
    const _delete = (entityType.modifications || {})['delete'] || {};
    if (_delete.using) {
        exitProcessor.executeExit(
            _delete.using,
            'using',
            'delete',
            context,
            asyncDone
        );
    } else {
        dataCollectorDeleteLinks.deleteTable(context, asyncDone);
    }
}

function setStatus(context, asyncDone) {
    context.response.status(204);
    return asyncDone(null, context);
}

exports.process = function (context, asyncDone) {
    let execArr;
    const m2n = context.oData.dbSegmentLast.getOver() !== undefined;

    context.logger.silly('resourceProcessorDeleteLinks', 'process');

    if (m2n) {
        // INSERT into 3rd table
        context.oData.dbSegmentLast.m2n = true;
        execArr = [
            utils.injectContext(context),

            //preparation
            utils.try(
                sqlDeleteLinks.createDeleteLinksMNStatementsCreateTmpTables
            ),
            utils.try(dataCollectorLinks.createTmpTableMN), //create //NEW ORL

            // no payload for delete link
            utils.try(sqlDeleteLinks.createDeleteLinksMNStatementsInsert),
            utils.try(
                dataCollectorLinks.insertOldDataToPrincipalDependentTables
            ),
            utils.try(dataCollectorDeleteLinks.insertDataToDelTable), //insert NEW

            //execution
            utils.try(eventBefore),
            utils.try(executeDelete),
            utils.try(eventAfter),

            //commit handling
            utils.try(eventPrecommit),
            utils.try(dataCollectorLinks.commit),
            utils.try(eventPostCommit),

            // cleanup
            utils.try(dataCollectorLinks.truncateTempTablesMN),
            utils.try(dataCollectorLinks.dropTempTablesMN),
            utils.try(dataCollectorLinks.commit),

            utils.try(setStatus),
        ];
    } else {
        execArr = [
            utils.injectContext(context),

            //preparation
            utils.try(
                sqlDeleteLinks.createDeleteLinksStatementsCreateTmpTables
            ),
            utils.try(dataCollectorLinks.createTmpTables),

            // no payload for delete link
            utils.try(sqlDeleteLinks.createDeleteLinksStatementsInsert),
            utils.try(dataCollectorLinks.moveRecordNV_ToSelectStm),

            utils.try(dataCollectorLinks.insertOldDataToOldTable),
            utils.try(
                dataCollectorLinks.insertOldDataToPrincipalDependentTables
            ),
            utils.try(dataCollectorLinks.insertPayloadIntoTempTable),

            //execution
            utils.try(eventBefore),
            utils.try(insertTmpTableToRealTable),
            utils.try(eventAfter),

            //commit handling
            utils.try(eventPrecommit),
            utils.try(dataCollectorLinks.commit),
            utils.try(eventPostCommit),

            // cleanup
            utils.try(dataCollectorLinks.truncateTempTables),
            utils.try(dataCollectorLinks.dropTempTables),
            utils.try(dataCollectorLinks.commit),

            //post processing
            utils.try(serializer.serializeNoContent),
        ];
    }

    async.waterfall(execArr, function (err, context) {
        if (err) {
            const dbClient = context.db.client;
            if (dbClient) {
                //ROLLBack the changes
                return connect.dbRollback(context, dbClient, function (errDB) {
                    if (errDB) {
                        return asyncDone(errDB, context);
                    }

                    return asyncDone(err, context);
                });
            }
        }
        return asyncDone(err, context);
    });
};

exports.processInBatchCreateTables = function (context, asyncDone) {
    context.logger.silly(
        'resourceProcessorDeleteLinks',
        'processInBatchCreateTables'
    );

    let execArr;
    const m2n = context.oData.dbSegmentLast.getOver() !== undefined;
    if (m2n) {
        // INSERT into 3rd table
        context.oData.dbSegmentLast.m2n = true;
        execArr = [
            utils.injectContext(context),

            //preparation
            utils.try(
                sqlDeleteLinks.createDeleteLinksMNStatementsCreateTmpTables
            ),
            utils.try(dataCollectorLinks.createTmpTableMN),
        ];
    } else {
        execArr = [
            utils.injectContext(context),

            //preparation
            utils.try(
                sqlDeleteLinks.createDeleteLinksStatementsCreateTmpTables
            ),
            utils.try(dataCollectorLinks.createTmpTables), //create //NEW ORL
        ];
    }

    async.waterfall(execArr, function (err, context) {
        return asyncDone(err, context);
    });
};

exports.processInBatch = function (context, asyncDone) {
    context.logger.silly('resourceProcessorDeleteLinks', 'processInBatch');

    let execArr;
    const m2n = context.oData.dbSegmentLast.getOver() !== undefined;
    if (m2n) {
        // INSERT into 3rd table
        context.oData.dbSegmentLast.m2n = true;
        execArr = [
            utils.injectContext(context),

            //preparation
            // no payload for delete link
            utils.try(sqlDeleteLinks.createDeleteLinksMNStatementsInsert),
            utils.try(
                dataCollectorLinks.insertOldDataToPrincipalDependentTables
            ),
            utils.try(dataCollectorDeleteLinks.insertDataToDelTable),

            //execution
            utils.try(eventBefore),
            utils.try(executeDelete), //insert real
            utils.try(eventAfter),
        ];
    } else {
        execArr = [
            utils.injectContext(context),

            //preparation
            // no payload for delete link
            utils.try(sqlDeleteLinks.createDeleteLinksStatementsInsert),
            utils.try(dataCollectorLinks.moveRecordNV_ToSelectStm), //no change
            utils.try(dataCollectorLinks.insertOldDataToOldTable),
            utils.try(
                dataCollectorLinks.insertOldDataToPrincipalDependentTables
            ),
            utils.try(dataCollectorLinks.insertPayloadIntoTempTable), //insert NEW

            //execution
            utils.try(eventBefore),
            utils.try(insertTmpTableToRealTable),
            utils.try(eventAfter),
        ];
    }

    async.waterfall(execArr, function (err, context) {
        return asyncDone(err, context);
    });
};

exports.processInBatchPreCommitRun = function (context, asyncDone) {
    context.logger.silly(
        'resourceProcessorDeleteLinks',
        'processInBatchPreCommitRun'
    );

    async.waterfall(
        [utils.injectContext(context), utils.try(eventPrecommit)],

        function (err, context) {
            return asyncDone(err, context);
        }
    );
};

exports.processInBatchPostCommitRun = function (context, asyncDone) {
    context.logger.silly(
        'resourceProcessorDeleteLinks',
        'processInBatchPostCommitRun'
    );

    async.waterfall(
        [
            utils.injectContext(context),

            utils.try(eventPostCommit),

            // cleanup
            utils.try(dataCollectorLinks.truncateTempTables),
            utils.try(dataCollectorLinks.dropTempTables),

            //post processing
            utils.try(serializer.serializeNoContent),
        ],
        function (err, context) {
            return asyncDone(err, context);
        }
    );
};