Add Sessions list resource

Author: rickyhurtado

src/controllers/Sessions.js

@@ -1,6 +1,28 @@
 import * as Sessions from '../lib/Sessions'
 
 export default {
+  list(req, res) {
+    Promise
+      .all([
+        Sessions.list({
+          res,
+          query: req.query,
+          returnData: true,
+          jsonData: true
+        }),
+        Sessions.pages({ query: req.query })
+      ])
+      .then(promises => {
+        res.status(200).send({
+          rows: promises[0],
+          pages: promises[1]
+        })
+      })
+      .catch(error => {
+        res.status(400).send(error)
+      })
+  },
+
   authenticate(req, res) {
     Sessions
       .auth(req, res)

src/helpers/ActiveRecord.js

@@ -1,42 +1,52 @@
 import _ from 'lodash'
 import Sequelize from 'sequelize'
 
+const Op = Sequelize.Op
 const DEFAULT_LIMIT = 20
 
 export function filters(filtered, options={}) {
   if (!filtered) return {}
 
   const filterArray = []
 
-  decodeURIComponent(filtered).split(',').map(filter => {
+  _.map(decodeURIComponent(filtered).split(','), filter => {
     const optionKeys = Object.keys(options)
     const array      = filter.split(':')
     const column     = array[0]
     const value      = array[1]
 
     if (_.indexOf(optionKeys, 'regexp') > -1 && _.indexOf(options.regexp, column) > -1)
-      decodeURIComponent(value).split(' ').map(decodedValue => {
+      _.map(decodeURIComponent(value).split(' '), decodedValue => {
         filterArray.push(whereSQLFn(column, decodedValue, 'regexp'))
       })
     else
       filterArray.push(filterType(column, decodeURIComponent(value), options))
   })
 
-  return { $and: filterArray }
+  return { [Op.and]: filterArray }
 }
 
-export function orderBy(sorted, defaultOrder=[]) {
+export function orderBy(sorted, defaultOrder=[], options) {
   if (!sorted) return [defaultOrder]
 
-  return sorted.split(',').map(sort => {
-    return sort.split(':')
-  })
+  return parseEncodedQuery(sorted, options)
 }
 
 export function pageCount({ limit }, count) {
   return Math.ceil(count / (limit ? limit : DEFAULT_LIMIT))
 }
 
+export function parseEncodedQuery(query, options) {
+  return _.map(query.split(','), q => {
+    let kv = q.split(':')
+
+    if (options && options.replace && options.replace[kv[0]])
+      return [options.replace[kv[0]], kv[1]]
+
+    return kv
+  })
+}
+
 function filterType(key, value, options) {
   const optionKeys = Object.keys(options)
 
@@ -46,13 +56,13 @@ function filterType(key, value, options) {
     const col = options[key].col
 
     if (type === 'integer')
-      filterObject[key] = parseInt(value)
+      filterObject[key] = isNaN(parseInt(value)) ? 0 : parseInt(value)
 
     if (type === 'minDate')
-      filterObject[col] = { $gte: new Date(value) }
+      filterObject[col] = { [Op.gte]: new Date(value) }
 
     if (type === 'maxDate')
-      filterObject[col] = { $lte: new Date(value) }
+      filterObject[col] = { [Op.lte]: new Date(value) }
 
     return filterObject
   }
@@ -63,8 +73,10 @@ function filterType(key, value, options) {
 function whereSQLFn(key, value, type='equal') {
   let op = {}
 
-  if (type === 'equal') op = { $eq: value.toLowerCase() }
-  if (type === 'regexp') op = { $regexp: ['\\y', value, '\\y'].join('') }
+  value = value.toLowerCase()
+
+  if (type === 'equal') op = { [Op.eq]: value }
+  if (type === 'regexp') op = { [Op.regexp]: ['\\y', value, '\\y'].join('') }
 
   return Sequelize.where(
     Sequelize.fn(

src/lib/Sessions.js

@@ -1,9 +1,19 @@
+import _ from 'lodash'
+import Sequelize from 'sequelize'
 import JWT from 'jsonwebtoken'
 import Passport from 'passport'
 import HttpBearerStrategy from 'passport-http-bearer'
+import { filters, pageCount, orderBy, parseEncodedQuery } from '../helpers/ActiveRecord'
 import DB from '../models'
 import * as Users from './Users'
 
+const Op = Sequelize.Op
+const FILTER_OPTIONS = {
+  dateFrom: { col: 'createdAt', type: 'minDate' },
+  dateTo:   { col: 'createdAt', type: 'maxDate' },
+  regexp:   ['userAgent']
+}
+
 Passport.use(new HttpBearerStrategy(
   function(token, done) {
     const { userId } = verifyToken(null, { token, returnData: true })
@@ -22,6 +32,58 @@ Passport.use(new HttpBearerStrategy(
   }
 ))
 
+export function list(options) {
+  const { res, query, returnData, jsonData } = options
+  const { filtered, sorted, limit, page } = query
+  const orderOptions = {
+    sorted: true,
+    replace: {
+      user: Sequelize.literal('\"User\".\"firstName\"'),
+      updatedAt: Sequelize.literal([
+        '\"Session\".\"signedOut\" DESC',
+        '\"Session\".\"updatedAt\"'
+      ].join(',')),
+    }
+  }
+
+  return DB.Session
+    .findAll({
+      where: filters(setQuery(filtered), FILTER_OPTIONS),
+      include: [setIncludeUser(filtered)],
+      offset: (page - 1) * limit,
+      order: orderBy(
+        setQuery(sorted, true),
+        ['sessionId', 'desc'],
+        orderOptions
+      ),
+      limit
+    })
+    .then(Sessions => {
+      const data = jsonData ? jsonSessions(Sessions) : Sessions
+
+      if (returnData) return data
+
+      return res.status(data ? 200 : 404).send(data)
+    })
+    .catch(error => {
+      console.log(error)
+
+      return returnData ? error : res.status(400).send(error)
+    })
+}
+
+export function pages({ query }) {
+  return DB.Session
+    .count({
+      col: 'sessionId',
+      where: filters(setQuery(query.filtered), FILTER_OPTIONS),
+      include: [setIncludeUser(query.filtered)]
+    })
+    .then(count => {
+      return pageCount(query, count)
+    })
+}
+
 export function find(res, options) {
   const { where, returnData } = options
 
@@ -31,7 +93,7 @@ export function find(res, options) {
       include: [{
         model: DB.User,
         as: 'User',
-        attributes: ['userId', 'firstName', 'lastName', 'email', 'role', 'status', 'redirect']
+        attributes: ['userId']
       }]
     })
     .then(Session => {
@@ -122,3 +184,70 @@ function getIpAddress(req) {
     req.connection.socket.remoteAddress
   ).split(',')[0]
 }
+
+function jsonSessions(Sessions) {
+  return _.map(Sessions, Session => {
+      return {
+        sessionId: Session.sessionId,
+        user: {
+          userId: Session.User.userId,
+          name: Session.User.fullName()
+        },
+        userAgent: Session.userAgent,
+        ipAddress: Session.ipAddress,
+        createdAt: Session.createdAt,
+        signedOutAt: Session.signedOutAt()
+      }
+    })
+}
+
+function setQuery(query, sorted=false) {
+  const parsed = query ? parseEncodedQuery(query) : []
+  const newQuery = _.compact(
+    _.map(parsed, p => {
+      if (p[0] === 'signedOutAt') return ['updatedAt', p[1]].join(':')
+      if (p[0] !== 'user' || (p[0] === 'user' && sorted)) return p.join(':')
+    })
+  ).join(',')
+
+  return newQuery
+}
+
+function setIncludeUser(filtered) {
+  const parsed = filtered ? parseEncodedQuery(filtered) : []
+
+  let includeUser = {
+    model: DB.User,
+    as: 'User',
+    attributes: ['userId', 'firstName', 'lastName']
+  }
+
+  _.map(parsed, p => {
+    if (p[0] === 'user')
+      return includeUser['where'] = whereUser(p[1])
+  })
+
+  return includeUser
+}
+
+function whereUser(values) {
+  const decodedValues  = decodeURIComponent(decodeURIComponent(values))
+  const userSQLFnArray = _.map(decodedValues.split(' '), value => {
+    return { [Op.or]: [
+      userSQLFn('firstName', value),
+      userSQLFn('lastName', value)
+    ]}
+  })
+
+  return { [Op.and]: userSQLFnArray }
+}
+
+function userSQLFn(column, value) {
+  return Sequelize.where(
+    Sequelize.fn(
+      'lower',
+      Sequelize.col(column)
+    ),
+    { [Op.regexp]: ['\\y', value.toLowerCase(), '\\y'].join('') }
+  )
+}

src/models/Session.js

@@ -14,6 +14,10 @@ export default (sequelize, DataTypes) => {
     signedOut: DataTypes.BOOLEAN
   })
 
+  Session.prototype.signedOutAt = function() {
+    return this.signedOut ? this.updatedAt : null
+  }
+
   Session.associate = (models) => {
     Session.belongsTo(models.User, {
       as: 'User',

src/routes/index.js

@@ -10,6 +10,7 @@ export default (app) => {
   app.post('/sign-in', C.Sessions.authenticate)
   app.post('/sign-out', authBearer(), C.Sessions.signOut)
   app.get('/verify-token', authBearer(), C.Sessions.verifyToken)
+  app.get('/sessions', authBearer(), C.Sessions.list)
 
   /* Users */
   app.get('/users', authBearer(), C.Users.list)