const session = require('express-session');

app.use(session({
  resave: false,
  saveUninitialized: false,
  secret: 'secret code',
  cookie: {
    httpOnly: true,
    secure: false,
  },
}));

const flash = require('connect-flash');

app.use(flash());

// TRY: http://localhost:3000/users/flash
router.get('/flash', function (req, res) {
  req.session.message = 'Session Message';
  req.flash('message', 'Flash Message');
  res.redirect('/users/flash/result');
});

router.get('/flash/result', function (req, res) {
  res.send(`req.session.message=${req.session.message}, req.flash('message')=${req.flash('message')}`);
});

// 'use strict';

// const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');

// const basename = path.basename(__filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};

let sequelize;

// if (config.use_env_variable) {
//   sequelize = new Sequelize(process.env[config.use_env_variable], config);
// } else {
  sequelize = new Sequelize(config.database, config.username, config.password, config);
// }

// fs
//   .readdirSync(__dirname)
//   .filter(file => {
//     return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
//   })
//   .forEach(file => {
//     const model = sequelize['import'](path.join(__dirname, file));
//     db[model.name] = model;
//   });

// Object.keys(db).forEach(modelName => {
//   if (db[modelName].associate) {
//     db[modelName].associate(db);
//   }
// });

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

const { User, Todo } = require('../models');

// Insert Dummy Data for Test
module.exports = async () => {
  try {
    await User.create({ name: 'oliver', age: 20, married: false, comment: 'programmer' });
    await User.create({ name: 'jack', age: 21, married: false, comment: 'designer' });
    await User.create({ name: 'harry', age: 30, married: true, comment: 'programmer' });
    await User.create({ name: 'jacob', age: 25, married: false, comment: 'designer' });
    await User.create({ name: 'charlie', age: 34, married: false, comment: 'programmer' });
    await User.create({ name: 'thomas', age: 33, married: false, comment: 'designer' });
    await User.create({ name: 'george', age: 40, married: true, comment: 'teacher' });
    await User.create({ name: 'oscar', age: 49, married: true, comment: 'salesman' });
    await User.create({ name: 'james', age: 55, married: false, comment: 'salesman' });
    await User.create({ name: 'william', age: 66, married: true, comment: 'none' });
    await User.create({ name: 'jake', age: 18, married: false, comment: 'teacher' });
    console.log('▶ 11 users inserted.');
    
    await Todo.create({ owner: 1, task: 'to learn node 1', done: false });
    await Todo.create({ owner: 1, task: 'to learn node 2', done: true });
    await Todo.create({ owner: 1, task: 'to learn node 3', done: false });
    await Todo.create({ owner: 1, task: 'to learn node 4', done: true });
    await Todo.create({ owner: 1, task: 'to learn node 5', done: false });
    await Todo.create({ owner: 1, task: 'to learn node 6', done: true });
    await Todo.create({ owner: 1, task: 'to learn node 7', done: false });
    await Todo.create({ owner: 1, task: 'to learn node 8', done: true });
    await Todo.create({ owner: 1, task: 'to learn node 9', done: false });
    await Todo.create({ owner: 1, task: 'to learn node 10', done: true });
    await Todo.create({ owner: 1, task: 'to learn node 11', done: false });
    console.log('▶ 11 todos inserted.');
  } catch (err) {
    console.error(err);
    throw err;
  }
}

const { sequelize } = require('./models');

// app.get('env') returns 'development' 
// if process.env.NODE_ENV is not defined.
console.log('----------------------');
console.log('MODE: ' + app.get('env'));
console.log('----------------------');

/*
 * connect to DB
 */
if (app.get('env') === 'development') {
  // If force is true, each Model will run DROP TABLE IF EXISTS, 
  // before it tries to create its own table
  sequelize.sync({
    force: true,
  }).then(() => {
    // Insert Dummy Data for Test
    require('./sql/dummy')();
  });
} else {
  sequelize.sync({
    // default value
    force: false,
  });
}

