New project structure

Beta of extract.js for extracting english locale

server/routes/rest/account.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const users = require('../../models/users');
+const contextHelpers = require('../../lib/context-helpers');
+
+const router = require('../../lib/router-async').create();
+
+
+router.getAsync('/account', passport.loggedIn, async (req, res) => {
+    const user = await users.getById(contextHelpers.getAdminContext(), req.user.id);
+    user.hash = users.hash(user);
+    return res.json(user);
+});
+
+router.postAsync('/account', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const data = req.body;
+    data.id = req.user.id;
+
+    await users.updateWithConsistencyCheck(contextHelpers.getAdminContext(), req.body, true);
+    return res.json();
+});
+
+router.postAsync('/account-validate', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const data = req.body;
+    data.id = req.user.id;
+
+    return res.json(await users.serverValidate(contextHelpers.getAdminContext(), data, true));
+});
+
+router.getAsync('/access-token', passport.loggedIn, async (req, res) => {
+    const accessToken = await users.getAccessToken(req.user.id);
+    return res.json(accessToken);
+
+});
+
+router.postAsync('/access-token-reset', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const accessToken = await users.resetAccessToken(req.user.id);
+    return res.json(accessToken);
+});
+
+
+router.post('/login', passport.csrfProtection, passport.restLogin);
+router.post('/logout', passport.csrfProtection, passport.restLogout);
+
+router.postAsync('/password-reset-send', passport.csrfProtection, async (req, res) => {
+    await users.sendPasswordReset(req.language, req.body.usernameOrEmail);
+    return res.json();
+});
+
+router.postAsync('/password-reset-validate', passport.csrfProtection, async (req, res) => {
+    const isValid = await users.isPasswordResetTokenValid(req.body.username, req.body.resetToken);
+    return res.json(isValid);
+});
+
+router.postAsync('/password-reset', passport.csrfProtection, async (req, res) => {
+    await users.resetPassword(req.body.username, req.body.resetToken, req.body.password);
+    return res.json();
+});
+
+router.postAsync('/restricted-access-token', passport.loggedIn, async (req, res) => {
+    const restrictedAccessToken = await users.getRestrictedAccessToken(req.context, req.body.method, req.body.params);
+    return res.json(restrictedAccessToken);
+
+});
+
+router.putAsync('/restricted-access-token', passport.loggedIn, async (req, res) => {
+    await users.refreshRestrictedAccessToken(req.context, req.body.token);
+    return res.json();
+});
+
+module.exports = router;

server/routes/rest/blacklist.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const blacklist = require('../../models/blacklist');
+
+const router = require('../../lib/router-async').create();
+
+
+router.postAsync('/blacklist-table', passport.loggedIn, async (req, res) => {
+    return res.json(await blacklist.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/blacklist', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await blacklist.add(req.context, req.body.email));
+});
+
+router.deleteAsync('/blacklist/:email', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await blacklist.remove(req.context, req.params.email);
+    return res.json();
+});
+
+router.postAsync('/blacklist-validate', passport.loggedIn, async (req, res) => {
+    return res.json(await blacklist.serverValidate(req.context, req.body));
+});
+
+module.exports = router;

