export function setup(router: express.Router) {

    logger.info('Setting up request mapping for for user');
    router.get('/secure/user', (req: any, res: express.Response) => {
        res.json(req.session.passport.user);
    });

    return router;
}

 public async init(): Promise<FSWatcher> {
   try {
     logger.info('Starting watcher');
     return this.fswatcher.on('add', this.onAdd.bind(this));
   } catch (err) {
     logger.error(err);
     throw err;
   }
 }

			cursor.each(function(err, row) {
				if (err) {
					throw err;
				}
				winston.info('myCategoriesFeed => cursor.each');
                const admins = _.merge(_.get(row, 'old_val.admins', []), _.get(row, 'new_val.admins', []));
				for (let playerId of admins) {
					emit('myCategories:' + playerId + ':feed', JSON.stringify(row));
				}
			});

    /**
	 * Called whenever a client disconnnects
	 */
    private onClose() {
        if ( this.onDisconnected )
            this.onDisconnected( this );

        winston.info( `Websocket disconnected: ${this.domain}`, { process: process.pid } )

        this.ws.removeAllListeners( 'message' );
        this.ws.removeAllListeners( 'close' );
        this.ws.removeAllListeners( 'error' );
    }

  private async handleFile(filePath: string): Promise<boolean> {
    logger.info('Taking file: %s', filePath);
    const jobType = this.getJobType(filePath);
    logger.debug('Took %s %s', filePath, jobType);

    // Give directories a chance to write cover files
    // await sleep(1000);

    return this.dispatcher.enqueueFile(filePath, jobType);
  }

    public listen(...args: any[]) {
        this.port = args[0];
        this.server.listen.apply(this.server, args);
        this.sbc.connect(this.port);

        log.info("Stage listening on port " + this.port + " for resource " +
            this.route);

        // TODO: Add John's hack for getting the current IP here.
    }

 handleEcho(payload: FBTypes.MessengerPayload) {
     logger.info("echo received:", payload);
     
     // keep track of last time we sent anything to this user
     return new Volunteer({ fbid: payload.recipient.id })
     .save(
         { last_messaged: moment().format(DATE_FORMAT) },
         { patch: true, require: false }
     );
 }

            this.mailgun.messages().send( { from: from, subject: subject, text: msg, to: to }, function( err, response ) {

                if ( err ) {
                    winston.error( `Could not send email to ${to}: ${err}`, { process: process.pid } );
                    return reject( err );
                }

                winston.info( `Email sent ${JSON.stringify( response )} unmodified`, { process: process.pid } );
                return resolve( true );
            } );

    /**
	 * Called whenever we recieve a message from a client
	 */
    private onMessage( message: string ) {
        winston.info( `Received message from client: '${message}'`, { process: process.pid } );
        try {
            const token: def.SocketTokens.IToken = JSON.parse( message );
            this._controller.processServerInstruction( new ServerInstruction( token, this ) );
        }
        catch ( err ) {
            winston.error( `Could not parse socket message: '${err}'`, { process: process.pid } );
        }
    }

 }, function( err ) {
     if ( !err ) {
         winston.info( `Modified email sent ${JSON.stringify( response )}`, { process: process.pid } );
         return resolve( true );
     }
     else {
         winston.error( `Could not modify email ${JSON.stringify( response )}: ${err}`, { process: process.pid } );
         return reject( err );
     }
 } );