TypeScript connect-flash.default函数代码示例

db.once('open', function () {
    console.log("Get passport...")
    let passport = require("./passport");
    console.log("Add middleware...");
    let app = express();
    if (process.env.NODE_ENV === 'production') {
        require('express-http2-workaround')({ express: express, http2: http2, app: app });///Fix http2 and express compatibility.
    }
    let st = [__dirname, ...config.staticLocation]
    if (process.env.NODE_ENV === 'production') {
        app.use(express.static(path.join(...st)));
    }
    let sessionOpts = {
        saveUninitialized: true, // saved new sessions
        resave: false, // do not automatically write to the session store
        store: new MongoStore({ mongooseConnection: mongoose.connection }),
        secret: config.db.secret,
        cookie: { httpOnly: true, maxAge: 2419200000 } // configure when sessions expires
    }
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: true }))
    app.use(cookieParser(config.db.secret))
    app.use(flash())//This is how we setup flash fail authentication.
    app.use(session(sessionOpts));
    app.use(passport.initialize());///Attach passport to express middleware.
    app.use(passport.session());
    if (config.jsTogz) {
        app.get('*.js', function (req, res, next) {
            req.url = req.url + '.gz';
            res.set('Content-Encoding', 'gzip');
            next();
        });
    }
    console.log("Add routes...");
    require('./routes/index')(app, passport);
    console.log("");
    let options = {
        key: fs.readFileSync(config.ssl.key),
        cert: fs.readFileSync(config.ssl.cert)
    };
    if (process.env.NODE_ENV === 'production') {
        http2.createServer(options, app).listen(config.port, (error) => {
            if (error) {
                console.error(error)
                return process.exit(1)
            } else {
                console.log('Listening on port: ' + config.port + '.')
            }
        });
    } else {
        http.createServer(app).listen(config.port, (error) => {
            if (error) {
                console.error(error)
                return process.exit(1)
            } else {
                console.log('Listening on port: ' + config.port + '.')
            }
        });
    }
});

function initAuth() {
    const flash = require('connect-flash');
    app.use(flash());

    const passport = require('passport');

    auth(passport);

    app.use(passport.initialize());
    app.use(passport.session()); // persistent login sessions

    return passport;
}

function expressConfig(app) {
    app.use(compress({
        filter: function (req, res) {
            return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
        },
        level: 9
    }));

    app.set('views', path.join(__dirname, '../app/views'));
    app.set('view engine', 'jade');
    app.use(logger('dev'));
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded());
    app.use(cookieParser());
    app.use(express.static(path.join(__dirname, '../public')));

    // express/mongo session storage
    app.use(session({
        secret: 'd@s !t m@n#',
        store: new mongoStore({
            url: config.db,
            collection: 'sessions'
        })
    }));

    // use passport session
    app.use(passport.initialize());
    app.use(passport.session());

    app.use(flash());

    app.use('/', routes);

    app.use(function (req, res, next) {
        var err = new Error('Not Found');
        //err.status = 404;
        next(err);
    });

    // production error handler
    // no stacktraces leaked to user
    app.use(function (err, req, res, next) {
        res.status(err.status || 500);
        res.render('error', {
            message: err.message,
            error: {}
        });
    });
}

  // start express application
  public initalize(app: any, config: ConfigType) {
    this.app = app;
    this.config = config;

    // view engine setup
    app.set('views', path.join(config.root, 'views'));
    app.set('view engine', 'ejs');

    // validator
    app.use(expressValidator());

    // favicon
    app.use(favicon(path.join(config.root, '.', 'public', 'favicon.ico'))); // uncomment after placing your favicon in /public

    // logger
    app.use(logger('dev'));

    // bodyParser
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: false }));

    // cookieParser
    app.use(cookieParser());

    // session
    app.use(session({
      secret: config.session.secret,
      resave: config.session.resave,
      saveUninitialized: config.session.saveUninitialized,
      cookie: { maxAge: config.session.cookie.maxAge }
    }));

    // public folder path
    const cacheTime = 10000;     // 10s
    app.use(express.static(path.join(config.root, '.', 'public'), {
      maxAge: cacheTime,
      lastModified: true,
      redirect: true }
      ));

    // Sample cache of extension match
    // app.use(function (req, res, next) {
    //     if (req.url.match(/^\/(css|js|img|font)\/.+/)) {
    //         res.setHeader('Cache-Control', 'public, max-age=3600');
    //     }
    //     next();
    // });

    // Initialize connect-flash
    app.use(flash());

    app.use(passport.initialize());
    app.use(passport.session());

    // Setup auth
    let auth = glob.sync(config.root + '/middlewares/*.+(js|ts|jsx|tsx)');
    auth.forEach(function (routes) {
      require(routes)(app);
    });

    // require(__dirname + '/middlewares/passport')(app);

    // Setup routes
    let routes = glob.sync(__dirname + '/routes/*.+(js|ts|jsx|tsx)');
      routes.forEach(function (routes) {
        require(routes)(app);
      });

    // require(__dirname + '/routes/about')(app);
    // require(__dirname + '/routes/api')(app);
    // require(__dirname + '/routes/hello')(app);
    // require(__dirname + '/routes/index')(app);
    // require(__dirname + '/routes/material')(app);
    // require(__dirname + '/routes/member')(app);
    // require(__dirname + '/routes/redux')(app);
    // require(__dirname + '/routes/simple')(app);

    // catch 404 and forward to error handler
    app.use((req: any, res: any, next: any) => {
      let err: any = new Error('Not Found');
      err.status = 404;
      next(err);
    });

    // error handlers

    // development error handler
    // will print stacktrace
    if (app.get('env') === 'development') {
      app.use((err: any, req: any, res: any, next: any) => {
        res.status(err.status || 500);
        res.render('error', {
        message: err.message,
        error: err
        });
      });
    }

    // production error handler