server/routes/rest/campaigns.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const campaigns = require('../../models/campaigns');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/campaigns-table', passport.loggedIn, async (req, res) => {
+    return res.json(await campaigns.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/campaigns-with-content-table', passport.loggedIn, async (req, res) => {
+    return res.json(await campaigns.listWithContentDTAjax(req.context, req.body));
+});
+
+router.postAsync('/campaigns-others-by-list-table/:campaignId/:listIds', passport.loggedIn, async (req, res) => {
+    return res.json(await campaigns.listOthersWhoseListsAreIncludedDTAjax(req.context, castToInteger(req.params.campaignId), req.params.listIds.split(';').map(x => castToInteger(x)), req.body));
+});
+
+router.postAsync('/campaigns-children/:campaignId', passport.loggedIn, async (req, res) => {
+    return res.json(await campaigns.listChildrenDTAjax(req.context, castToInteger(req.params.campaignId), req.body));
+});
+
+router.postAsync('/campaigns-test-users-table/:campaignId', passport.loggedIn, async (req, res) => {
+    return res.json(await campaigns.listTestUsersDTAjax(req.context, castToInteger(req.params.campaignId), req.body));
+});
+
+router.getAsync('/campaigns-settings/:campaignId', passport.loggedIn, async (req, res) => {
+    const campaign = await campaigns.getById(req.context, castToInteger(req.params.campaignId), true, campaigns.Content.WITHOUT_SOURCE_CUSTOM);
+    campaign.hash = campaigns.hash(campaign, campaigns.Content.WITHOUT_SOURCE_CUSTOM);
+    return res.json(campaign);
+});
+
+router.getAsync('/campaigns-stats/:campaignId', passport.loggedIn, async (req, res) => {
+    const campaign = await campaigns.getById(req.context, castToInteger(req.params.campaignId), true, campaigns.Content.SETTINGS_WITH_STATS);
+    return res.json(campaign);
+});
+
+router.getAsync('/campaigns-content/:campaignId', passport.loggedIn, async (req, res) => {
+    const campaign = await campaigns.getById(req.context, castToInteger(req.params.campaignId), true, campaigns.Content.ONLY_SOURCE_CUSTOM);
+    campaign.hash = campaigns.hash(campaign, campaigns.Content.ONLY_SOURCE_CUSTOM);
+    return res.json(campaign);
+});
+
+router.postAsync('/campaigns', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.create(req.context, req.body));
+});
+
+router.putAsync('/campaigns-settings/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.campaignId);
+
+    await campaigns.updateWithConsistencyCheck(req.context, entity, campaigns.Content.WITHOUT_SOURCE_CUSTOM);
+    return res.json();
+});
+
+router.putAsync('/campaigns-content/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.campaignId);
+
+    await campaigns.updateWithConsistencyCheck(req.context, entity, campaigns.Content.ONLY_SOURCE_CUSTOM);
+    return res.json();
+});
+
+router.deleteAsync('/campaigns/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await campaigns.remove(req.context, castToInteger(req.params.campaignId));
+    return res.json();
+});
+
+router.postAsync('/campaign-start/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.start(req.context, castToInteger(req.params.campaignId), null));
+});
+
+router.postAsync('/campaign-start-at/:campaignId/:dateTime', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.start(req.context, castToInteger(req.params.campaignId), new Date(Number.parseInt(req.params.dateTime))));
+});
+
+
+router.postAsync('/campaign-stop/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.stop(req.context, castToInteger(req.params.campaignId)));
+});
+
+router.postAsync('/campaign-reset/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.reset(req.context, castToInteger(req.params.campaignId)));
+});
+
+router.postAsync('/campaign-enable/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.enable(req.context, castToInteger(req.params.campaignId), null));
+});
+
+router.postAsync('/campaign-disable/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await campaigns.disable(req.context, castToInteger(req.params.campaignId), null));
+});
+
+
+module.exports = router;

server/routes/rest/editors.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+
+const bluebird = require('bluebird');
+const premailerApi = require('premailer-api');
+const premailerPrepareAsync = bluebird.promisify(premailerApi.prepare);
+
+const router = require('../../lib/router-async').create();
+
+router.postAsync('/html-to-text', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    if (!req.body.html) {
+        return res.json({text: ''}); // Premailer crashes very hard when html is empty
+    }
+
+    const email = await premailerPrepareAsync({
+        html: req.body.html,
+        fetchHTML: false
+    });
+
+    res.json({text: email.text.replace(/%5B/g, '[').replace(/%5D/g, ']')});
+
+});
+
+module.exports = router;

server/routes/rest/fields.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const fields = require('../../models/fields');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/fields-table/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await fields.listDTAjax(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.postAsync('/fields-grouped-table/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await fields.listGroupedDTAjax(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.getAsync('/fields/:listId/:fieldId', passport.loggedIn, async (req, res) => {
+    const entity = await fields.getById(req.context, castToInteger(req.params.listId), castToInteger(req.params.fieldId));
+    entity.hash = fields.hash(entity);
+    return res.json(entity);
+});
+
+router.getAsync('/fields/:listId', passport.loggedIn, async (req, res) => {
+    const rows = await fields.list(req.context, castToInteger(req.params.listId));
+    return res.json(rows);
+});
+
+router.getAsync('/fields-grouped/:listId', passport.loggedIn, async (req, res) => {
+    const rows = await fields.listGrouped(req.context, castToInteger(req.params.listId));
+    return res.json(rows);
+});
+
+router.postAsync('/fields/:listId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await fields.create(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.putAsync('/fields/:listId/:fieldId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.fieldId);
+
+    await fields.updateWithConsistencyCheck(req.context, castToInteger(req.params.listId), entity);
+    return res.json();
+});
+
+router.deleteAsync('/fields/:listId/:fieldId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await fields.remove(req.context, castToInteger(req.params.listId), castToInteger(req.params.fieldId));
+    return res.json();
+});
+
+router.postAsync('/fields-validate/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await fields.serverValidate(req.context, castToInteger(req.params.listId), req.body));
+});
+
+
+module.exports = router;