module.exports = (sequelize, DataTypes) => {
  return sequelize.define('user', {
    name: {
      type: DataTypes.STRING(20),
      allowNull: false,
      unique: true,
    },
    age: {
      type: DataTypes.INTEGER.UNSIGNED,
      allowNull: false,
    },
    married: {
      type: DataTypes.BOOLEAN,
      allowNull: false,
    },
    comment: {
      type: DataTypes.TEXT,
      allowNull: true,
    },
    created_at: {
      type: DataTypes.DATE,
      allowNull: false,
      defaultValue: sequelize.literal('now()'),
    },
  }, {
    timestamps: false,
  });
};

module.exports = (sequelize, Sequelize) => {
  return sequelize.define('todo', {
    task: {
      type: Sequelize.STRING(100),
      allowNull: false,
      unique: false,
    },
    done: {
      type: Sequelize.BOOLEAN,
      allowNull: false,
      unique: false,
      defaultValue: false,
    }
  }, {
    timestamps: true,
    paranoid: true,
    underscored: true,
  });
}

const path = require('path');
const Sequelize = require('sequelize');

const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};

const sequelize = new Sequelize(config.database, config.username, config.password, config);

db.sequelize = sequelize;
db.Sequelize = Sequelize;

db.User = require('./user')(sequelize, Sequelize);
db.Todo = require('./todo')(sequelize, Sequelize);

// One User has Many Todos.
// Users 테이블의 id를 Todos 테이블의 owner 칼럼에 넣는다.
db.User.hasMany(db.Todo, {
  foreignKey: 'owner', 
  sourceKey: 'id',
});
// One Todo belongs to One User.
// Users 테이블의 id를 Todos 테이블의 owner 칼럼에 넣는다.
db.Todo.belongsTo(db.User, {
  foreignKey: 'owner', 
  targetKey: 'id',
});

module.exports = db;

var express = require('express');
var router = express.Router();
const { User, Todo } = require('../models');

// ---------------------------------------
// TEST
// TRY: http://localhost:3000/users/flash
router.get('/flash', function(req, res) {
  req.session.message = 'Session Message';
  req.flash('message', 'Flash Message');
  res.redirect('/users/flash/result');
});

router.get('/flash/result', function(req, res) {
  res.send(`req.session.message=${req.session.message}, req.flash('message')=${req.flash('message')}`);
});
// ---------------------------------------

// req.params : Path Variable(URL Segment)값을 갖고 있다.
// req.body : Body 영역에 할당되어 전달되는 값을 갖고 있다.
// req.query : 물음표(?) 뒤에 설정되는 Search(Query Params) 값을 갖고 있다.

router.get('/', function(req, res, next) {
  User.findAll({}).then((users) => {
    // 반환결과는 다음과 같다.
    // [
    //   {
    //       "id": 1,
    //       "name": "john",
    //       "age": 24,
    //       "married": false,
    //       "comment": "programmer",
    //       "created_at": "2019-01-25T18:10:32.000Z"
    //   },
    //   {
    //       "id": 2,
    //       "name": "tom",
    //       "age": 32,
    //       "married": true,
    //       "comment": "actor",
    //       "created_at": "2019-01-25T18:10:32.000Z"
    //   }
    // ]
    res.json(users);
  }).catch((err) => {
    console.error(err);
    next(err);
  });
});

router.get('/:id', function(req, res, next) {
  User.findOne({
    where: {
      id: req.params.id
    }
  }).then((user) => {
    // 반환결과는 다음과 같다.
    // {
    //   "id": 1,
    //   "name": "john",
    //   "age": 24,
    //   "married": false,
    //   "comment": "programmer",
    //   "created_at": "2019-01-25T18:10:32.000Z"
    // }
    res.json(user);
  }).catch((err) => {
    console.error(err);
    next(err);
  });
});

router.post('/', function(req, res, next) {
  // 예상쿼리는 다음과 같다.
  // INSERT INTO users(name, age, married, comment) VALUES('john', 24, 0, 'programmer');

  User.create({
    name: req.body.name,
    age: req.body.age,
    married: req.body.married,
    comment: req.body.comment,
  }).then((user) => {
    console.log(user); 
    // 반환결과는 다음과 같다.
    // {
    //   created_at: '2019-01-26T08:53:56.491Z',
    //   id: 7,
    //   name: '11',
    //   age: 22,
    //   married: false,
    //   comment: '33'
    // }
    res.json(user);
  }).catch((err) => {
    console.error(err);
    next(err);
  })
  // 실제로 사용된 쿼리는 다음과 같다.
  // INSERT INTO `users` (`id`,`name`,`age`,`married`,`comment`,`created_at`) 
  // VALUES (DEFAULT,'11',22,false,'33',now());
});

