function AzureTablesStore(options) {
var self = this;
options = options || {};
self.log = options.logger || noop;
self.logError = options.errorLogger ||noop;
self.sessionTimeOut = options.sessionTimeOut;
self.cronPattern = options.overrideCron || '59 * * * * *';
Store.call(this, options);
/*
storage account set up. azure-storage will attempt to read the following environment variables:
AZURE_STORAGE_ACCOUNT
AZURE_STORAGE_ACCESS_KEY
or
AZURE_STORAGE_CONNECTION_STRING
if these are not found, storageAccount and accessKey
must be supplied on options
*/
//todo: allow retry policy to bet set on options
var retryOperations = new azure.LinearRetryPolicyFilter(RETRY_LIMIT, RETRY_INTERVAL);
var azureStorageConnectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
if (azureStorageConnectionString) {
self.tableService = azure.createTableService().withFilter(retryOperations);
}
else {
var storageAccount = process.env.AZURE_STORAGE_ACCOUNT || options.storageAccount;
var accessKey = process.env.AZURE_STORAGE_ACCESS_KEY || options.accessKey;
self.tableService = azure.createTableService(storageAccount, accessKey).withFilter(retryOperations);
}
/*
table setup
table name can be supplied on options
*/
self.table = options.table || DEFAULT_TABLE;
self.tableService.createTableIfNotExists(self.table, logOrThrow);
//schedule expired session cleanup if session timeout is set
if (options.sessionTimeOut) {
self.startBackgroundCleanUp();
}
//reducing function complexity to keep code climate happy
function logOrThrow(error, result) {
if (result) {
self.log('connect-azuretables created table ' + self.table);
}
if (error) {
throw ('failed to create table: ' + error);
}
}
}
function Meal() {
var accountName = process.env.AzureStorageName;
var accountKey = process.env.AzureStorageKey;
this.storageClient = azure.createTableService(accountName, accountKey);
this.tableName = "meals";
}
connect: function (callback) {
var retryOperations = new azure.ExponentialRetryPolicyFilter();
var self = this;
this.client = azure.createTableService(this.options.storageAccount, this.options.storageAccessKey, this.options.storageTableHost).withFilter(retryOperations);
var createSagaTable = function (callback) {
self.client.createTableIfNotExists(self.options.sagaTableName, callback);
}
var createCommandTable = function (callback) {
self.client.createTableIfNotExists(self.options.commandTableName, callback);
}
var createUndispatchedCommandTable = function (callback) {
self.client.createTableIfNotExists(self.options.undispatchedCommandtableName, callback);
}
async.parallel([
createSagaTable,
createCommandTable,
createUndispatchedCommandTable
], function (err) {
if (err) {
if (callback) callback(err);
} else {
self.emit('connect');
if (callback) callback(null, self);
}
});
},
function testQuestion()
{
var Question = require("./question");
var azure = require('azure-storage');
var uuid = require('uuid');
var tableService = azure.createTableService();
var sessionId = uuid();
var questionId = "Q_" + uuid();
var questionStr = "Do you know you can test question class?";
var answerStr = "";
var timestamp = Date.now();
var upvotes = 0;
var question = new Question(sessionId, questionId, questionStr, answerStr, timestamp, upvotes);
console.log(question);
var entity = question.toEntity();
tableService.insertEntity('questiontest', entity, (error, result, response) => {
if(!error) {
console.log("Question is added.");
tableService.retrieveEntity('questiontest', sessionId, questionId, (error, result, response) => {
var newQuestion = Question.toQuestion(result);
console.log(newQuestion);
});
}
else {
console.log(error);
}
});
}
connect: function (callback) {
var self = this;
var retryOperations = new azure.ExponentialRetryPolicyFilter();
var server = azure.createTableService(this.options.storageAccount, this.options.storageAccessKey, this.options.storageTableHost).withFilter(retryOperations);
self.client = server;
self.isConnected = true;
var createEventsTable = function (callback) {
self.client.createTableIfNotExists(self.options.eventsTableName, callback);
};
var createSnapshotTable = function (callback) {
self.client.createTableIfNotExists(self.options.snapshotsTableName, callback);
};
var createUndispatchedEventsTable = function (done) {
self.client.createTableIfNotExists(self.options.undispatchedEventsTableName, done)
};
async.parallel([
createEventsTable,
createSnapshotTable,
createUndispatchedEventsTable
], function (err) {
if (err) {
if (callback) callback(err);
} else {
self.emit('connect');
if (callback) callback(null, self);
}
});
},
router.post('/createTableIfNotExists', function (req, res) {
var tableName = req.query.tableName;
if (!tableName) {
res.send("Please specify a table name");
return;
}
var cn = config.connectionString;
var tableService = storage.createTableService(cn);
tableService.createTableIfNotExists(tableName, function(error, result) {
if(error) {
res.send(error);
return;
}
if(result.created) {
res.send('Table created');
} else{
res.send('Table ' + tableName + ' already exists');
return;
}
})
});
router.get('/getTableSasUrl', function (req, res) {
var cn = config.connectionString;
var tableService = storage.createTableService(cn);
var tableName = req.query.tableName;
var expiryDate = new Date();
expiryDate.setMinutes(expiryDate.getMinutes() + 30);
var sharedAccessPolicy = {
AccessPolicy: {
Permissions: storage.TableUtilities.SharedAccessPermissions.QUERY
+ storage.TableUtilities.SharedAccessPermissions.ADD
+ storage.TableUtilities.SharedAccessPermissions.UPDATE
+ storage.TableUtilities.SharedAccessPermissions.DELETE,
Expiry: expiryDate
},
};
var sas = tableService.generateSharedAccessSignature(tableName, sharedAccessPolicy);
var url = tableService.host.primaryHost; // TODO: there is no tableService.getUrl()
res.send(url + '/' + tableName + "?" + sas);
});
module.exports = () => {
var tableSvc = azure.createTableService(storageAccount, storageAccessKey);
return {
initialize: (callback) => {
tableSvc.createTableIfNotExists('passwords', function(error, result, response) {
if (error) {
callback(error);
return;
}
callback();
});
},
insert: (table, entity, callback) => {
tableSvc.insertEntity(table, entity, callback);
}
};
}
module.exports = (context, req) => __awaiter(this, void 0, void 0, function* () {
const tableService = storage.createTableService();
const entGen = storage.TableUtilities.entityGenerator;
const tableName = `AzureWebJobsHostLogs${moment(moment().toISOString()).format('YYYYMM')}`;
const checkTableExists = () => __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, rejects) => {
tableService.createTableIfNotExists(tableName, function (error, result, response) {
resolve(result);
});
});
});
const checkTbl = yield checkTableExists();
if (checkTbl.isSuccessful === false)
return false;
//bolbにテーブルログの情報を取得
const getFileSuccess = (query) => __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
tableService.queryEntities(tableName, query, null, (err, data) => {
if (err)
reject(undefined);
else
resolve(data.entries.length > 0 ? data.entries : undefined);
});
});
});
const query = new storage.TableQuery()
.where('fileHandleComplete != ?', '')
.and('EndTime >= ?', new Date(moment(moment().subtract(1, 'days')).toISOString()));
const events = yield getFileSuccess(query);
if (events === undefined)
return false;
if (events !== undefined) {
for (let x in events) {
let event = events[x];
if (event.moveDate !== undefined)
continue;
const oriBlob = 'working/' + event.fileHandleComplete._;
const targetBlob = 'complete/' + event.fileHandleComplete._;
const oriUrl = event.fileHandleUrl._;
let copyHandle = yield new Promise((resolve, reject) => {
storage.createBlobService().startCopyBlob(oriUrl, process.env.AZURE_BLOB_STORAGE, targetBlob, (err, result, res) => __awaiter(this, void 0, void 0, function* () {
if (err)
return reject(false);
return resolve(true);
}));
});
if (copyHandle === false)
continue;
let deleteHandle = yield new Promise((resolve, reject) => {
storage.createBlobService().deleteBlobIfExists(process.env.AZURE_BLOB_STORAGE, oriBlob, (err, result, res) => __awaiter(this, void 0, void 0, function* () {
if (err)
return reject(false);
return resolve(true);
}));
});
}
}
});
function TableStorageStream(options) {
if (options.connectionString) {
this.client = azure.createTableService(options.connectionString);
}
else if (options.storageAccountSettings) {
this.client = azure.createTableService(options.storageAccountSettings.accountName, options.storageAccountSettings.accessKey, { primaryHost: options.storageAccountSettings.host });
}
else {
throw new Error("Missing either a connection string or storage account settings");
}
this.tableName = options.tableName;
if (!options.partitionKeyFormat) {
options.partitionKeyFormat = '{{name}}_{{momentFormat time "YYYY-MM-DD-HH"}}';
}
this.partitionKeyBuilder = handlebars.compile(options.partitionKeyFormat);
if (!options.rowKeyFormat) {
options.rowKeyFormat = '{{newId}}';
}
this.rowKeyBuilder = handlebars.compile(options.rowKeyFormat);
}
function main() {
nconf.env().argv().defaults({
config : 'localConfig.json',
startPartition : 10,
endPartition : 99
});
let configFile = nconf.get('config');
let config = nconf.file({file:configFile, search:true});
nconf.required(['table_storage_account', 'table_storage_key', 'command_table', 'command_queue']);
let queueService = azure.createQueueService(
config.get("table_storage_account"),
config.get("table_storage_key")
);
queueService.messageEncoder = null;
let tableService = azure.createTableService(
config.get("table_storage_account"),
config.get("table_storage_key")
);
tableService.createTableIfNotExists(config.get('command_table'), (err) => {
debug(err);
queueService.createQueueIfNotExists(config.get('command_queue'), (err) => {
if (err) {
console.warn('create command queue');
console.warn(err.stack);
}
init(config, tableService, queueService, (err) => {
debug(err);
let iterations = [];
if (config.get('test')) {
iterations = [1, 2];
}
else {
for (let i = 1; i <= 5; i++) {
iterations.push(i);
}
}
let generation = "randomnumber";
insertNextIteration(config, tableService, queueService, iterations, generation);
});
});
});
}
connect: function (callback) {
var retryOperations = new azure.ExponentialRetryPolicyFilter();
var self = this;
this.client = azure.createTableService(this.options.storageAccount, this.options.storageAccessKey, this.options.storageTableHost).withFilter(retryOperations);
self.emit('connect');
if (callback) callback(null, self);
},
function Users() {
var accountName = 'rockfallstorage',
accountKey = 'Xl+57BjOS2v2KUB+EOWCVpJN387Fbl9IrNOfBSNwmxtx6TPthxSq9WqHImC3SPLAOWNPfrHfekmLe02EngBgeg==',
tableName = 'users',
partitionKey = 'user'
var Table = require('./table')
this.tableUsers = new Table(
azure.createTableService(accountName, accountKey),
tableName, partitionKey)
}
function azureAppender(config) {
var missingConfigMessage = 'Missing required configuration';
var missingStorageAccountMessage = 'Missing storage account name';
var missingStorageAccountKeyMessage = 'Missing storage account key';
var defaultTableName = 'log4js';
if (!config || typeof config !== 'object') {
throw (new Error(missingConfigMessage));
}
if (!config.storageAccount || typeof config.storageAccount !== 'string') {
throw (new Error(missingStorageAccountMessage));
}
if (!config.storageAccountKey || typeof config.storageAccountKey !== 'string') {
throw (new Error(missingStorageAccountKeyMessage));
}
if (!config.tableName) {
config.tableName = defaultTableName;
}
var azure = require('azure-storage');
var tableService = azure.createTableService(config.storageAccount, config.storageAccountKey);
tableService.createTableIfNotExists(config.tableName, function (error) {
if (error) {
throw (new Error(error));
}
});
return function (loggingEvent) {
if (loggingEvent) {
var entGen = azure.TableUtilities.entityGenerator;
var rowKey = (new Date()).valueOf();
for (var i = 0; i < loggingEvent.data.length; i++) {
var entry = {
PartitionKey: entGen.String(config.tableName),
RowKey: entGen.String(rowKey + '_' + i),
Category: entGen.String(loggingEvent.categoryName),
Level: entGen.String(loggingEvent.level.levelStr),
Data: entGen.String(loggingEvent.data[i])
};
tableService.insertEntity(config.tableName, entry, function (error) {
if (error) {
throw (new Error(error));
}
});
}
}
}
}
app.get("/accounts", function(req, res) {
var service = wasb.createTableService(storageAccount, storageKey);
var create = new promise(function(resolve, reject) {
try {
service.createTableIfNotExists("accounts", function(error, result, response) {
if (error) {
console.log("createTableIfNotExists: " + error);
reject("accounts?");
} else {
resolve(result);
}
});
} catch (ex) {
console.log("createTableIfNotExists: " + ex);
reject("accounts?");
}
});
var list = new promise(function(resolve, reject) {
try {
var query = new wasb.TableQuery().top(1000).where("PartitionKey eq ?", "customers");
service.queryEntities("accounts", query, null, function(error, result, response) {
if (error) {
console.log("queryEntities: " + error);
reject("accounts?");
} else {
resolve(result);
}
});
} catch (ex) {
console.log("queryEntities: " + ex);
reject("accounts?");
}
});
promise.each([verifyAdmin(req), create, list], function(result) { }).then(function(result) {
var response = [];
result[2].entries.forEach(function(entry) {
response.push({
"username": entry.RowKey._,
"password": entry.password._,
"container": entry.container._
});
});
res.status(200).send(response);
}, function(error) {
res.sendError(error);
}).catch(function(ex) {
console.log("/list/accounts: " + ex);
res.sendError("exception");
});
});
module.exports = function (table, q) {
TABLE_NAME = table;
$q = q;
// initialisation
dataAccess.tableService = azure.createTableService(ACCOUNT_NAME, ACCOUNT_KEY);
dataAccess.tableService.createTableIfNotExists(TABLE_NAME, function (error, result, response) {
if (!error) {
// result contains true if created; false if already exists
}
});
return dataAccess;
};
init: function() {
CoreObject.prototype.init.apply(this, arguments);
this.manifestSize = this.manifestSize || DEFAULT_MANIFEST_SIZE;
if (!this.config) {
return Promise.reject(new SilentError('You have to pass a config!'));
}
// be transparant to either passing a connectionString or the storageAccount + storageAccessKey
if(this.config.connectionString) {
this.client = azure.createTableService(this.config.connectionString);
} else if (this.config.storageAccount && this.config.storageAccessKey) {
this.client = azure.createTableService(this.config.storageAccount, this.config.storageAccessKey);
} else {
console.error("No connection string or storage account plus access key set for this Azure deployment.");
return Promise.reject(new SilentError('No connection string or storage account plus access key set for this Azure deployment.'));
}
/*
TODO to make feasible for tests;
In order to run the tests, the following environment variables need to be set up:
AZURE_STORAGE_CONNECTION_STRING="valid storage connection string"
*/
},
function queryTableStorageLogs(options, query, resultsPrinter){
process.env['AZURE_STORAGE_ACCOUNT'] = options.storageAccountName;
process.env['AZURE_STORAGE_ACCESS_KEY'] = options.storageAccountKey;
console.log("Querying the " + options.tableName + " table");
var tableSvc = azure.createTableService();
tableSvc.queryEntities(options.tableName, query, null, function(error, result, response) {
if(!error) {
resultsPrinter(result.entries);
}
else {
console.log(chalk.red("failed to get logs"));
console.log(error);
}
});
}
connect: function (callback) {
var self = this;
var retryOperations = new azure.ExponentialRetryPolicyFilter();
this.client = azure.createTableService(this.options.storageAccount, this.options.storageAccessKey, this.options.storageTableHost).withFilter(retryOperations);
this.client.createTableIfNotExists(this.options.revisionTableName, function (err) {
if (err) {
if (callback) callback(err);
} else {
self.emit('connect');
if (callback) callback(null, self);
}
});
},
processComplete: (context) => __awaiter(this, void 0, void 0, function* () {
const tableName = 'AzureWebJobsHostLogs' + moment(moment().toISOString()).format('YYYYMM');
const tableService = storage.createTableService();
const checkTableExists = () => __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, rejects) => {
tableService.createTableIfNotExists(tableName, (error, result, response) => resolve(result));
});
});
//ログテーブルがなければ止まります
const checkTbl = yield checkTableExists();
if (checkTbl.isSuccessful !== true)
return false;
//該当処理の情報を取得
const getCurrentHandle = (query) => __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
tableService.queryEntities(tableName, query, null, (err, data) => {
if (err)
reject(err);
else
resolve(data.entries.length > 0 ? data.entries[0] : undefined);
});
});
});
const query = new storage.TableQuery().where('RowKey == ?', context.funcId);
const processHandle = yield getCurrentHandle(query);
if (processHandle === undefined)
return false;
//TRUEをprocessCompleteカラムに設定
const setProcessComplete = (processHandle) => __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
tableService.insertOrReplaceEntity(tableName, processHandle, function (err) {
if (err)
reject(err);
else
resolve(true);
});
});
});
const entGen = storage.TableUtilities.entityGenerator;
processHandle.fileHandleComplete = entGen.String(context.bindingData.name);
processHandle.fileHandleUrl = entGen.String(context.bindingData.uri + '?sasString');
yield setProcessComplete(processHandle);
}),
var WinstonAzure = exports.WinstonAzure = function (options) {
winston.Transport.call(this, options);
options = options || {};
this.name = 'azure';
this.tableName = options.table || 'log';
this.level = options.level || 'info';
this.silent = options.silent || false;
this.metaAsColumns = options.metaAsColumns || false;
this.partition = options.partition || 'log';
this.rowKeyBuilder = options.rowKeyBuilder || function()
{
return (new Date()).getTime() + '_' + (new Date()).getMilliseconds();
};
this.tableService = azure.createTableService(options.account, options.key);
this.entityGenerator = azure.TableUtilities.entityGenerator;
};
function Azure (opt) {
opt = opt || {}
if (!opt.storageConnectionString) { throw new Error('opt.storageConnectionString must be defined') }
var retryOperations = new azureCommon.ExponentialRetryPolicyFilter()
var ent = azureStorage.TableUtilities.entityGenerator
var tables = azureStorage.createTableService(opt.storageConnectionString)
.withFilter(retryOperations)
var blobs = azureStorage.createBlobService(opt.storageConnectionString)
.withFilter(retryOperations)
Azure.extendBlobsWithGzip(blobs)
Azure.extendBlobsWithLazyContainers(blobs)
Promise.promisifyAll(blobs)
Promise.promisifyAll(tables)
Promise.promisifyAll(zlib)
this.ent = ent
this.tables = tables
this.blobs = blobs
}
verifyAdmin(req).then(function(verified) {
var container = (verified.body.scope == "[admin]") ? req.query.container : verified.body.scope;
var service = wasb.createTableService(storageAccount, storageKey);
return new promise(function(resolve, reject) {
try {
var gen = wasb.TableUtilities.entityGenerator;
var entity = {
"PartitionKey": gen.String("customers"),
"RowKey": gen.String(req.query.username)
};
service.deleteEntity("accounts", entity, function(error, result, response) {
if (error) {
console.log("deleteEntity: " + error);
reject("delete-account");
} else {
resolve(result);
}
});
} catch (ex) {
console.log("deleteEntity: " + ex);
reject("delete-account");
}
})
}).then(function() {
exports.getTableService = function (req) {
var sa = getStorageAccount(req);
return azure.createTableService(sa.name, sa.key);
};
createTableService: ()=>azure.createTableService(account,key),
console.log('listener job started');
var azure = require('azure');
var azureStorage = require('azure-storage');
var parseString = require('xml2js').parseString;
var connStr = process.env.CONNECTION_STRING;
if (!connStr) throw new Error('Must provide connection string to queue');
var queueName = process.env.queue;
if (!queueName) throw new Error('Must provide queue name');
var serviceBus = azure.createServiceBusService(connStr);
listenForMessages(serviceBus);
// Uses env variables AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY, or AZURE_STORAGE_CONNECTION_STRING for information
var tableSvc = azureStorage.createTableService();
var tableName = process.env.AZURE_TABLE_NAME;
var sql = require('mssql');
var sqlTable = process.env.AZURE_SQL_TABLE;
var config = {
user: process.env.AZURE_SQL_USER,
password: process.env.AZURE_SQL_PASS,
server: process.env.AZURE_SQL_SERVER,
database: process.env.AZURE_SQL_DB,
options: {
encrypt: true // Use this if you're on Azure
}
};
function main() {
var tableService = azure.createTableService(
nconf.get("STORAGE_ACCOUNT"),
nconf.get("STORAGE_KEY")
);
var queueService = azure.createQueueService(
nconf.get("STORAGE_ACCOUNT"),
nconf.get("STORAGE_KEY")
);
tableService.createTableIfNotExists(TABLE_NAME, (err, result) => {
if (err) {
console.warn("createTable");
console.warn(err.stack);
process.exit(1);
}
queueService.createQueueIfNotExists(USERGRAPH_QUEUE_NAME, (err, result) => {
if (err) {
console.warn("create user graph queue");
console.warn(err.stack);
process.exit(1);
}
queueService.createQueueIfNotExists(PIPELINE_QUEUE_NAME, (err, result) => {
if (err) {
console.warn("create user graph queue");
console.warn(err.stack);
process.exit(1);
}
var filterSpec = {};
var bbox = nconf.get("BOUNDING_BOX");
if (bbox) {
filterSpec.locations = bbox;
}
getKeywordList().then((keywords) => {
if (keywords.length > 400) {
console.warn("filter: >400 keywords, truncating");
keywords = keywords.slice(0, 399);
}
if (keywords) {
filterSpec.track = keywords.join(",");
}
var languageFilter = nconf.get("LANGUAGE_FILTER")
filterSpec.language = languageFilter;
console.log("== Filter Spec ==");
console.log(filterSpec);
filter(
filterSpec,
(err, tweet) => {
if (err) {
console.warn("twitter");
console.warn(err.stack);
process.exit(1);
}
processTweet(tweet, tableService, queueService);
}
);
})
.catch((err) => {
console.log(err.stack);
});
})
})
});
}
var moment = require('moment');
nconf.file({ file: 'localConfig.json', search: true }).env();
console.log(nconf.get("STORAGE_ACCOUNT"));
console.log(nconf.get("STORAGE_KEY"));
var USERGRAPH_QUEUE_NAME = nconf.get("TWEET_USERGRAPH_QUEUE_NAME");
console.log(USERGRAPH_QUEUE_NAME);
var PIPELINE_QUEUE_NAME = nconf.get("TWEET_PIPELINE_QUEUE_NAME");
console.log(PIPELINE_QUEUE_NAME);
var TABLE_NAME = nconf.get("TWEET_TABLE_NAME");
console.log(TABLE_NAME);
var tableService = azure.createTableService(
nconf.get("STORAGE_ACCOUNT"),
nconf.get("STORAGE_KEY")
);
var queueService = azure.createQueueService(
nconf.get("STORAGE_ACCOUNT"),
nconf.get("STORAGE_KEY")
);
function filter(filters, cb) {
var client = new twitter({
consumer_key: nconf.get("TWITTER_CONSUMER_KEY"),
consumer_secret: nconf.get("TWITTER_CONSUMER_SECRET"),
access_token_key: nconf.get("TWITTER_ACCESS_TOKEN_KEY"),
access_token_secret: nconf.get("TWITTER_ACCESS_TOKEN_SECRET")
});
var azure = require('azure-storage');
var uuid = require('node-uuid');
var tableName = 'notes';
var partitionKey = 'mynotes';
var storageAccount = process.env.AZURE_STORAGE_ACCOUNT;
var storageAccessKey = process.env.AZURE_STORAGE_ACCESS_KEY;
var entityGen = azure.TableUtilities.entityGenerator;
var tableService = azure.createTableService(storageAccount, storageAccessKey);
var TableQuery = azure.TableQuery;
tableService.createTableIfNotExists(tableName, function (error) {
if (error) {
throw error;
}
});
function convertToNoteEntity(entry) {
var note = {};
note.id = entry.RowKey._;
note.userId = entry.userId._;
note.title = entry.title._;
if (entry.content) {
note.content = entry.content._;
}
return note;
}
function Note(note) {
var express = require('express');
var azure = require('azure-storage');
var validator = require('validator');
var bodyParser = require('body-parser');
var tasks = require('./tasks');
var appName = "Simple To-Do List app";
var app = express();
var azureTableService = azure.createTableService("UseDevelopmentStorage=true");
var taskListIDChecker = function(req, res, next) {
var taskListID = req.params.taskListID;
if (!taskListID || !taskListID.match(/^[a-zA-Z0-9]{8}$/)) {
console.error('Invalid task list - ' + taskListID);
res.status(500).send('Invalid task list - ' + taskListID);
} else {
next();
}
};
var taskIDChecker = function(req, res, next) {
var taskID = req.params.taskID;
if (!taskID || !validator.isUUID(taskID)) {
console.error('Invalid task id - ' + taskID);
res.status(500).send('Invalid task ID - ' + taskID);
} else {
next();
}
};