server/routes/rest/files.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const files = require('../../models/files');
+const router = require('../../lib/router-async').create();
+const fileHelpers = require('../../lib/file-helpers');
+const {castToInteger} = require('../../lib/helpers');
+
+router.postAsync('/files-table/:type/:subType/:entityId', passport.loggedIn, async (req, res) => {
+    return res.json(await files.listDTAjax(req.context, req.params.type, req.params.subType, castToInteger(req.params.entityId), req.body));
+});
+
+router.getAsync('/files-list/:type/:subType/:entityId', passport.loggedIn, async (req, res) => {
+    return res.json(await files.list(req.context, req.params.type, req.params.subType, castToInteger(req.params.entityId)));
+});
+
+
+router.getAsync('/files/:type/:subType/:fileId', passport.loggedIn, async (req, res) => {
+    const file = await files.getFileById(req.context, req.params.type, req.params.subType, castToInteger(req.params.fileId));
+    res.type(file.mimetype);
+    return res.download(file.path, file.name);
+});
+
+router.deleteAsync('/files/:type/:subType/:fileId', passport.loggedIn, async (req, res) => {
+    await files.removeFile(req.context, req.params.type, req.params.subType, castToInteger(req.params.fileId));
+    return res.json();
+});
+
+fileHelpers.installUploadHandler(router, '/files/:type/:subType/:entityId');
+
+module.exports = router;

server/routes/rest/forms.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const forms = require('../../models/forms');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/forms-table', passport.loggedIn, async (req, res) => {
+    return res.json(await forms.listDTAjax(req.context, req.body));
+});
+
+router.getAsync('/forms/:formId', passport.loggedIn, async (req, res) => {
+    const entity = await forms.getById(req.context, castToInteger(req.params.formId));
+    entity.hash = forms.hash(entity);
+    return res.json(entity);
+});
+
+router.postAsync('/forms', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await forms.create(req.context, req.body));
+});
+
+router.putAsync('/forms/:formId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.formId);
+
+    await forms.updateWithConsistencyCheck(req.context, entity);
+    return res.json();
+});
+
+router.deleteAsync('/forms/:formId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await forms.remove(req.context, castToInteger(req.params.formId));
+    return res.json();
+});
+
+router.postAsync('/forms-validate', passport.loggedIn, async (req, res) => {
+    return res.json(await forms.serverValidate(req.context, req.body));
+});
+
+
+module.exports = router;

server/routes/rest/import-runs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const importRuns = require('../../models/import-runs');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+router.postAsync('/import-runs-table/:listId/:importId', passport.loggedIn, async (req, res) => {
+    return res.json(await importRuns.listDTAjax(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId), req.body));
+});
+
+router.postAsync('/import-run-failed-table/:listId/:importId/:importRunId', passport.loggedIn, async (req, res) => {
+    return res.json(await importRuns.listFailedDTAjax(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId), castToInteger(req.params.importRunId), req.body));
+});
+
+router.getAsync('/import-runs/:listId/:importId/:runId', passport.loggedIn, async (req, res) => {
+    const entity = await importRuns.getById(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId), castToInteger(req.params.runId));
+    return res.json(entity);
+});
+
+module.exports = router;

