/**
     * Constructor
     * @param application: the KOA application
     */
    constructor (webServer: WebServer) {
        this.webServer = webServer;
        this.router = new KoaRouter();

        // Create routes
        this.openDevTools();
        this.getVersion();
        this.getOsPlatform();
        this.getAddress();

        this.getOpenedFile();
        this.setOpenedFile();
        
        webServer.localApplication.use(this.router.routes());
        webServer.externApplication.use(this.router.routes());
    }

export function createHttpServer(): HttpServer {
  const koa = new Koa()
  installMiddlewares(koa)
  const router = new KoaRouter()
  koa.use(router.routes())
  koa.use(router.allowedMethods())
  return httpCreateServer(koa.callback())
}

const main = async () => {
    const app = new Koa();
    const router = new Router();
    const apolloServer = new ApolloServer({
        formatError: err => {
            logger.error(err);
            return err;
        },
        schema: Schema,
        playground: {
            endpoint: "/tictactoe/graphql"
        }
    });
    apolloServer.applyMiddleware({ app });

    app.use(koabody());

    router.get("/ping", async ctx => {
        ctx.body = "pong";
    });

    app.use(router.routes());

    app.use(koaBunyanLogger());
    app.use(koaBunyanLogger.requestLogger());

    process.on("unhandledRejection", err => {
        logger.error(err);
    });

    await connectWithRetry();
    const server = createServer(app.callback());

    SubscriptionServer.create(
        {
            schema: Schema,
            execute,
            subscribe
        },
        {
            server,
            path: "/ws"
        }
    );

    server.listen(3000, () => {
        logger.info("listening on 3000");
    });
};

app.prepare().then(() => {
  const server = new Koa();
  const router = new Router();

  router.get('*', async ctx => {
    await handle(ctx.req, ctx.res);
    ctx.respond = false;
  });

  server.use(async (ctx, next) => {
    ctx.res.statusCode = 200;
    await next();
  });

  server.use(router.routes());

  server.listen(port);
});

export function setRouters(app: Koa, RouterClass: any[]): void {
  RouterClass.forEach(Router => {
    return new Router()
  })

  routerSet.forEach(Func => {
    Func()
  })

  app.use(koaRouter.routes())

  app.use(async (ctx) => {
    ctx.res.setHeader('Access-Control-Allow-Origin', ctx.request.header.origin || '*')
    ctx.res.setHeader('Access-Control-Allow-Credentials', 'true')
    ctx.res.setHeader('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS')
    ctx.res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Requested-With, AUTHORIZATION, X-Socket-Id')
  })
}

createConnection().then(async connection => {

    // create koa app
    const app = new Koa();
    const router = new Router();

    // register all application routes
    AppRoutes.forEach(route => router[route.method](route.path, route.action));

    // run app
    app.use(bodyParser());
    app.use(router.routes());
    app.use(router.allowedMethods());
    app.listen(3000);

    console.log("Koa application is up and running on port 3000");

}).catch(error => console.log("TypeORM connection error: ", error));

export default (app?: Koa) => {
  const provided = !!app

  const middlewares = [bodyParser(), router.routes(), router.allowedMethods()]

  if (!app) {
    app = new Koa()
    app.keys = app.keys = (process.env.APP_KEYS || '').split(',')
    middlewares.unshift(session({}, app))
  }

  if (provided) {
    return middlewares
  }

  app.use(compose(middlewares))

  app.listen(serverPort + 1, serverHost, () => {
    debug('Router server is now running at %s:%s', serverHost, serverPort + 1)
  })
}

    add: (app, middleware, options) => {
      app.use(
        webpackServeWaitpage(options, {
          template: fs.readFileSync(
            path.join(config.paths.gitRoot, 'webpack', 'config', 'waitpage.ejs'),
            'utf8'
          )
        })
      )

      app.use(mount('/node_modules', serve(config.paths.nodeModules)))

      app.use(
        mount('/currencies', serve(path.join(config.paths.vendor, 'game-currency-formats', 'src')))
      )

      // Make sure the usage of webpack-serve-waitpage will be before the following commands if exists
      middleware.webpack()
      middleware.content()

      app.use(router.routes())
    }

