@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}
 */

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

exports.process = function (context, asyncDone) {

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

        var 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);
                } else {
                    return postProcessor.process(context, asyncDone);
                }
                break;
            case "PUT":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.process(context, asyncDone);
                } else {
                    return putProcessor.process(context, asyncDone);
                }
                break;
            case "DELETE":
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.process(context, asyncDone);
                } else {
                    return deleteProcessor.process(context, asyncDone);
                }
                break;
            // 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);
        }

        var method = context.request.method;

        switch (method) {
            case "GET":
                return asyncDone(null, context);
            case "POST":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchCreateTables(context, asyncDone);
                } else {
                    return postProcessor.processInBatchCreateTables(context, asyncDone);
                }
                break;
            case "PUT":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchCreateTables(context, asyncDone);
                } else {
                    return putProcessor.processInBatchCreateTables(context, asyncDone);
                }
                break;
            case "DELETE":
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatchCreateTables(context, asyncDone);
                } else {
                    return deleteProcessor.processInBatchCreateTables(context, asyncDone);
                }
                break;
            // 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);
        }
        var 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);
                } else {
                    return postProcessor.processInBatch(context, asyncDone);
                }
                break;
            case "PUT":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatch(context, asyncDone);
                } else {
                    return putProcessor.processInBatch(context, asyncDone);
                }
                break;
            case "DELETE":
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatch(context, asyncDone);
                } else {
                    return deleteProcessor.processInBatch(context, asyncDone);
                }
                break;
            // 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);
        }
        var method = context.request.method;

        switch (method) {
            case "GET":
                return asyncDone(null, context);
            case "POST":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPreCommitRun(context, asyncDone);
                } else {
                    return postProcessor.processInBatchPreCommitRun(context, asyncDone);
                }
                break;
            case "PUT":
                if (context.oData.dbSegment.isLinks) {
                    return putPostLinksProcessor.processInBatchPreCommitRun(context, asyncDone);
                } else {
                    return putProcessor.processInBatchPreCommitRun(context, asyncDone);
                }
                break;
            case "DELETE":
                if (context.oData.dbSegment.isLinks) {
                    return deleteLinksProcessor.processInBatchPreCommitRun(context, asyncDone);
                } else {
                    return deleteProcessor.processInBatchPreCommitRun(context, asyncDone);
                }
                break;
            // 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);
        }

        var method = context.request.method;

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