server/routes/rest/imports.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const imports = require('../../models/imports');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+const path = require('path');
+const files = require('../../models/files');
+const uploadedFilesDir = path.join(files.filesDir, 'uploaded');
+
+const multer = require('multer')({
+    dest: uploadedFilesDir
+});
+
+router.postAsync('/imports-table/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await imports.listDTAjax(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.getAsync('/imports/:listId/:importId', passport.loggedIn, async (req, res) => {
+    const entity = await imports.getById(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId), true);
+    entity.hash = imports.hash(entity);
+    return res.json(entity);
+});
+
+const fileFields = [
+    {name: 'csvFile', maxCount: 1}
+];
+
+router.postAsync('/imports/:listId', passport.loggedIn, passport.csrfProtection, multer.fields(fileFields), async (req, res) => {
+    const entity = JSON.parse(req.body.entity);
+
+    return res.json(await imports.create(req.context, castToInteger(req.params.listId), entity, req.files));
+});
+
+router.putAsync('/imports/:listId/:importId', passport.loggedIn, passport.csrfProtection, multer.fields(fileFields), async (req, res) => {
+    const entity = JSON.parse(req.body.entity);
+    entity.id = castToInteger(req.params.importId);
+
+    await imports.updateWithConsistencyCheck(req.context, castToInteger(req.params.listId), entity, req.files);
+    return res.json();
+});
+
+router.deleteAsync('/imports/:listId/:importId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await imports.remove(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId));
+    return res.json();
+});
+
+router.postAsync('/import-start/:listId/:importId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await imports.start(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId)));
+});
+
+router.postAsync('/import-stop/:listId/:importId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await imports.stop(req.context, castToInteger(req.params.listId), castToInteger(req.params.importId)));
+});
+
+module.exports = router;

server/routes/rest/lists.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const lists = require('../../models/lists');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/lists-table', passport.loggedIn, async (req, res) => {
+    return res.json(await lists.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/lists-with-segment-by-campaign-table/:campaignId', passport.loggedIn, async (req, res) => {
+    return res.json(await lists.listWithSegmentByCampaignDTAjax(req.context, castToInteger(req.params.campaignId), req.body));
+});
+
+router.getAsync('/lists/:listId', passport.loggedIn, async (req, res) => {
+    const list = await lists.getByIdWithListFields(req.context, castToInteger(req.params.listId));
+    list.hash = lists.hash(list);
+    return res.json(list);
+});
+
+router.postAsync('/lists', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await lists.create(req.context, req.body));
+});
+
+router.putAsync('/lists/:listId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.listId);
+
+    await lists.updateWithConsistencyCheck(req.context, entity);
+    return res.json();
+});
+
+router.deleteAsync('/lists/:listId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await lists.remove(req.context, castToInteger(req.params.listId));
+    return res.json();
+});
+
+
+module.exports = router;

server/routes/rest/mosaico-templates.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const mosaicoTemplates = require('../../models/mosaico-templates');
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.getAsync('/mosaico-templates/:mosaicoTemplateId', passport.loggedIn, async (req, res) => {
+    const mosaicoTemplate = await mosaicoTemplates.getById(req.context, castToInteger(req.params.mosaicoTemplateId));
+    mosaicoTemplate.hash = mosaicoTemplates.hash(mosaicoTemplate);
+    return res.json(mosaicoTemplate);
+});
+
+router.postAsync('/mosaico-templates', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await mosaicoTemplates.create(req.context, req.body));
+});
+
+router.putAsync('/mosaico-templates/:mosaicoTemplateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const mosaicoTemplate = req.body;
+    mosaicoTemplate.id = castToInteger(req.params.mosaicoTemplateId);
+
+    await mosaicoTemplates.updateWithConsistencyCheck(req.context, mosaicoTemplate);
+    return res.json();
+});
+
+router.deleteAsync('/mosaico-templates/:mosaicoTemplateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await mosaicoTemplates.remove(req.context, castToInteger(req.params.mosaicoTemplateId));
+    return res.json();
+});
+
+router.postAsync('/mosaico-templates-table', passport.loggedIn, async (req, res) => {
+    return res.json(await mosaicoTemplates.listDTAjax(req.context, req.body));
+});
+
+module.exports = router;

server/routes/rest/namespaces.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const namespaces = require('../../models/namespaces');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.getAsync('/namespaces/:nsId', passport.loggedIn, async (req, res) => {
+    const ns = await namespaces.getById(req.context, castToInteger(req.params.nsId));
+
+    ns.hash = namespaces.hash(ns);
+
+    return res.json(ns);
+});
+
+router.postAsync('/namespaces', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await namespaces.create(req.context, req.body));
+});
+
+router.putAsync('/namespaces/:nsId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const ns = req.body;
+    ns.id = castToInteger(req.params.nsId);
+
+    await namespaces.updateWithConsistencyCheck(req.context, ns);
+    return res.json();
+});
+
+router.deleteAsync('/namespaces/:nsId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await namespaces.remove(req.context, castToInteger(req.params.nsId));
+    return res.json();
+});
+
+router.getAsync('/namespaces-tree', passport.loggedIn, async (req, res) => {
+
+    const tree = await namespaces.listTree(req.context);
+
+    return res.json(tree);
+});
+
+
+module.exports = router;