function createServer() {
  const app = new Koa();
  app.use(bodyParser());
  app.use(cors());
  app.use(staticFiles(path.join(__dirname, 'public')));

  const router = new Router();
  router.get('/api/animals', async (ctx) => {
    ctx.body =  [
      {id: 1, name: 'cat'},
      {id: 2, name: 'dog'},
      {id: 3, name: 'fish'}
    ];
  });

  app.use(async (ctx, next) => {
    try {
      await next();
    } catch (err) {

      const error = {
        errorType: 'UNHANDLED_ERROR',
        message: err.message,
        stack: err.stack
      };

      ctx.body = error;
      // tslint:disable-next-line:no-console
      console.error(error);
    }
  });

  app
  .use(router.routes())
  .use(router.allowedMethods());

  return app;
}

});


// logger

app.use(function *(next){
  const start = new Date().getTime();
  yield next;
  const ms = new Date().getTime() - start;
  console.log('%s %s - %s', this.method, this.url, ms);
});

// Redirect

redirect_router.redirect('/', '/static/main.html');
app.use(redirect_router.routes());
app.use(redirect_router.allowedMethods());

// static

app.use(mount('/static', serve('../frontend/build')));


// responses under /api

router.get('/hello', function *(next) {
  this.body = 'hello';
});


function query_to_linestring(points) {

/// <reference path="./d.ts/node.d.ts" />
/// <reference path="./d.ts/koa.d.ts" />

import {YabpConfig} from './modules/config/config.ts';

import databaseSetup = require('./modules/db/databaseSetup.ts')
import koa = require('koa');

var router = require('koa-router');
var yabpServer = new koa();

router
  .get("/REST/config/isConfigured", function* (next){
    this.statusCode = 200;
    this.set('Access-Control-Allow-Origin','http://localhost:9000')
    this.body = { isConfigured : false };
  })

yabpServer.use(router.routes()).use(router.allowedMethods());
yabpServer.listen(1988);

import { ensureAuthenticated } from './authUtils';
import * as Router from 'koa-router';
import * as authController from './auth.controller';
import * as meController from './me.controller';
import * as github from './github';
import * as google from './google';
import * as facebook from './facebook';
import * as linkedin from './linkedin';
import * as live from './live';
import * as twitter from './twitter';

const router = new Router();

// routes
router.post('/login', authController.login);
router.post('/signup', authController.signup);
router.post('/github', github.authenticate);
router.post('/google', google.authenticate);
router.post('/facebook', facebook.authenticate);
router.post('/linkedin', linkedin.authenticate);
router.post('/live', live.authenticate);
router.post('/twitter', twitter.authenticate);

// auth only applied for following routes, not the routes above
router.use(['/me', '/unlink'], ensureAuthenticated);
router.get('/me', meController.getMe );
router.put('/me', meController.updateMe );
router.get('/unlink/:provider', meController.unlink);

export default router.routes();

    // record visit
    if (whiteList[ctx.request.ip] === undefined) {
      visitList[ctx.request.ip] = Date.now();
      saveVisitList();
    }

    ctx.response.status = 200;
    ctx.body = JSON.stringify({
      statistics: { ...flavor },
      code: 200
    });
  } catch (e) {
    ctx.response.status = 400;
    ctx.body = JSON.stringify(
      {
        message: e.message,
        code: 400
      },
      null,
      2
    );
  } finally {
    fs.writeFileSync("./config.json", JSON.stringify(flavor, null, 2), "utf-8");
  }
});

loadConfig();
app.use(Koabody());
app.use(router.routes()).listen(8080);

  .post('/:url/unpublish', blogController.unpublish);

api.use(async (ctx, next) => {
  let auth = ctx.headers.auth;

  if (auth == Keys.api[ctx.method]) {
    await next();
  } else {
    ctx.status = 401;
    ctx.body = 'Unauthorized';
  }
})

api.get('/counts', countController.list)
  .post('/images', upload.single('file'), imageController.create)
  .use('/games', game.routes(), game.allowedMethods())
  .use('/gourmets', gourmet.routes(), gourmet.allowedMethods())
  .use('/hearthstone-seasons', hearthstoneSeason.routes(), hearthstoneSeason.allowedMethods())
  .use('/hearthstone-decks', hearthstoneDeck.routes(), hearthstoneDeck.allowedMethods())
  .use('/hearthstone-matches', hearthstoneMatch.routes(), hearthstoneMatch.allowedMethods())
  .get('/hearthstone-cards', hearthstoneCardController.list)
  .post('/game-trophy', trophyController.scrap)
  .use('/blogs', blog.routes(), blog.allowedMethods());

