import { Router, Request, Response, RequestHandler } from 'express';
import { User, UserDataStore } from '../services/user-datastore';

import * as expressJWT from "express-jwt";
import * as jwt from "jsonwebtoken";

const TOKEN_SECRET = 'CryptoGraphix';

export var tokenValidator = expressJWT( { secret: TOKEN_SECRET } );

/**
* Express middleware to authenticate a user
*   For now, just retrieves a 'user' cookie, that is the logged-in username
*   If OK, the 'req' object will gain a user property on exit
*   If NOK, fail with a 401 (unauthorized) error code
*/
export function authenticateUser( req, res, next ) {

  // We need a user (extracted and validated by express-jwt)
  if ( req.user ) {
    console.log( req.user );

    next();
  }
  else
    res.sendStatus( 401 );
}

/**
* Create and export sub-router for '/api/auth'
*/

import * as express from 'express';
import * as jwt from 'express-jwt';
import * as controller from './controller';

const router = express.Router();
const auth = jwt({
  userProperty: 'payload',
  secret: process.env.JWT_SECRET
});

//BASE ROUTE: '/api/v1/items'

//GET: '/api/v1/items/user/:id'
router.get('/user/:id', controller.getAll);

//GET: '/api/v1/items/:id'
router.get('/:id', controller.getOne);

//POST: '/api/v1/items'
router.post('/', auth, controller.create);

//PUT: '/api/v1/items/:id'
router.put('/:id', auth, controller.update);

//DELETE: '/api/v1/items/:id'
router.delete('/:id', auth, controller.remove);

export = router;

import eventbriteSync from "./middleware/eventbrite-sync";
import * as config from "./config";
import reviver from "./middleware/reviver";
import addDataContext from "./middleware/add-data-context";
import * as eventApi from "./middleware/events-api";
import * as participantsApi from "./middleware/participants-api";
import * as sessions from "./middleware/sessionpicker-api";
import setupDb from "./middleware/db-setup-api";
import * as appinsights from "applicationinsights";
import * as jwt from "express-jwt";
import apiKeyAuth from "./middleware/key-auth";

appinsights.setup(config.APP_INSIGHTS_KEY).start();

var app = express();
const jwtCheck = jwt({ secret: config.AUTH0_SECRET, audience: config.AUTH0_CLIENT });
const jwtOptionalCheck = jwt({ secret: config.AUTH0_SECRET, audience: config.AUTH0_CLIENT, credentialsRequired: false });
const jwtCheckSessionpicker = jwt({ secret: config.AUTH0_SECRET_SESSIONPICKER, audience: config.AUTH0_CLIENT_SESSIONPICKER });

// Create express server
app.use(cors());
var bodyParserOptions = { reviver: reviver };
app.use(bodyParser.json(bodyParserOptions));

// Endpoint for initializing the DB. Will return an error if DB already initialized
app.get("/admin/db-setup", jwtCheck, setupDb);

// Endpoint for triggering Eventbrite sync
app.post("/admin/eventbrite-sync", jwtCheck, ensureAdmin, eventbriteSync);

// Events API

import * as express from 'express';
import * as util from 'gulp-util';
import * as chalk from 'chalk';
import * as jwt from 'express-jwt';
import * as _ from 'lodash';
import {User} from './user';
import {UserContainer} from './user.container';

const EXPRESS_APP = express();
EXPRESS_APP.use(express.static(__dirname + '/../app'));
EXPRESS_APP.use(express.static(__dirname + '/../../../'));

const userContainer=new UserContainer(1000000);
const JWT_CHECK=jwt({
	secret: new Buffer("VqPEjyiGncpqLZoPFgZNUIQsEcVRbZ4vcjN85uQF5cTaAHCIauUacPTdQ_f0OzZ1", 'base64'),
	audience: 'bUfoWb8hk8OsP9VUV2gpr7WlFE5LOWb9'
});

const QUOTES:string[]=[
	"Hey I'm this API server!",
	"API Server says hello to you visitor!",
	"You are welcome!"
]

EXPRESS_APP.use('/', JWT_CHECK);
EXPRESS_APP.get('/', (req: express.Request, res: express.Response) => {
	res.json('Welcome to the builder APP REST API!');
});