server/routes/rest/report-templates.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const reportTemplates = require('../../models/report-templates');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.getAsync('/report-templates/:reportTemplateId', passport.loggedIn, async (req, res) => {
+    const reportTemplate = await reportTemplates.getById(req.context, castToInteger(req.params.reportTemplateId));
+    reportTemplate.hash = reportTemplates.hash(reportTemplate);
+    return res.json(reportTemplate);
+});
+
+router.postAsync('/report-templates', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await reportTemplates.create(req.context, req.body));
+});
+
+router.putAsync('/report-templates/:reportTemplateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const reportTemplate = req.body;
+    reportTemplate.id = castToInteger(req.params.reportTemplateId);
+
+    await reportTemplates.updateWithConsistencyCheck(req.context, reportTemplate);
+    return res.json();
+});
+
+router.deleteAsync('/report-templates/:reportTemplateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await reportTemplates.remove(req.context, castToInteger(req.params.reportTemplateId));
+    return res.json();
+});
+
+router.postAsync('/report-templates-table', passport.loggedIn, async (req, res) => {
+    return res.json(await reportTemplates.listDTAjax(req.context, req.body));
+});
+
+router.getAsync('/report-template-user-fields/:reportTemplateId', passport.loggedIn, async (req, res) => {
+    const userFields = await reportTemplates.getUserFieldsById(req.context, castToInteger(req.params.reportTemplateId));
+    return res.json(userFields);
+});
+
+module.exports = router;

server/routes/rest/reports.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const reports = require('../../models/reports');
+const reportProcessor = require('../../lib/report-processor');
+const reportHelpers = require('../../lib/report-helpers');
+const shares = require('../../models/shares');
+const contextHelpers = require('../../lib/context-helpers');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+const fs = require('fs-extra');
+
+router.getAsync('/reports/:reportId', passport.loggedIn, async (req, res) => {
+    const report = await reports.getByIdWithTemplate(req.context, castToInteger(req.params.reportId));
+    report.hash = reports.hash(report);
+    return res.json(report);
+});
+
+router.postAsync('/reports', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await reports.create(req.context, req.body));
+});
+
+router.putAsync('/reports/:reportId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const report = req.body;
+    report.id = castToInteger(req.params.reportId);
+
+    await reports.updateWithConsistencyCheck(req.context, report);
+    return res.json();
+});
+
+router.deleteAsync('/reports/:reportId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await reports.remove(req.context, castToInteger(req.params.reportId));
+    return res.json();
+});
+
+router.postAsync('/reports-table', passport.loggedIn, async (req, res) => {
+    return res.json(await reports.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/report-start/:id', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const id = castToInteger(req.params.id);
+
+    await shares.enforceEntityPermission(req.context, 'report', id, 'execute');
+
+    const report = await reports.getByIdWithTemplate(contextHelpers.getAdminContext(), id, false);
+    await shares.enforceEntityPermission(req.context, 'reportTemplate', report.report_template, 'execute');
+
+    await reportProcessor.start(id);
+    res.json();
+});
+
+router.postAsync('/report-stop/:id', async (req, res) => {
+    const id = castToInteger(req.params.id);
+
+    await shares.enforceEntityPermission(req.context, 'report', id, 'execute');
+
+    const report = await reports.getByIdWithTemplate(contextHelpers.getAdminContext(), id, false);
+    await shares.enforceEntityPermission(req.context, 'reportTemplate', report.report_template, 'execute');
+
+    await reportProcessor.stop(id);
+    res.json();
+});
+
+router.getAsync('/report-content/:id', async (req, res) => {
+    const id = castToInteger(req.params.id);
+
+    await shares.enforceEntityPermission(req.context, 'report', id, 'viewContent');
+
+    const report = await reports.getByIdWithTemplate(contextHelpers.getAdminContext(), id, false);
+    const file = reportHelpers.getReportContentFile(report);
+
+    if (await fs.pathExists(file)) {
+        res.sendFile(file);
+    } else {
+        res.send('');
+    }
+});
+
+router.getAsync('/report-output/:id', async (req, res) => {
+    const id = castToInteger(req.params.id);
+
+    await shares.enforceEntityPermission(req.context, 'report', id, 'viewOutput');
+
+    const report = await reports.getByIdWithTemplate(contextHelpers.getAdminContext(), id, false);
+    const file = reportHelpers.getReportOutputFile(report);
+
+    if (await fs.pathExists(file)) {
+        res.sendFile(file);
+    } else {
+        res.send('');
+    }
+});
+
+
+module.exports = router;

server/routes/rest/segments.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const segments = require('../../models/segments');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/segments-table/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await segments.listDTAjax(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.getAsync('/segments/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await segments.listIdName(req.context, castToInteger(req.params.listId)));
+});
+
+router.getAsync('/segments/:listId/:segmentId', passport.loggedIn, async (req, res) => {
+    const segment = await segments.getById(req.context, castToInteger(req.params.listId), castToInteger(req.params.segmentId));
+    segment.hash = segments.hash(segment);
+    return res.json(segment);
+});
+
+router.postAsync('/segments/:listId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await segments.create(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.putAsync('/segments/:listId/:segmentId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.segmentId);
+
+    await segments.updateWithConsistencyCheck(req.context, castToInteger(req.params.listId), entity);
+    return res.json();
+});
+
+router.deleteAsync('/segments/:listId/:segmentId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await segments.remove(req.context, castToInteger(req.params.listId), castToInteger(req.params.segmentId));
+    return res.json();
+});
+
+
+module.exports = router;