router.use('/api', api.routes(), api.allowedMethods())
  .get('/admin*', auth({ name: Keys.admin.user, pass: Keys.admin.password }), async (ctx, next) => {
    await send(ctx, 'admin.html', { root: path.join(__dirname, '..', '/public') });
  })
  .get('*', async (ctx, next) => {
    await send(ctx, 'index.html', { root: path.join(__dirname, '..', '/public') });
  })

// Read more about routing at https://github.com/alexmingoia/koa-router
const router = new Router({prefix: '/api'});
router.get('/people', getAllPeople);
router.get('/todos', getAllTodo);
router.get('/todos/:id', getTodo);
router.post('/todos', addTodo);
router.patch('/todos/:id', patchTodo);
router.delete('/todos/:id', deleteTodo);

// Read more about koa at http://koajs.com/
const app = new Koa();
app.use(cors());
app.use(logger());
app.use(bodyParser());
app.use(router.routes());

// Read more about koa views at https://github.com/queckezz/koa-views
// Read more about Nunjucks at https://mozilla.github.io/nunjucks/
const viewPath = path.join(__dirname, 'views');
app.use(views(viewPath, {
  map: {html: 'nunjucks'},
  options: {loader: new FileSystemLoader(viewPath)}
}));
app.use(async (ctx, next) => {
  // If nothing else was found, render index (assumption: single-page app)
  await ctx.render('index');
});

