app.use((err: any, req, res, next) => {
log.error('catching request handler error', err);
if (!res.headersSent) {
if (err instanceof HttpError || (isFinite(err.code) && err.name)) {
log.debug('sending back %s(%s)', err.name, err.code);
res.status(err.code);
} else if (err.code === 'ETIMEDOUT' || err.type === 'entity.too.large') {
log.debug('sending back Request Timeout(408)');
res.status(RequestTimeoutError.code);
} else {
log.debug('sending back generic 500');
res.status(500);
}
} else {
log.debug('headers already sent. no updates to response');
}
res.render('index', {
err,
cp_url: config('cp_url'),
debugging: CLIENT_DEBUG_INFO,
lang: normalize_i18n(req.query.lang),
});
});
export default function (collection: string, cb: Function = () => {}) {
var url, env = process.env;
function send_back(err, conn, collection, cb) {
if (err) {
cb(err);
} else {
cb(null, conn.collection(collection));
}
}
if (connection) {
send_back(connection_err, connection, collection, cb);
} else {
log.info('connecting to mongodb');
url = !env.MONGO_HOST ? config('mongo.url') :
'mongodb://' + env.MONGO_HOST + ':27017/' + env.MONGO_COLLECTION;
MongoClient.connect(url, (err, db) => {
connection = db;
connection_err = err;
if (err) {
log.error('error connecting to mongo', err);
} else {
log.info('connected to mongodb');
}
send_back(connection_err, connection, collection, cb);
});
}
}
function generate_body(template: EMAIL, payload: PAYLOAD, lang: string) {
var data = {
body: '',
payload: payload,
images: ASSETS.images,
styles: ASSETS.styles,
i18n: pick_i18n(lang),
config: {
url: config('cp.url'),
}
};
data.body = TEMPLATES[template](data);
return TEMPLATES.base(data);
}
import * as imgur from 'imgur';
import * as config from 'acm';
const IMGUR_ALBUM_ID = config('files.avatars.imgur.album_id');
const IMGUR_CLIENT_ID = config('files.avatars.imgur.client_id');
const IMGUR_PASSWORD = config('files.avatars.imgur.password');
const IMGUR_USERNAME = config('files.avatars.imgur.username');
export namespace Model {
export interface Base {
id?: string;
link?: string;
}
export interface ImgurImage extends Base {
id: string;
link: string;
}
}
export namespace Payload {
export interface Base {
base64?: string;
}
export class ImgurImage implements Base {
base64: string;
constructor(base64: string) {
this.base64 = base64;
}
import { BadGatewayError, ERR_MSG_EXTERNAL_ERROR } from '../errors';
import * as config from 'acm';
import Trello = require('trello');
const TRELLO_KEY = config('trello.key');
const TRELLO_TOKEN = config('trello.token');
const TRELLO_LIST_ID = config('trello.list_id');
const TRELLO_BOARD_ID = config('trello.board_id');
export const trello = new Trello(TRELLO_KEY, TRELLO_TOKEN);
export namespace card {
export function add(name: string, desc: string) {
return trello.addCard(name, desc, TRELLO_LIST_ID)
.then(errw);
}
export function get(id: string) {
return trello.getCard(TRELLO_BOARD_ID, id)
.then(errw);
}
export function del(id: string) {
return trello.deleteCard(id)
.then(errw);
}
}
function errw(ack) {
if (typeof ack === 'string') {
InternalServerError, ERR_MSG_MISSING_FIELDS } from '../errors';
import Message, { CATEGORY, NOTIFICATION, OTYPE } from '../notification/message';
import { save, find, purge, update, purge_signature } from '../repository/notification';
import { head } from 'lodash';
import connect from '../device/mongo';
export const router = Router();
router.use((req, res, next) => {
// 5 minute caching
res.setHeader('Cache-Control', `private, max-age=${minutes(5) / 1000}`);
next();
});
connect(config('mongo.collections.notifications'), (err, coll) => {
function get_event_and_act_upon_message(id: string, action: Function, processor: (ev: EventMessage) => Message) {
// XXX check this isn't our own event
return new Promise<Message | DeleteWriteOpResultObject>((resolve, reject) =>
Event.findById(id)
.then((ev: EventMessage) => {
var msg = processor(ev);
msg.sign();
action(coll, action === purge_signature ? msg.signature : msg)
.then(ack => resolve(msg))
.catch(err => reject(new InternalServerError(err.message)));
})
.catch(err => reject(new InternalServerError(err.message))));
}
import * as config from 'acm';
import * as request from 'request';
import { try_func } from '../utilities';
import { BadRequestError, BadGatewayError,
ERR_MSG_PARSING_ERROR } from '../errors';
const GOOGLE_RECAPTCHA_ENDPOINT = config('google.recaptcha.endpoint');
const GOOGLE_RECAPTCHA_SECRET = config('google.recaptcha.secret');
export function recaptcha(response: string, remoteip: string) {
return new Promise<boolean>((resolve, reject) => {
request({
method: 'POST',
uri: GOOGLE_RECAPTCHA_ENDPOINT,
formData: { response, remoteip,
secret: GOOGLE_RECAPTCHA_SECRET }
}, (err, res, body) => {
var [ parse_err, check ] = try_func(() => JSON.parse(body));
if (err) {
reject(err);
} else if (parse_err) {
reject(new BadGatewayError(ERR_MSG_PARSING_ERROR('google')));
} else if (!check.success) {
reject(new BadRequestError('failed to verify recaptcha'));
} else {
resolve(true);
}
});
});
}
import db_connect, { DbmsDevice } from '../device/dbms';
import es_connect, { ElasticsearchDevice } from '../device/elasticsearch';
import { get, elasticsearch } from '../search/updater';
import { UpdaterAck, LinkConfiguration, LinkDefinition } from '../river/sync';
import { Duration } from '../lang';
import { logger } from '../log';
import { nonce } from '../crypto';
import * as config from 'acm';
import * as toes from '../toe';
const log = logger(__filename);
const models: LinkDefinition[] = config('river.models').map((def: LinkConfiguration) =>
new LinkDefinition(
def.name,
def.fields,
def.query_file,
def.soft_delete,
def.primary_key,
def.label));
export function run(since: Duration, identity: string, counter: number): Promise<UpdaterAck[]> {
var db: DbmsDevice;
var es: ElasticsearchDevice;
try {
db = db_connect();
es = es_connect();
models.map(model => log.info('river model entry', model));
return Promise.all(models.map(model => get(db, model, { since })
function do_log() {
if (config('logging.enable.sql')) {
return log.debug.apply(log, arguments);
}
}
})).catch(err => res.render('index', {
unfurled: OG,
cp_url: config('cp_url'),
debugging: CLIENT_DEBUG_INFO,
lang: normalize_i18n(req.query.lang),
}));