server/routes/rest/send-configurations.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const sendConfigurations = require('../../models/send-configurations');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.getAsync('/send-configurations-private/:sendConfigurationId', passport.loggedIn, async (req, res) => {
+    const sendConfiguration = await sendConfigurations.getById(req.context, castToInteger(req.params.sendConfigurationId), true, true);
+    sendConfiguration.hash = sendConfigurations.hash(sendConfiguration);
+    return res.json(sendConfiguration);
+});
+
+router.getAsync('/send-configurations-public/:sendConfigurationId', passport.loggedIn, async (req, res) => {
+    const sendConfiguration = await sendConfigurations.getById(req.context, castToInteger(req.params.sendConfigurationId), true, false);
+    sendConfiguration.hash = sendConfigurations.hash(sendConfiguration);
+    return res.json(sendConfiguration);
+});
+
+router.postAsync('/send-configurations', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await sendConfigurations.create(req.context, req.body));
+});
+
+router.putAsync('/send-configurations/:sendConfigurationId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const sendConfiguration = req.body;
+    sendConfiguration.id = castToInteger(req.params.sendConfigurationId);
+
+    await sendConfigurations.updateWithConsistencyCheck(req.context, sendConfiguration);
+    return res.json();
+});
+
+router.deleteAsync('/send-configurations/:sendConfigurationId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await sendConfigurations.remove(req.context, castToInteger(req.params.sendConfigurationId));
+    return res.json();
+});
+
+router.postAsync('/send-configurations-table', passport.loggedIn, async (req, res) => {
+    return res.json(await sendConfigurations.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/send-configurations-with-send-permission-table', passport.loggedIn, async (req, res) => {
+    return res.json(await sendConfigurations.listWithSendPermissionDTAjax(req.context, req.body));
+});
+
+module.exports = router;

server/routes/rest/settings.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const settings = require('../../models/settings');
+
+const router = require('../../lib/router-async').create();
+
+
+router.getAsync('/settings', passport.loggedIn, async (req, res) => {
+    const configItems = await settings.get(req.context);
+    configItems.hash = settings.hash(configItems);
+    return res.json(configItems);
+});
+
+router.putAsync('/settings', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const configItems = req.body;
+    await settings.set(req.context, configItems);
+    return res.json();
+});
+
+
+module.exports = router;

