TypeScript express-serve-static-core.Router类代码示例

//Log requests to console
app.use(morgan(config.env));

// Initialize passport for use
app.use(passport.initialize());

//connect to db
mongoose.connect(config.database);

//bring in passport strategy we just defined
require('../config/passport')(passport);


//Create API group routes

const apiRoutes:Router = express.Router();

apiRoutes.post('/register',  function(req, res) {
  if(!req.body.email || !req.body.password) {
    res.json({success: false, message: 'Please enter an email and password to register.'});
  }else{
    var newUser = new User({
      email: req.body.email,
      password: req.body.password
    });

    //Attempt to save the new users
    newUser.save(function(err) {
      if(err){
        return res.json({success: false, message: 'That email address already exists.'});
      }

import * as express from 'express';
import {Router, Request, Response, NextFunction } from 'express-serve-static-core';

let router: Router = express.Router();

router.use((req: Request, res: Response, next: NextFunction): any => {
    req.isAuthenticated()
        ? next()
        : next(new Error('Authentication failed.'));
});

export = router;

    private registerRouteHandlers() {
        for (let [route, handler] of this.routeHandlers.entries()) {
            let httpMethod = route.requestConfig.method;
            let path = route.requestConfig.path;
            logger.debug(`Registering route. Path: '${path}', method: ${httpMethod}. Handler: ${ComponentUtil
                .getComponentData(handler.constructor).componentName}.${route.methodHandler}()`);

            this.router[httpMethod](path, this.wrap(async(request, response, next) => {
                let result;
                try {
                    result = await handler[route.methodHandler](request, response);
                } catch (err) {
                    logger.debug("Error occurred in the route handler.");
                    next(new RouteHandlerError(`${handler.constructor.name}.${route.
                        methodHandler} failed on ${httpMethod.toUpperCase()} ${path}`, err));
                    return;
                }
                // TODO #3 saskodh: Check whether is more convenient to store in the request zone or pass on next
                response.$$frameworkData = {
                    view: route.view,
                    model: result
                };
                next();
            }));
        }
    }

    private configureMiddlewares() {
        logger.info('Configuring the exposed express router...');

        // NOTE: The request context middleware should always be registered first
        logger.debug('Registering request context initializer middleware...');
        this.router.use(RequestContextInitializer.getMiddleware());

        logger.debug('Registering pre-handler middleware...');
        this.router.use(this.wrap(this.preHandler.bind(this)));
        // NOTE: we will have our middleware handler when we drop the dependency to express
        // That would require the dispatching by path to be implemented on our side
        logger.debug('Registering route-handler (RequestMapping) middleware...');
        this.registerRouteHandlers();
        logger.debug('Registering post-handler middleware...');
        this.router.use(this.wrap(this.postHandler.bind(this)));
        logger.debug('Registering error-resolver middleware...');
        this.router.use(this.errorResolver);
        logger.debug('Registering resolver middleware...');
        this.router.use(this.wrap(this.resolver.bind(this)));
    }