router.put('/:id', function(req, res, next) {
  User.update({
    name: req.body.name,
    age: req.body.age,
    married: req.body.married,
    comment: req.body.comment,
  }, {
    where: {
      id: req.params.id,
    }
  }).then((affectedRowsArray) => {
    console.log(affectedRowsArray);
    // [ 1 ]
    res.json(affectedRowsArray);
  }).catch((err) => {
    console.error(err);
    next(err);
  });
});

router.delete('/:id', function(req, res, next) {
  User.destroy({
    where: {
      id: req.params.id
    }
  }).then((affectedRows) => {
    console.log(affectedRows);
    // 1
    res.json(affectedRows);
  }).catch((err) => {
    console.error(err);
    next(err);
  })
});

module.exports = router;

var express = require('express');
var router = express.Router();
const { User, Todo, Sequelize: { Op, where, fn, col } } = require('../models');

// 주목: fn('date', col('created_at')) 함수로 처리하면 아래 둘다 가능하다.
// http://localhost:3000/todos?created_at=20190126
// http://localhost:3000/todos?created_at=2019-01-26
router.get('/', async function(req, res, next) {
  const filter = {};
  
  if (req.query.created_at) {
    console.log(req.query.created_at);
    filter.created_at = where(fn('date', col('created_at')), '=', req.query.created_at);
  }
  
  // 명시하지 않으면 [Op.and] 연산이 적용된다. and 연산일 때는 굳이 아래처럼 할 필요가 없다.
  // const filter = {
  //   [Op.and]: [
  //     {
  //       id: req.params.id,
  //     },
  //   ]
  // };
  // 
  // if (req.query.created_at) {
  //   filter[Op.and].push(where(fn('date', col('created_at')), '=', req.query.created_at));
  // }
  
  try {
    const todos = await Todo.findAll({
      where: filter
    });
    console.log(todos);
    // 반환결과는 다음과 같다.
    // [
    //   {
    //     id: 1,
    //     task: "to learn node 1",
    //     done: false,
    //     created_at: "2019-01-26T12:16:18.000Z",
    //     updated_at: "2019-01-26T12:16:18.000Z",
    //     deleted_at: null,
    //     owner: 1
    //   },
    //   ...
    //   {
    //     id: 11,
    //     task: "to learn node 11",
    //     done: false,
    //     created_at: "2019-01-26T12:16:18.000Z",
    //     updated_at: "2019-01-26T12:16:18.000Z",
    //     deleted_at: null,
    //     owner: 1
    //   }
    // ]
    res.json(todos);
  } catch (e) {
    console.error(err);
    next(err);
  }
  // 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  //   `id`, `task`, `done`, `created_at`, `updated_at`, `deleted_at`, `owner` 
  // FROM `todos` AS `todo` 
  // WHERE (
  //   (`todo`.`deleted_at` > '2019-01-26 12:23:12' OR `todo`.`deleted_at` IS NULL) 
  //   AND 
  //   date(`created_at`) = '20190126'
  // );
});

router.get('/:id', async function(req, res, next) {
  try {
    const todo = await Todo.findOne({
      where: {
        id: req.params.id,
      },
    });
    console.log(todo);
    // 반환결과는 다음과 같다.
    // {
    //   "id": 1,
    //   "task": "go shpping",
    //   "done": true,
    //   "created_at": "2019-01-25T17:52:51.000Z",
    //   "updated_at": "2019-01-25T17:52:51.000Z",
    //   "deleted_at": null,
    //   "owner": 1
    // }
    res.json(todo);
  } catch (e) {
    console.error(err);
    next(err);
  }
  // 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  //   `id`, `task`, `done`, `created_at`, `updated_at`, `deleted_at`, `owner` 
  // FROM `todos` AS `todo` 
  // WHERE (
  //   (`todo`.`deleted_at` > '2019-01-26 12:16:25' OR `todo`.`deleted_at` IS NULL) 
  //   AND 
  //   `todo`.`id` = '1'
  // );
});