server/routes/rest/shares.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const shares = require('../../models/shares');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+router.postAsync('/shares-table-by-entity/:entityTypeId/:entityId', passport.loggedIn, async (req, res) => {
+    return res.json(await shares.listByEntityDTAjax(req.context, req.params.entityTypeId, castToInteger(req.params.entityId), req.body));
+});
+
+router.postAsync('/shares-table-by-user/:entityTypeId/:userId', passport.loggedIn, async (req, res) => {
+    return res.json(await shares.listByUserDTAjax(req.context, req.params.entityTypeId, castToInteger(req.params.userId), req.body));
+});
+
+router.postAsync('/shares-unassigned-users-table/:entityTypeId/:entityId', passport.loggedIn, async (req, res) => {
+    return res.json(await shares.listUnassignedUsersDTAjax(req.context, req.params.entityTypeId, castToInteger(req.params.entityId), req.body));
+});
+
+router.postAsync('/shares-roles-table/:entityTypeId', passport.loggedIn, async (req, res) => {
+    return res.json(await shares.listRolesDTAjax(req.params.entityTypeId, req.body));
+});
+
+router.putAsync('/shares', passport.loggedIn, async (req, res) => {
+    const body = req.body;
+    await shares.assign(req.context, body.entityTypeId, body.entityId, body.userId, body.role);
+
+    return res.json();
+});
+
+/*
+ Checks if entities with a given permission exist.
+
+ Accepts format:
+ {
+   XXX1: {
+     entityTypeId: ...
+     requiredOperations: [ ... ]
+   },
+
+   XXX2: {
+     entityTypeId: ...
+     requiredOperations: [ ... ]
+   }
+ }
+
+ Returns:
+ {
+   XXX1: true
+   XXX2: false
+ }
+ */
+router.postAsync('/permissions-check', passport.loggedIn, async (req, res) => {
+    const body = req.body;
+    const result = {};
+
+    for (const reqKey in body) {
+        if (body[reqKey].entityId) {
+            result[reqKey] = await shares.checkEntityPermission(req.context, body[reqKey].entityTypeId, body[reqKey].entityId, body[reqKey].requiredOperations);
+        } else {
+            result[reqKey] = await shares.checkTypePermission(req.context, body[reqKey].entityTypeId, body[reqKey].requiredOperations);
+        }
+    }
+
+    return res.json(result);
+});
+
+router.postAsync('/permissions-rebuild', passport.loggedIn, async (req, res) => {
+    shares.enforceGlobalPermission(req.context, 'rebuildPermissions');
+    await shares.rebuildPermissions();
+    return res.json(result);
+});
+
+
+
+module.exports = router;

server/routes/rest/subscriptions.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const subscriptions = require('../../models/subscriptions');
+const { SubscriptionSource } = require('../../../shared/lists');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/subscriptions-table/:listId/:segmentId?', passport.loggedIn, async (req, res) => {
+    return res.json(await subscriptions.listDTAjax(req.context, castToInteger(req.params.listId), req.params.segmentId ? castToInteger(req.params.segmentId) : null, req.body));
+});
+
+router.postAsync('/subscriptions-test-user-table/:listCid', passport.loggedIn, async (req, res) => {
+    return res.json(await subscriptions.listTestUsersDTAjax(req.context, req.params.listCid, req.body));
+});
+
+router.getAsync('/subscriptions/:listId/:subscriptionId', passport.loggedIn, async (req, res) => {
+    const entity = await subscriptions.getById(req.context, castToInteger(req.params.listId), castToInteger(req.params.subscriptionId));
+    entity.hash = await subscriptions.hashByList(castToInteger(req.params.listId), entity);
+    return res.json(entity);
+});
+
+router.postAsync('/subscriptions/:listId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await subscriptions.create(req.context, castToInteger(req.params.listId), req.body, SubscriptionSource.ADMIN_FORM));
+});
+
+router.putAsync('/subscriptions/:listId/:subscriptionId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.subscriptionId);
+
+    await subscriptions.updateWithConsistencyCheck(req.context, castToInteger(req.params.listId), entity, SubscriptionSource.ADMIN_FORM);
+    return res.json();
+});
+
+router.deleteAsync('/subscriptions/:listId/:subscriptionId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await subscriptions.remove(req.context, castToInteger(req.params.listId), castToInteger(req.params.subscriptionId));
+    return res.json();
+});
+
+router.postAsync('/subscriptions-validate/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await subscriptions.serverValidate(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.postAsync('/subscriptions-unsubscribe/:listId/:subscriptionId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await subscriptions.unsubscribeByIdAndGet(req.context, castToInteger(req.params.listId), castToInteger(req.params.subscriptionId));
+    return res.json();
+});
+
+
+module.exports = router;