//.........这里部分代码省略.........

  app.use(compression());
  // parse application/json
  app.use(bodyParser.json());
  // parse application/x-www-form-urlencoded
  app.use(bodyParser.urlencoded({extended:false})); // get information from html forms
  // parse application/vnd.api+json as json
  //app.use(bodyParser.json({ type: 'application/vnd.api+json' }));
  // required for passport
  app.use(cookieParser()); // required before session.
  app.use(require('express-session')({
    secret: 'keyboard cat',
    resave: false,
    saveUninitialized: false
  }));
  app.use(passport.initialize());
  app.use(flash());
  app.use(passport.session());
  app.use("/", express.static('./public'));//redirect folder path
	console.log("[ = Development Express Config... = ]");
}

if ('production' == config.mode) {
  //console.log('production');
  // configure stuff here
  app.enable('trust proxy');
  //app.set('port', port);
  app.set('view engine', 'ejs'); // set up ejs for templating
  //app.use(express.static('public'), { maxAge: cachetime });
  //app.use("/js", express.static('./js'));//redirect folder path
  //app.use(favicon('./public/favicon.ico',{ maxAge: 1000 }));
  //app.use(compression());

        .then((app) => {
            app.set('view options', {pretty: false});
            app.set("etag", false);
            app.disable("x-powered-by");

            app.engine("dust", cons.dust);

            app.set("views", __dirname + "/../views");
            app.set("view engine", "dust");

            app.use(express.static(__dirname + "/../public"));

            passport.use(new LocalStrategy(
                function(username, password, done) {
                    storageManager.getAccountByEmail(username)
                        .then((account:any) => {
                            if (account === null) {
                                return done(null, false, { message: 'Incorrect account.' });
                            }
                            if (compareSync(password, account.password)) {
                                return done(null, account);
                            }
                            return done(null, false, { message: 'Incorrect password.' });
                        })
                        .catch((err:any) => {
                            console.log(err);
                            return done(null, false, { message: 'Internal error.' });
                        });
                }
            ));

            passport.serializeUser(function(account, done) {
                done(null, account.id);
            });

            passport.deserializeUser(function(id, done) {
                storageManager.getAccountById(id)
                    .then((account:any) => {
                        if (account !== undefined) {
                            return done(null, account);
                        }
                        return done(new Error("Invalid account"), null)
                    })
                    .catch((err:any) => {
                        done(err, null);
                    });
            });

            app.use(methodOverride());
            app.use(bodyParser.json());
            app.use(bodyParser.urlencoded({extended: false}));

            app.use(cookieParser());
            app.use(session({ secret: 'keyboard cat' }));
            app.use(passport.initialize());
            app.use(passport.session());

            app.use(flash());

            app.use((req:express.Request, res:express.Response, next:express.NextFunction) => {
                logger.info({method: req.method, url: req.url, protocol: req.protocol, ip: req.ip, hostname: req.hostname}, req.method + " " + req.path);
                next();
            });

            return app;
        });

    mongoStore = require('connect-mongo')({ session: session }),
    flash = require('connect-flash');

// express/mongo session storage
var expressSession = session({
        secret: 'd@s !t m@n#',
        resave: false,
        saveUninitialized: false,
        store: new mongoStore({
            url: config.db,
            collection: 'sessions'
        })
    }),
    passportInitialize = passport.initialize(),
    passportSession = passport.session(),
    flashMiddleware = flash();

var populateSession = (req: express.Request, res: express.Response, next: Function) => {
    expressSession(req, res, (err) => {
        if (_.isObject(err)) {
            return next(err);
        }

        passportInitialize(req, res, (err) => {
            if (_.isObject(err)) {
                return next(err);
            }

            passportSession(req, res, (err) => {
                if (_.isObject(err)) {
                    return next(err);