router.post('/', async function(req, res, next) {
  // 예상쿼리는 다음과 같다.
  // INSERT INTO todos(owner, task, done) VALUES(1, 'go shpping', 1);
  try {
    const todo = await Todo.create({
      owner: req.body.owner,
      task: req.body.task,
      done: req.body.done,
    });
    console.log(todo);
    // 반환결과는 다음과 같다.
    // {
    //   "id": 3,
    //   "owner": 1,
    //   "task": "to study",
    //   "done": false,
    //   "updated_at": "2019-01-26T07:54:47.651Z",
    //   "created_at": "2019-01-26T07:54:47.651Z"
    // }
    res.json(todo);
  } catch (e) {
    console.error(err);
    next(err);
  }
  // 실제로 사용된 쿼리는 다음과 같다.
  // INSERT INTO `todos` (`id`,`task`,`done`,`created_at`,`updated_at`,`owner`) 
  // VALUES (DEFAULT,'to study',false,'2019-01-26 07:54:47','2019-01-26 07:54:47',1);
});

router.put('/:id', async function(req, res, next) {
  try {
    const affectedRowsArray = await Todo.update({
      owner: req.body.owner,
      task: req.body.task,
      done: req.body.done,
    }, {
      where: {
        id: req.params.id,
      }
    });
    console.log(affectedRowsArray);
    // 반환결과는 다음과 같다.
    // [ 1 ]
    res.json(affectedRowsArray);
  } catch (e) {
    console.error(err);
    next(err);
  }
  // 주목: updated_at 칼럼의 정보는 자동으로 갱신된다.
});

router.delete('/:id', async function(req, res, next) {
  try {
    const affectedRows = await Todo.destroy({
      where: {
        id: req.params.id,
      }
    });
    console.log(affectedRows);
    // 반환결과는 다음과 같다.
    // 1
    res.json(affectedRows);
  } catch (e) {
    console.error(err);
    next(err);
  }
  // 주목: 로우가 삭제되는 대신 deleted_at 칼럼에 삭제시각 정보가 입력된다.
});

module.exports = router;

var express = require('express');
var router = express.Router();
const { User, Todo, Sequelize: { Op, where, fn, col } } = require('../models');

function seekOffset(page, size) {
	if (page > 0) {
		return (page - 1) * size;
	}
	return 0;
}

// http://localhost:3000/deep/users?page=1&size=3
router.get('/', function(req, res, next) {
  let page = 1;
  let size = 10;
  
  if (req.query.page) {
    page = +req.query.page;
  }
  if (req.query.size) {
    size = +req.query.size;
  }
  
  const limit = size;
  const offset = seekOffset(page, size);
  
  User.findAll({
    limit,
    offset,
    include: {
      model: Todo,
    },
  }).then((users) => {
    // 반환결과는 다음과 같다.
    // [
    //   {
    //     id: 1,
    //     name: "chris",
    //     age: 20,
    //     married: false,
    //     comment: "programmer",
    //     created_at: "2019-01-26T10:34:13.000Z",
    //     todos: [
    //       {
    //         id: 1,
    //         task: "to learn node",
    //         done: false,
    //         created_at: "2019-01-26T10:34:13.000Z",
    //         updated_at: "2019-01-26T10:34:13.000Z",
    //         deleted_at: null,
    //         owner: 1
    //       }
    //       ...
    //     ]
    //   }
    //   ...
    // ]
    res.json(users);
  }).catch((err) => {
    console.error(err);
    next(err);
  });
  // 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  //   `user`.`id`, `user`.`name`, `user`.`age`, 
  //   `user`.`married`, `user`.`comment`, `user`.`created_at`, 
  //   `todos`.`id` AS `todos.id`, `todos`.`task` AS `todos.task`, 
  //   `todos`.`done` AS `todos.done`, `todos`.`created_at` AS `todos.created_at`, 
  //   `todos`.`updated_at` AS `todos.updated_at`, `todos`.`deleted_at` AS `todos.deleted_at`, 
  //   `todos`.`owner` AS `todos.owner` 
  // FROM `users` AS `user` LEFT OUTER JOIN `todos` AS `todos` 
  // ON `user`.`id` = `todos`.`owner` 
  // AND (`todos`.`deleted_at` > '2019-01-26 10:34:28' OR `todos`.`deleted_at` IS NULL);
  
  // limit, offset을 추가로 설정하면 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  //   `user`.*, 
  //   `todos`.`id` AS `todos.id`, `todos`.`task` AS `todos.task`, 
  //   `todos`.`done` AS `todos.done`, `todos`.`created_at` AS `todos.created_at`, 
  //   `todos`.`updated_at` AS `todos.updated_at`, `todos`.`deleted_at` AS `todos.deleted_at`, 
  //   `todos`.`owner` AS `todos.owner` 
  // FROM (
  //   SELECT `user`.`id`, `user`.`name`, `user`.`age`, `user`.`married`, `user`.`comment`, `user`.`created_at` 
  //   FROM `users` AS `user` LIMIT 0, 3
  // ) AS `user` LEFT OUTER JOIN `todos` AS `todos` 
  // ON `user`.`id` = `todos`.`owner` 
  // AND (`todos`.`deleted_at` > '2019-01-26 12:44:12' OR `todos`.`deleted_at` IS NULL);
});