const port: (number|string) = process.env.PORT || 8080;
app.listen(port, () => {

switch (environment) {
    case 'build':
        //TODO: implement build environment server
        break;

    default:
        console.log('*** DEV ***');
        console.log('rootDir: ' + rootDir);
        app.use(convert(serve(path.join(rootDir, './src/client'))));
        app.use(convert(serve(path.join(rootDir, './'), { hidden: true })));

        router.get('/*', function *(ctx: KoaRouter.IRouterContext, next: any) {
            this.body = yield fs.readFile(path.join(rootDir, './src/client/index.html'), 'utf-8');
        });
        break;
}

app.use(convert(router.routes()));

app.on('error', (err: Error) => {
   console.log(err);
   console.log('Koa server error occurred.');
});

if (!module.parent) {
    app.listen(port, function() {
        console.log(`Koa server listening on port ${port}...`);
    });
}

function sanitizeRoom({ name, memberCount }: any) {
  return {
    name,
    memberCount,
  }
}

const router = new KoaRouter()

router.get("/", async (ctx, next) => {
  ctx.body = board.rooms.chain().simplesort("memberCount", true).data().map(sanitizeRoom)
})

app.use(cors())
app.use(router.routes()).use(router.allowedMethods())

// server.on("request", function (req, res) {
//   if (req.url === "/") {
//     res.writeHead(302, {
//       Location: "https://github.com/rtc-io/rtc-switchboard",
//     })
//     res.end("switchboard available from: https://github.com/rtc-io/rtc-switchboard")
//   }
//   if (req.url === "/rooms") {
//     res.end(JSON.stringify(board.rooms.chain().simplesort("memberCount", true).data().map(sanitizeRoom)))
//   }
// })

// start the server
server.listen(port, host, (err: Error) => {

 routes() {
     return this.router.routes();
 }

export function App(client:Assets, options: AssetsRouterOptions = {}	) {

	let app = new Koa();

	let router = new Router();

	let p = options.prefix|| '/'

	
	router.post(p, convert(body({multipart:true})), createAsset);
	router.get(p, listAssets);
	router.get(Path.join(p, '*'), getAsset);
	
	router.del(Path.join(p, '*'), deleteAsset);

	app.use(convert(cors({
		origin: '*',
		expose: ['Link']
		//expose: 'Content-Type'
	})))

	
	app.use(router.routes());
	//app.use(router.allowedMethods())
	//router.put('/')
	return app;



	async function listAssets(ctx: Koa.Context) {
		ctx.type = 'json';
		let query = ctx.query;

		if (query.id) {
			let asset = await client.getById(query.id);

			if (!asset) {
				ctx.throw(404, {message:'not found'});
			}

			ctx.body = asset;
		}

		let page = 1, limit = 100;
        if (query.page) {
            let i = parseInt(query.page);
            if (!isNaN(i)) page = i;
        }

        if (query.limit) {
            let i = parseInt(query.limit);
            if (!isNaN(i)) limit = i;
        }

        if (page <= 0) page = 1;

        let result;
        if (query.q) {
            result = await client.query(query.q);
        } else {
            let count = await client.metaStore.count();
            let pages = Math.ceil(count / limit);
            let offset = limit * (page - 1);

            if (offset > count) {
                result = [];
            } else {
                result = await client.list({
                    offset: offset,
                    limit: limit
                });
            }

            let links: any = {
                first: 1,
                last: pages
            };

            if (page > 1) links.prev = page - 1;
            if (page < pages) links.next = page + 1;

            _writeLinksHeader(ctx, links);

        }
		
        ctx.body = result;
	
	}


	async function getAsset(ctx: Koa.Context) {
		let query = ctx.query

		let path = ctx.path;

        if (path[0] !== '/') path = "/" + path;
        
        let asset = (await client.getByPath(path));
        console.log(asset)
        if (!asset) ctx.throw(404);
//.........这里部分代码省略.........

  public async mount(rootApp: Koa) {
    const config = this.config;
    const app = new Koa();
    // todo: isolate the cookieKeys under mounted app
    // https://github.com/koajs/mount/pull/58
    app.keys = config.cookieKeys;

    // construct auth related middlewares
    const {
      beforeRenderCms,
      authCallback,
      logout,
    } = await construct(config, authCallbackPath);

    // logging
    const loggingMiddleware = createLoggerMiddleware(this.logger);

    // router
    const router = new Router();
    // error handler
    router.use('*', loggingMiddleware, async (ctx: Context, next) => {
      try {
        await next();
      } catch (err) {
        this.logger.fatal({
          message: err.message,
          stacktrace: err.stack,
        });
        const errorCode = (err.isBoom && err.data && err.data.code) ? err.data.code : 'INTERNAL_ERROR';
        const statusCode =
          (err.isBoom && err.output && err.output.statusCode) ? err.output.statusCode : err.status || 500;

        ctx.status = statusCode;
        ctx.body = {code: errorCode, message: err.message};
      }
    });

    router.use(views(path.join(__dirname, './views'), {
      extension: 'pug'
    }));

    // serve client static
    const clientStatic = serve(this.config.staticsPath, this.config.clientBundledDir);
    router.get(clientStatic.path, loggingMiddleware, clientStatic.middleware);

    // serve favicon
    const faviconPath = path.resolve(__dirname, '../public/favicon');
    const favicon = serve('/public/favicon', faviconPath);
    router.get(favicon.path, loggingMiddleware, favicon.middleware);

    // cms
    const setConfigMiddleware = async (ctx: Context, next: () => Promise<any>) => {
      // put into frontendConfig
      const username = ctx.cookies.get(usernameCookieKey, {signed: true});
      const accessToken = ctx.cookies.get(accessTokenCookieKey, {signed: true});
      const graphqlEndpoint = config.graphqlEndpoint;
      ctx.state.frontendConfig = JSON.stringify({username, accessToken, graphqlEndpoint});
      return next();
    };

    router.get('/cms', loggingMiddleware, beforeRenderCms, setConfigMiddleware, async ctx => {
      await ctx.render('cms', {title: 'Canner CMS', staticsPath: config.staticsPath});
    });

    router.get('/cms/*', loggingMiddleware, beforeRenderCms, setConfigMiddleware, async ctx => {
      await ctx.render('cms', {title: 'Canner CMS', staticsPath: config.staticsPath});
    });

    // auth callback
    router.get(authCallbackPath, loggingMiddleware, authCallback, async ctx => {
      ctx.redirect('/cms');
    });

    // logout
    router.get('/auth/logout', loggingMiddleware, logout, async ctx => {
      // if logout middleware calls next, it will redirect to /cms
      ctx.redirect('/cms');
    });

    // health check
    router.get('/health', loggingMiddleware, async ctx => {
      ctx.status = 200;
    });

    // redirect
    router.get('/', loggingMiddleware, async (ctx: Context) => {
      return ctx.redirect('/cms');
    });

    app.use(router.routes());

    // mount cmsApp to rootApp
    const cmsMiddleware = koaMount(app);
    rootApp.use(cmsMiddleware);
  }