EXPRESS_APP.get('/users', (req: express.Request, res: express.Response)=>{
	res.json({

server.setConfig((app) => {

    app.use(bodyParser.urlencoded({ extended: true }));
    app.use(bodyParser.json());
    app.use(morgan('combined'));
    app.use(cors({
        origin: (origin, callback) => {
            try {
                let ok: boolean = config.originsWhitelist.indexOf(origin) !== -1
                callback(null, ok);
            } catch (e) {
                callback(e, null);
            }

        }
    }));
    app.use(jwt({ secret: config.appSecret })
        .unless({
            path: ['/api/account/login', '/setup', '/',
                {
                    url: '/api/donors',
                    methods: ['GET', 'POST']
                }]
        }));

   let feed: DonorsFeed = kernel.get<DonorsFeed>(TYPES.DonorsFeed);
   feed.start(httpServer);
});

const protect = () => {
	return expressJwt({
		secret: config.security.tokenSecret,
		getToken: (req: Request) => {
            return req.cookies.token;
		},
	}).unless({path: [ '/api/login', '/api/register', '/api/logout' ]});
};

 return (req, res, next) => {
     jwt({
         secret: expressJwtSecret({
             cache: true,
             rateLimit: true,
             jwksRequestsPerMinute: 5,
             jwksUri: `https://${EnvConfig.AUTH0_DOMAIN}/.well-known/jwks.json`
         }),
         aud: EnvConfig.AUTH0_AUDIENCE,
         iss: `https://${EnvConfig.AUTH0_DOMAIN}/`,
         algorithm: 'RS256'
     })(req, res, this.next.bind(this, next));
 };

server.setConfig((app) => {

    app.use(bodyParser.urlencoded({ extended: true }));
    app.use(bodyParser.json());
    app.use(morgan('combined'));
    app.use(cors({
        origin: (origin, callback) => {
            try {
                let ok: boolean = config.originsWhitelist.indexOf(origin) !== -1
                callback(null, ok);
            } catch (e) {
                callback(e, null);
            }

        }
    }));
    app.use(jwt({ secret: config.appSecret})
    .unless({path: ['/api/account/login', '/setup', '/']}));
    
});

  setupSwagger() {
    // resolve the spec
    const spath = path.resolve('swagger.yml');
    const file = fs.readFileSync(spath, 'utf8');
    const spec = yaml.safeLoad(file);
    
    // init jwt middleware
    const jwtSecret = config.get('auth.jwt_secret').toString();
    let jwt = expressJwt({
      secret: new Buffer(jwtSecret, 'base64')
    });

    // setup middleware swagger middleware in express
    swaggerTools.initializeMiddleware(spec, (middleware) => {
      this.app.use(middleware.swaggerMetadata());
      
      this.app.use(middleware.swaggerValidator({
        validateResponse: true
      }));

      this.app.use(middleware.swaggerSecurity({
        jwt_token: (req, authOrSecDef, scopes, cb) => {
          jwt(req, req.res, (err) => {
            if (req.userName === undefined) {
              return cb(new Error('Access Denied!'));
            } else {
              logger.info(`${req.userName} authorized`, req.userName);
              return cb(null);
            }
          });
        }
      }));

      this.app.use(middleware.swaggerUi());
    });
  }

 */

const app = express();
const hostname = process.env.HOSTNAME || 'localhost';
const port = parseInt(process.env.PORT, 10) || 3000;
const isDev = 'development' === app.get('env');
const publicDir = process.argv[2] || path.join(__dirname, '..', '..', 'client');


app
    .use(morgan('dev'))
    .use(bodyParser.json())
    .get('/index.dev.html', (req, res) =>
        res.redirect(301, '/')
    )
    .get('/index.prod.html', (req, res) =>
        res.redirect(301, '/')
    )
    .use(express.static(publicDir))
    .use('/auth', authRoutes)
    .get('/secret', jwtMiddleware({
        secret: config.auth.TOKEN_SECRET
    }), (req, res) => res.send('4 8 15 16 23 42'))
    .get("*", (req, res) =>
        res.sendFile(path.join(publicDir, isDev ? "index.dev.html" : "index.prod.html"))
    )
    .listen(port, hostname, () =>
        console.log(`Server listening at http://${hostname}:${port} ${app.get('env')}`)
    );