// http://localhost:3000/deep/users/1?page=1&size=3&sort=id,desc
// http://localhost:3000/deep/users/1?page=1&size=3&sort=id,asc
router.get('/:id', function(req, res, next) {
  let page = 1;
  let size = 10;
  
  if (req.query.page) {
    page = +req.query.page;
  }
  if (req.query.size) {
    size = +req.query.size;
  }
  
  const limit = size;
  const offset = seekOffset(page, size);
  const order = [];
  
  if (req.query.sort) {
    order.push(req.query.sort.split(','));
    console.log(order);
    // [ [ 'id', 'asc' ] ]
  }
  
  User.findOne({
    where: {
      id: req.params.id
    },
    include: {
      model: Todo,
      limit,
      offset,
      order,
    },
  }).then((user) => {
    // 반환결과는 다음과 같다.
    // {
    //   id: 1,
    //   name: "chris",
    //   age: 20,
    //   married: false,
    //   comment: "programmer",
    //   created_at: "2019-01-26T10:34:13.000Z",
    //   todos: [
    //     {
    //       id: 1,
    //       task: "to learn node",
    //       done: false,
    //       created_at: "2019-01-26T10:34:13.000Z",
    //       updated_at: "2019-01-26T10:34:13.000Z",
    //       deleted_at: null,
    //       owner: 1
    //     }
    //   ]
    // }
    res.json(user);
  }).catch((err) => {
    console.error(err);
    next(err);
  });
  // 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  //   `user`.`id`, `user`.`name`, `user`.`age`, 
  //   `user`.`married`, `user`.`comment`, `user`.`created_at`, 
  //   `todos`.`id` AS `todos.id`, `todos`.`task` AS `todos.task`, 
  //   `todos`.`done` AS `todos.done`, `todos`.`created_at` AS `todos.created_at`, 
  //   `todos`.`updated_at` AS `todos.updated_at`, `todos`.`deleted_at` AS `todos.deleted_at`, 
  //   `todos`.`owner` AS `todos.owner` 
  // FROM `users` AS `user` LEFT OUTER JOIN `todos` AS `todos` 
  // ON `user`.`id` = `todos`.`owner` 
  // AND (`todos`.`deleted_at` > '2019-01-26 10:41:21' OR `todos`.`deleted_at` IS NULL) 
  // WHERE `user`.`id` = '1';
  
  // limit, offset을 추가로 설정하면 실제로 사용된 쿼리는 다음과 같다.
  // SELECT 
  // 	`user`.`id`, `user`.`name`, `user`.`age`, `user`.`married`, `user`.`comment`, `user`.`created_at` 
  // FROM `users` AS `user` 
  // WHERE `user`.`id` = '1';
  // 
  // SELECT 
  // 	`id`, `task`, `done`, `created_at`, `updated_at`, `deleted_at`, `owner` 
  // FROM `todos` AS `todo` 
  // WHERE (
  // 	(`todo`.`deleted_at` > '2019-01-28 00:40:24' OR `todo`.`deleted_at` IS NULL) 
  // 	AND 
  // 	(`todo`.`owner` IN (1) AND (`todo`.`deleted_at` > '2019-01-28 00:40:24' OR `todo`.`deleted_at` IS NULL))
  // ) 
  // ORDER BY `todo`.`id` ASC 
  // LIMIT 0, 3;
});