server/routes/rest/templates.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const templates = require('../../models/templates');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+const CampaignSender = require('../../lib/campaign-sender');
+
+
+router.getAsync('/templates/:templateId', passport.loggedIn, async (req, res) => {
+    const template = await templates.getById(req.context, castToInteger(req.params.templateId));
+    template.hash = templates.hash(template);
+    return res.json(template);
+});
+
+router.postAsync('/templates', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await templates.create(req.context, req.body));
+});
+
+router.putAsync('/templates/:templateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const template = req.body;
+    template.id = castToInteger(req.params.templateId);
+
+    await templates.updateWithConsistencyCheck(req.context, template);
+    return res.json();
+});
+
+router.deleteAsync('/templates/:templateId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await templates.remove(req.context, castToInteger(req.params.templateId));
+    return res.json();
+});
+
+router.postAsync('/templates-table', passport.loggedIn, async (req, res) => {
+    return res.json(await templates.listDTAjax(req.context, req.body));
+});
+
+router.postAsync('/template-test-send', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const data = req.body;
+    const result = await CampaignSender.testSend(req.context, data.listCid, data.subscriptionCid, data.campaignId, data.sendConfigurationId, data.html, data.text);
+    return res.json(result);
+});
+
+module.exports = router;

server/routes/rest/triggers.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const passport = require('../../lib/passport');
+const triggers = require('../../models/triggers');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.postAsync('/triggers-by-campaign-table/:campaignId', passport.loggedIn, async (req, res) => {
+    return res.json(await triggers.listByCampaignDTAjax(req.context, castToInteger(req.params.campaignId), req.body));
+});
+
+router.postAsync('/triggers-by-list-table/:listId', passport.loggedIn, async (req, res) => {
+    return res.json(await triggers.listByListDTAjax(req.context, castToInteger(req.params.listId), req.body));
+});
+
+router.getAsync('/triggers/:campaignId/:triggerId', passport.loggedIn, async (req, res) => {
+    const entity = await triggers.getById(req.context, castToInteger(req.params.campaignId), req.params.triggerId);
+    entity.hash = triggers.hash(entity);
+    return res.json(entity);
+});
+
+router.postAsync('/triggers/:campaignId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await triggers.create(req.context, castToInteger(req.params.campaignId), req.body));
+});
+
+router.putAsync('/triggers/:campaignId/:triggerId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const entity = req.body;
+    entity.id = castToInteger(req.params.triggerId);
+
+    await triggers.updateWithConsistencyCheck(req.context, castToInteger(req.params.campaignId), entity);
+    return res.json();
+});
+
+router.deleteAsync('/triggers/:campaignId/:triggerId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await triggers.remove(req.context, castToInteger(req.params.campaignId), castToInteger(req.params.triggerId));
+    return res.json();
+});
+
+module.exports = router;

server/routes/rest/users.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const config = require('config');
+const passport = require('../../lib/passport');
+const _ = require('../../lib/translate')._;
+const users = require('../../models/users');
+const shares = require('../../models/shares');
+
+const router = require('../../lib/router-async').create();
+const {castToInteger} = require('../../lib/helpers');
+
+
+router.getAsync('/users/:userId', passport.loggedIn, async (req, res) => {
+    const user = await users.getById(req.context, castToInteger(req.params.userId));
+    user.hash = users.hash(user);
+    return res.json(user);
+});
+
+router.postAsync('/users', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    return res.json(await users.create(req.context, req.body));
+});
+
+router.putAsync('/users/:userId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    const user = req.body;
+    user.id = castToInteger(req.params.userId);
+
+    await users.updateWithConsistencyCheck(req.context, user);
+    return res.json();
+});
+
+router.deleteAsync('/users/:userId', passport.loggedIn, passport.csrfProtection, async (req, res) => {
+    await users.remove(req.context, castToInteger(req.params.userId));
+    return res.json();
+});
+
+router.postAsync('/users-validate', passport.loggedIn, async (req, res) => {
+    return res.json(await users.serverValidate(req.context, req.body));
+});
+
+router.postAsync('/users-table', passport.loggedIn, async (req, res) => {
+    return res.json(await users.listDTAjax(req.context, req.body));
+});
+
+
+module.exports = router;