function processRequest()

in source/api/services/package/lib/index.js [86:501]


function processRequest(event, ticket, cb) {

    let _response = {};

    let INVALID_PATH_ERR = {
        Error: ['Invalid path request ', event.resource, ', ', event.httpMethod].join('')
    };

    let _accessValidator = new AccessValidator();
    let _package = new ContentPackage();
    let _dataset = new Dataset();
    let _metadata = new Metadata();
    let _accessLog = new AccessLog();
    let _operation = '';

    if (event.resource === '/packages' && event.httpMethod === 'POST') {
        let _body = JSON.parse(event.body);
        _operation = 'reading package metadata governance';
        _metadata.getMetadataGovernance(_body, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(500, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}' && event.httpMethod === 'GET') {
        _operation = ['reading package', event.pathParameters.package_id].join(' ');
        _package.getPackage(event.pathParameters.package_id, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}' && event.httpMethod === 'DELETE') {
        _operation = ['deleting package', event.pathParameters.package_id].join(' ');
        let _authToken = _accessValidator.getAuthToken(event.headers);
        _package.deletePackage(event.pathParameters.package_id, _authToken, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}' && event.httpMethod === 'POST') {
        _operation = 'creating a new package';
        _package.createPackage(event, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}' && event.httpMethod === 'PUT') {
        _operation = ['updating package', event.pathParameters.package_id].join(' ');
        _package.updatePackage(event, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}/datasets' && event.httpMethod === 'GET') {
        _operation = ['listing datasets for package', event.pathParameters.package_id].join(' ');
        _dataset.getPackageDatasets(event.pathParameters.package_id, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}/datasets/{dataset_id}' && event.httpMethod === 'GET') {
        _operation = ['reading dataset', event.pathParameters.dataset_id, 'from package',
            event.pathParameters.package_id
        ].join(' ');
        _dataset.getPackageDataset(event.pathParameters.package_id, event.pathParameters.dataset_id, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(err.code, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });
    } else if (event.resource === '/packages/{package_id}/datasets/{dataset_id}' && event.httpMethod === 'DELETE') {
        _operation = ['deleting dataset', event.pathParameters.dataset_id, 'from package',
            event.pathParameters.package_id
        ].join(' ');
        _dataset.deletePackageDataset(event.pathParameters.package_id, event.pathParameters.dataset_id, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(err.code, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });
    } else if (event.resource === '/packages/{package_id}/datasets/{dataset_id}' && event.httpMethod === 'POST') {
        _operation = ['adding a new dataset in package', event.pathParameters.package_id].join(' ');
        _dataset.createPackageDataset(event.pathParameters.package_id, event.body, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}/datasets/{dataset_id}/process' && event.httpMethod === 'POST') {
        _operation = ['processing import manifest', event.pathParameters.dataset_id, 'for package',
            event.pathParameters.package_id
        ].join(' ');

        let _authToken = _accessValidator.getAuthToken(event.headers);
        _dataset.processPackageDatasetManifest(event.pathParameters.package_id, event.pathParameters.dataset_id,
            _authToken, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(err.code, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });
    } else if (event.resource === '/packages/{package_id}/metadata' && event.httpMethod === 'GET') {
        _operation = ['listing metadata for package', event.pathParameters.package_id].join(' ');
        _metadata.getAllPackageMetadata(event.pathParameters.package_id, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(500, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });
    } else if (event.resource === '/packages/{package_id}/metadata/{metadata_id}' && event.httpMethod === 'GET') {
        _operation = ['reading metadata', event.pathParameters.metadata_id, 'for package',
            event.pathParameters.package_id
        ].join(' ');
        _metadata.getPackageMetadata(event.pathParameters.package_id, event.pathParameters.metadata_id,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(500, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });
    } else if (event.resource === '/packages/{package_id}/metadata/{metadata_id}' && event.httpMethod === 'POST') {
        _operation = ['creating metadata for package', event.pathParameters.package_id].join(' ');

        let _authToken = _accessValidator.getAuthToken(event.headers);
        _metadata.createPackageMetadata(event.pathParameters.package_id, event.body, _authToken, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(500, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });

    } else if (event.resource === '/packages/{package_id}/tables' && event.httpMethod === 'GET') {
        _operation = ['listing AWS Glue tables for package', event.pathParameters.package_id].join(' ');

        _package.getTables(event.pathParameters.package_id, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });

    } else if (event.resource === '/packages/{package_id}/tables/{table_name}' && event.httpMethod === 'GET') {
        _operation = ['reading AWS Glue table ', event.pathParameters.table_name, 'for package',
            event.pathParameters.package_id
        ].join(' ');

        _package.viewTableData(event.pathParameters.package_id, decodeURI(event.pathParameters.table_name), ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });

    } else if (event.resource === '/packages/{package_id}/crawler' && event.httpMethod === 'GET') {
        _operation = ['reading AWS Glue crawler info for package', event.pathParameters.package_id].join(' ');

        _package.getCrawler(event.pathParameters.package_id, ticket, function(err, data) {
            if (err) {
                console.log(err);
                _response = buildOutput(err.code, err);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'failed/error',
                    function(err, resp) {
                        return cb(_response, null);
                    });
            } else {
                _response = buildOutput(200, data);
                _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                    'success',
                    function(err, resp) {
                        return cb(null, _response);
                    });
            }
        });

    } else if (event.resource === '/packages/{package_id}/crawler' && event.httpMethod === 'POST') {
        _operation = ['starting AWS Glue crawler for package', event.pathParameters.package_id].join(' ');

        _package.startCrawler(event.pathParameters.package_id, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(err.code, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });

    } else if (event.resource === '/packages/{package_id}/crawler' && event.httpMethod === 'PUT') {
        _operation = ['update or create AWS Glue crawler for package', event.pathParameters.package_id].join(' ');

        _package.updateOrCreateCrawler(event.pathParameters.package_id, ticket,
            function(err, data) {
                if (err) {
                    console.log(err);
                    _response = buildOutput(err.code, err);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'failed/error',
                        function(err, resp) {
                            return cb(_response, null);
                        });
                } else {
                    _response = buildOutput(200, data);
                    _accessLog.logEvent(event.requestContext.requestId, servicename, ticket.userid, _operation,
                        'success',
                        function(err, resp) {
                            return cb(null, _response);
                        });
                }
            });

    } else {
        _response = buildOutput(501, INVALID_PATH_ERR);
        return cb(_response, null);
    }

}