module.exports = router;

const { Router } = require('express');
const { User, Todo, Sequelize: { Op, where, fn, col }, sequelize } = require('../models');
const url = require('url');

const router = Router();

function seekOffset(page, size) {
	if (page > 0) {
		return (page - 1) * size;
	}
	return 0;
}

class Query {
  constructor(page, size, bsize) {
    this.page = page;
    this.size = size;
    this.bsize = bsize;
  }
}

class Path {
  constructor(active, link, query, text) {
    this.active = active;
    this.link = link;
    this.query = query;
    this.text = text;
  }
}
	
class Pager {
	
	constructor(page=1, size=10, bsize=5, rows=0, url){
		if (!url) {
			throw Error('url is required');
		}
		
		this.currentPage; // 현재 페이지(사용자가 보고싶은 페이지)
		this.elementsPerPage; // 페이지당 표시하는 로우의 개수
		this.pagesPerBlock; // 하단에 표시하는 페이징 넘버의 개수
		this.totalElements; // 테이블이 갖고 있는 모든 로우의 개수
		
		this.totalPages; // 전체 페이지 수
		this.totalBlocks; // 전체 블럭 수 
		
		this.currentBlock; // 현재 블럭
		this.currentBlockStartPage; // 현재 블럭의 시작 페이지 번호
		this.currentBlockEndPage; // 현재 블럭의 끝 페이지 번호
		
		this.beforePage; // 이전 페이지
		this.nextPage; // 다음 페이지
		
		this.paths = []; // Path's Array for Pagination
		
		this.currentPage = page; 
		if (this.currentPage <= 0) {
			this.currentPage = 1;
		}
		this.elementsPerPage = size;
		if (this.elementsPerPage <= 0) {
			this.elementsPerPage = 1;
		}
		this.pagesPerBlock = bsize;
		if (this.pagesPerBlock <= 0) {
			this.pagesPerBlock = 1;
		}
		this.totalElements = rows;

		this.totalPages = Math.ceil(this.totalElements / this.elementsPerPage);
		this.totalBlocks = Math.ceil(this.totalPages / this.pagesPerBlock);
		
		this.currentBlock = Math.ceil(this.currentPage / this.pagesPerBlock);
		this.currentBlockEndPage = this.currentBlock * this.pagesPerBlock;
		this.currentBlockStartPage = this.currentBlockEndPage - this.pagesPerBlock + 1;
		
		/*
		 * For Simple Paging with 2 Buttons (Before, Next)
		 */
		this.beforePage = this.currentPage - 1;
		if (this.beforePage < 0) {
			this.beforePage = 0;
		}
		this.nextPage = this.currentPage + 1;
		if (this.nextPage > this.totalPages) {
			this.nextPage = 0;
		}
		
		this.proceedPath(url);
	}
	
	proceedPath(url) {
		if (this.totalElements > 0) { // 로우가 있을 때
			if (this.currentBlockStartPage > this.pagesPerBlock) {
				// Home 버튼
				this.addPath(new Path('', url, 
					new Query(1, this.elementsPerPage, this.pagesPerBlock), 'Home'));
				// 이전 블럭
				this.addPath(new Path('', url, 
					new Query(this.currentBlockStartPage-1, this.elementsPerPage, this.pagesPerBlock), '<<'));
			}
			
			// Paging 버튼
			for (let pno = this.currentBlockStartPage; pno <= this.currentBlockEndPage; pno++) {
				if (pno == this.currentPage) {
					this.addPath(new Path('active', url, 
						new Query(pno, this.elementsPerPage, this.pagesPerBlock), pno.toString(10)));
				} else {
					if (pno <= this.totalPages) {
						this.addPath(new Path('', url, 
							new Query(pno, this.elementsPerPage, this.pagesPerBlock), pno.toString(10)));
					}
				}
			}
			
			if (this.currentBlockEndPage < this.totalPages) {
				// 이후 블럭
				this.addPath(new Path('', url, 
					new Query(this.currentBlockEndPage+1, this.elementsPerPage, this.pagesPerBlock), '>>'));
				// Last 버튼
				this.addPath(new Path('', url, 
					new Query(this.totalPages, this.elementsPerPage, this.pagesPerBlock), 'Last'));
			}
		} else { // 로우가 없을 때
			this.addPath(new Path('', url, 
				new Query(1, this.elementsPerPage, this.pagesPerBlock), '1'));
		}
	}
	
