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

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

'use strict';
/**
 *
 * Uses <context>.<odata>,<context>.<client>
 *
 * @type {exports}
 */

const postProcessor = require('./resourceProcessorPost');
const putProcessor = require('./resourceProcessorPut');
const putPostLinksProcessor = require('./resourceProcessorPutPostLinks');
const deleteProcessor = require('./resourceProcessorDelete');
const deleteLinksProcessor = require('./resourceProcessorDeleteLinks');
const getProcessor = require('./resourceProcessorGet');
const MethodNotAllowedError = require('./../utils/errors/http/methodNotAllowed');
const NotImplementedError = require('./../utils/errors/http/notImplemented');
const db = require('./../db/connect');

exports.process = function (context, asyncDone) {
    db.connect(context, function (err, context) {
        if (err) {
            return asyncDone(err, asyncDone);
        }

        const method = context.request.method;

        switch (method) {
            case 'GET':
                return getProcessor.process(context, asyncDone);
            case 'POST':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.process(context, asyncDone);
                }
                return postProcessor.process(context, asyncDone);
            case 'PUT':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.process(context, asyncDone);
                }
                return putProcessor.process(context, asyncDone);
            case 'DELETE':
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.process(context, asyncDone);
                }
                return deleteProcessor.process(context, asyncDone);
            // We do not support PATCH or MERGE
            case 'PATCH':
                return asyncDone(
                    new MethodNotAllowedError('Method not allowed'),
                    context
                );
            default:
                return asyncDone(
                    new NotImplementedError('Not implemented'),
                    context
                );
        }
    });
};

exports.processInBatchCreateTables = function (context, asyncDone) {
    db.connect(context, function (err, context) {
        if (err) {
            return asyncDone(err, asyncDone);
        }

        const method = context.request.method;

        switch (method) {
            case 'GET':
                return asyncDone(null, context);
            case 'POST':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchCreateTables(
                        context,
                        asyncDone
                    );
                }
                return postProcessor.processInBatchCreateTables(
                    context,
                    asyncDone
                );
            case 'PUT':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchCreateTables(
                        context,
                        asyncDone
                    );
                }
                return putProcessor.processInBatchCreateTables(
                    context,
                    asyncDone
                );
            case 'DELETE':
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatchCreateTables(
                        context,
                        asyncDone
                    );
                }
                return deleteProcessor.processInBatchCreateTables(
                    context,
                    asyncDone
                );
            // We do not support PATCH or MERGE
            case 'PATCH':
                return asyncDone(
                    new MethodNotAllowedError('Method not allowed'),
                    context
                );

            default:
                return asyncDone(
                    new NotImplementedError('Not implemented'),
                    context
                );
        }
    });
};

exports.processInBatch = function (context, asyncDone) {
    db.connect(context, function (err, context) {
        if (err) {
            return asyncDone(err, asyncDone);
        }
        const method = context.request.method;

        switch (method) {
            case 'GET':
                return getProcessor.process(context, asyncDone);
            case 'POST':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatch(
                        context,
                        asyncDone
                    );
                }
                return postProcessor.processInBatch(context, asyncDone);
            case 'PUT':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatch(
                        context,
                        asyncDone
                    );
                }
                return putProcessor.processInBatch(context, asyncDone);
            case 'DELETE':
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatch(
                        context,
                        asyncDone
                    );
                }
                return deleteProcessor.processInBatch(context, asyncDone);
            // We do not support PATCH or MERGE
            case 'PATCH':
                return asyncDone(
                    new MethodNotAllowedError('Method not allowed'),
                    context
                );
            default:
                return asyncDone(
                    new NotImplementedError('Not implemented'),
                    context
                );
        }
    });
};

exports.processInBatchPreCommitRun = function (context, asyncDone) {
    db.connect(context, function (err, context) {
        if (err) {
            return asyncDone(err, asyncDone);
        }
        const method = context.request.method;

        switch (method) {
            case 'GET':
                return asyncDone(null, context);
            case 'POST':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPreCommitRun(
                        context,
                        asyncDone
                    );
                }
                return postProcessor.processInBatchPreCommitRun(
                    context,
                    asyncDone
                );
            case 'PUT':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPreCommitRun(
                        context,
                        asyncDone
                    );
                }
                return putProcessor.processInBatchPreCommitRun(
                    context,
                    asyncDone
                );
            case 'DELETE':
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatchPreCommitRun(
                        context,
                        asyncDone
                    );
                }
                return deleteProcessor.processInBatchPreCommitRun(
                    context,
                    asyncDone
                );
            // We do not support PATCH or MERGE
            case 'PATCH':
                return asyncDone(
                    new MethodNotAllowedError('Method not allowed'),
                    context
                );
            default:
                return asyncDone(
                    new NotImplementedError('Not implemented'),
                    context
                );
        }
    });
};

exports.processInBatchPostCommitRun = function (context, asyncDone) {
    db.connect(context, function (err, context) {
        if (err) {
            return asyncDone(err, asyncDone);
        }

        const method = context.request.method;

        switch (method) {
            case 'GET':
                return asyncDone(null, context);
            case 'POST':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPostCommitRun(
                        context,
                        asyncDone
                    );
                }
                return postProcessor.processInBatchPostCommitRun(
                    context,
                    asyncDone
                );
            case 'PUT':
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPostCommitRun(
                        context,
                        asyncDone
                    );
                }
                return putProcessor.processInBatchPostCommitRun(
                    context,
                    asyncDone
                );
            case 'DELETE':
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatchPostCommitRun(
                        context,
                        asyncDone
                    );
                }
                return deleteProcessor.processInBatchPostCommitRun(
                    context,
                    asyncDone
                );
            // We do not support PATCH or MERGE
            case 'PATCH':
                return asyncDone(
                    new MethodNotAllowedError('Method not allowed'),
                    context
                );
            default:
                return asyncDone(
                    new NotImplementedError('Not implemented'),
                    context
                );
        }
    });
};