	addPath(path) {
		this.paths.push(path);
	}
	
}

// http://localhost:3000/pager/users?page=1&size=3&bsize=2
router.get('/pager/users', function(req, res, next) {
  let page = 1;
  let size = 10;
  let bsize = 5;
  
  if (req.query.page) {
    page = +req.query.page;
  }
  if (req.query.size) {
    size = +req.query.size;
  }
  if (req.query.bsize) {
    bsize = +req.query.bsize;
  }
  
  const limit = size;
  const offset = seekOffset(page, size);
	
	// query() 함수를 이용하여 로우 쿼리를 사용할 수 있다.
	// 주목: { type: sequelize.QueryTypes.SELECT} 옵션을 설정하지 않으면 
	// 메타정보를 위한 쿼리가 추가로 수행된다.
	sequelize.query('SELECT COUNT(*) as count FROM users', { type: sequelize.QueryTypes.SELECT})
	.then((result) => {
		console.log(url.parse(req.url));
		// 주목: pathname 값은 router.get() 함수에 설정한 문자열을 가져온다.
		// {
		//   ...
		//   search: '?page=1&size=3&bsize=2',
		//   query: 'page=1&size=3&bsize=2',
		//   pathname: '/pager/users',
		//   path: '/pager/users?page=1&size=3&bsize=2',
  	// 	 href: '/pager/users?page=1&size=3&bsize=2'
		// }
		
		console.log('result: ', result);
		// 주목: 결과가 배열에 담겨있다.
		// result:  [ { count: 11 } ]
		const rows = result[0].count;
		
		const pager = new Pager(page, size, bsize, rows, url.parse(req.url).pathname);
		console.log(pager);
		// {
		//   paths: [
		//     {
		//       active: "active",
		//       link: "/pager/users",
		//       query: {
		//         page: 1,
		//         size: 3,
		//         bsize: 2
		//       },
		//       text: "1"
		//     },
		//     {
		//       active: "",
		//       link: "/pager/users",
		//       query: {
		//         page: 2,
		//         size: 3,
		//         bsize: 2
		//       },
		//       text: "2"
		//     },
		//     {
		//       active: "",
		//       link: "/pager/users",
		//       query: {
		//         page: 3,
		//         size: 3,
		//         bsize: 2
		//       },
		//       text: ">>"
		//     },
		//     {
		//       active: "",
		//       link: "/pager/users",
		//       query: {
		//         page: 4,
		//         size: 3,
		//         bsize: 2
		//       },
		//       text: "Last"
		//     }
		//   ],
		//   currentPage: 1,
		//   elementsPerPage: 3,
		//   pagesPerBlock: 2,
		//   totalElements: 11,
		//   totalPages: 4,
		//   totalBlocks: 2,
		//   currentBlock: 1,
		//   currentBlockEndPage: 2,
		//   currentBlockStartPage: 1,
		//   beforePage: 0,
		//   nextPage: 2
		// }
		
		return pager;
	}).then((pager) => {
		// 주목: Promise 체이닝을 위해서 return 해야 한다.
		return User.findAll({
	    limit,
	    offset,
	  }).then((users) => {
			// 모두 정상이라면 여기서 작업이 완료된다.
	    res.json({users, pager});
	  });
	}).catch((err) => {
    console.error(err);
    next(err);
  });
});

module.exports = router;

var pagerUsersRouter = require('./routes/pager.users');

app.use('/', pagerUsersRouter);

var express = require('express');
var router = express.Router();
const cors = require('cors');

router.use(cors());