@questwork/vue-q-list-vue3 3.1.0

package/lib/models/qListButton/qListButton.js

@@ -0,0 +1,241 @@
+const { KeyValueObject } = require('../keyValueObject')
+class QListButton {
+  constructor(options = {}) {
+    options = options || {}
+    this.active = (typeof options.active !== 'undefined') ? !!options.active : true
+    this.creator = options.creator
+    this.css = options.css || {}
+    this.deleted = options.deleted || false
+    this.endpoint = options.endpoint
+    this.httpMethod = options.httpMethod
+    this.icon = options.icon
+    this.label = options.label
+    this.linkTarget = options.linkTarget
+    this.onClick = options.onClick
+    this.owner = options.owner
+    this.preventDefault = options.preventDefault
+    this.qListButtonType = options.qListButtonType
+    this.qRow = options.qRow
+    this.restrictions = options.restrictions
+    this.showLabel = options.showLabel
+    this.title = options.title
+    this.url = options.url
+  }
+
+  static init(options) {
+    if (options instanceof QListButton) {
+      return options
+    }
+    const instance = new QListButton(options)
+    return instance.isValid ? instance : null
+  }
+
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map(this.init)
+    }
+    return []
+  }
+
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+
+  get isValid() {
+    if (this.qListButtonType) {
+      // version 1: actionBuilder
+      if (this.qListButtonType === 'actionBuilder') {
+        return true
+      } else {
+        return this.validation(this.restrictions) && this.qRow[this.qListButtonType] !== false
+      }
+      // if (this.qListButtonType === 'actionBuilder') {
+      //   return true
+      // // version 2: use this.qRow[this.qListButtonType] to control
+      // } else if (this.qRow[this.qListButtonType] === undefined) {
+      //   if (this.restrictions) {
+      //     return this.validation(this.restrictions)
+      //   }
+      //   return true
+      // } else {
+      //   if (this.restrictions) {
+      //     return this.qRow[this.qListButtonType] && this.validation(this.restrictions)
+      //   }
+      //   return this.qRow[this.qListButtonType]
+      // }
+    } else {
+      return this.validation(this.restrictions)
+    }
+  }
+
+  click(...obj) {
+    if (this.onClick && typeof this.onClick === 'function') {
+      return this.onClick(...obj)
+    }
+  }
+
+  makeCss() {
+    return `__q-list-button ${this.css.element || ''}`
+  }
+
+  validation(restrictions) {
+    if (!restrictions) {
+      return true
+    }
+    const [visibleRule] = KeyValueObject.getValuesByKey(restrictions, 'visible')
+
+    return getValidation({
+      rule: visibleRule,
+      qRow: this.qRow,
+    })
+  }
+}
+
+// function getValidation({ rule, qRow }) {
+//   const { key = '', value } = rule
+//   const [valueAttribute] = Object.keys(value)
+
+//   if (!key) {
+//     switch(valueAttribute) {
+//       case '$and': {
+//         const arr = value['$and']
+//         return arr.reduce((acc, item) => {
+//           return acc && getValidation({ rule: item, qRow})
+//         }, true)
+//       }
+//       case '$or': {
+//         const arr = value['$or']
+//         return arr.reduce((acc, item) => {
+//           return acc || getValidation({ rule: item, qRow})
+//         }, false)
+//       }
+//     }
+//     return false
+//   } 
+
+//   const rowValue = qRow.get(key)
+//   switch (valueAttribute) {
+//     case '$empty': {
+//       return !rowValue === value['$empty']
+//     }
+//     case '$lte': {
+//       return rowValue <= value['$lte']
+//     }
+//   }
+//   return false
+// }
+
+function _getValidation(rule, data, getDataByKey) {
+  if (!rule) {
+    return true
+  }
+  if (!getDataByKey || typeof getDataByKey !== 'function') {
+    return false
+  }
+  const { key = '', value } = rule
+  const [valueAttribute] = Object.keys(value)
+
+  if (!key) {
+    switch (valueAttribute) {
+      case '$and': {
+        const arr = value['$and']
+        return arr.reduce((acc, item) => (acc && _getValidation(item, data, getDataByKey)), true)
+      }
+      case '$or': {
+        const arr = value['$or']
+        return arr.reduce((acc, item) => (acc || _getValidation(item, data, getDataByKey)), false)
+      }
+      default:
+        return false
+    }
+  }
+
+  const rowValue = getDataByKey(key, data)
+  switch (valueAttribute) {
+    case '$empty': {
+      return !rowValue === !!value['$empty']
+    }
+    case '$eq': {
+      return rowValue === value['$eq']
+    }
+    case '$gt': {
+      return rowValue > value['$gt']
+    }
+    case '$gte': {
+      return rowValue >= value['$gte']
+    }
+    case '$lt': {
+      return rowValue < value['$lt']
+    }
+    case '$lte': {
+      return rowValue <= value['$lte']
+    }
+    case '$in': {
+      debugger
+      console.log('rowValuda', rowValue)
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (value['$in'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !!value['$in'].includes(rowValue)
+      }
+      return false
+    }
+    case '$inValue': {
+      const result = getDataByKey(value['$inValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue === 'string') {
+        return !!_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$ne': {
+      return rowValue !== value['$ne']
+    }
+    case '$notIn': {
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (value['$notIn'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !value['$notIn'].includes(rowValue)
+      }
+      return false
+    }
+    case '$notInValue': {
+      const result = getDataByKey(value['$notInValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$range': {
+      const [min, max] = value['$range']
+      if (typeof min === 'number' && typeof max === 'number' && rowValue >= min && rowValue <= max) {
+        return true
+      }
+      return false
+    }
+    default:
+      return false
+  }
+}
+
+function getDataByKey(key, data) {
+  return data.get(key)
+}
+
+function getValidation({ rule, qRow }) {
+  return _getValidation(rule, qRow, getDataByKey)
+}
+
+module.exports = {
+  QListButton
+}
+

package/lib/models/qRow/index.js

@@ -0,0 +1,5 @@
+const { QRow } = require('./qRow')
+
+module.exports = {
+  QRow
+}

package/lib/models/qRow/qRow.js

@@ -0,0 +1,212 @@
+const { dateHelper } = require('@questwork/utilities/lib/dateHelper')
+
+class QRow {
+  constructor(options = {}) {
+    options = options || {}
+    this.active = (typeof options.active !== 'undefined') ? !!options.active : true
+    this.creator = options.creator
+    this.cssMaker = options.cssMaker
+    this.cssNames = options.cssNames || []
+    this.deleted = options.deleted || false
+    this.duration = options.duration
+    this.getActions = options.getActions 
+    this.new = options.new || false
+    this.owner = options.owner
+    this.row = options.row
+    this.shouldBeDisabled = setshouldBeDisabled(options.shouldBeDisabled || null)
+    this.shouldBeVisible = setShouldBeVisible(options.shouldBeVisible || null)
+    this.uniqueKey = options.uniqueKey
+    this.unread = options.unread || false
+  }
+
+  // Class methods
+  static dummyData() {
+    return {
+      active: true,
+      creator: '1234',
+      deleted: false,
+      new: true,
+      owner: '9876',
+      row: {
+        firstName: 'Peter',
+        sex: 'M'
+      },
+      unread: true,
+    }
+  }
+  static init(options = {}) {
+    if (options instanceof QRow) {
+      return options
+    }
+    const instance = new QRow(options)
+    return instance.isValid ? instance : null
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map(this.init)
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+
+  // getters
+  get css() {
+    return this.cssNames.join(' ')
+  }
+
+  get isValid() {
+    return !!this.row
+  }
+  get read() {
+    return !this.unread
+  }
+
+  // instance methods
+  addCss(className) {
+    if (!this.cssNames.includes(className)) {
+      this.cssNames.push(className)
+    }
+    return this
+  }
+
+  get(key) {
+    if (key) {
+      if (key.includes('qRow')) {
+        const arr = key.split('.')
+        arr.shift()
+        return getRecursiveValue(this, arr)
+        // const realKey = arr[1]
+        // return this[realKey]
+      }
+      if (key.includes('.')) {
+        const arr = key.split('.')
+        return getRecursiveValue(this.row, arr)
+      }
+      return this.row[key]
+    }
+    return this.row
+  }
+
+  getUniqueKey() {
+    if (this.uniqueKey) {
+      return this.get(this.uniqueKey)
+    }
+    return null
+  }
+
+  isBetween(myTimestamp, dateRange) {
+    let result = true
+    if (dateRange) {
+      const timestamp = new Date().getTime()
+      if (dateRange.start) {
+        const { start } = dateRange
+        result = result && (timestamp >= dateHelper(myTimestamp).add(start).valueOf())
+      }
+      if (dateRange.end) {
+        const { end } = dateRange
+        result = result && (timestamp <= dateHelper(myTimestamp).add(end).valueOf())
+      }
+    }
+    return result
+  }
+  
+  isSameCreator(user) {
+    return user
+      ? (user === this.creator)
+      : false
+  }
+  isSameOwner(user) {
+    return user
+      ? (user === this.owner)
+      : false
+  }
+
+  getStatus() {
+    const statusList = []
+    if (this.active) {
+      statusList.push('active')
+    }
+    if (this.deleted) {
+      statusList.push('deleted')
+    }
+    if (this.new) {
+      statusList.push('new')
+    }
+    if (this.unread) {
+      statusList.push('unread')
+    }
+    return statusList
+  }
+
+  makeCss() {
+    const cssArr = this.cssMaker && typeof this.cssMaker === 'function' ? [this.cssMaker(this)] : []
+    return cssArr
+  }
+
+  removeCss(className) {
+    this.cssNames = this.cssNames.filter((e) => (e !== className))
+    return this
+  }
+
+  toggleActive() {
+    this.active = !this.active
+    this.new = false
+    this.unread = false
+    return this
+  }
+  toggleDeleted() {
+    this.deleted = !this.deleted
+    this.new = false
+    this.unread = false
+    return this
+  }
+  toggleNew() {
+    this.new = !this.new
+    return this
+  }
+  toggleRead() {
+    this.unread = !this.unread
+    return this
+  }
+}
+
+function getRecursiveValue(obj, arr) {
+  if (arr.length === 0) {
+    return obj
+  }
+  const key = arr.shift()
+  // if (obj && obj[key] !== undefined && obj[key] !== null && (obj[key].toString() || obj[key].toString() === '')) {
+  //   return getRecursiveValue(obj[key], arr)
+  // }
+  if (obj && obj[key]) {
+    return getRecursiveValue(obj[key], arr)
+  }
+  if (obj && key) {
+    return obj[key]
+  }
+  return ''
+}
+
+function setshouldBeDisabled(shouldBeDisabled) {
+  return (component) => {
+    if(!shouldBeDisabled || typeof shouldBeDisabled !== 'function') {
+      return false
+    }
+    return !!shouldBeDisabled(component)
+  }
+}
+
+function setShouldBeVisible(shouldBeVisible) {
+  return (component) => {
+    if(!shouldBeVisible || typeof shouldBeVisible !== 'function') {
+      return true
+    }
+    return !!shouldBeVisible(component)
+  }
+}
+
+module.exports = {
+  QRow
+}

package/lib/models/qRow/qRow.spec.js

@@ -0,0 +1,185 @@
+const { expect } = require('chai')
+const { QRow } = require('./qRow')
+
+describe.only('QRow', function () {
+  let qRow
+  let qRows
+  const user = '9876'
+  const dummy = {
+    ...QRow.dummyData()
+  }
+
+  describe('.init', function () {
+    it('should return null if data is missing', async function () {
+      qRow = QRow.init()
+      expect(qRow).to.eql(null)
+      qRow = QRow.init(null)
+      expect(qRow).to.eql(null)
+      qRow = QRow.init({
+        ...dummy,
+        row: null
+      })
+      expect(qRow).to.eql(null)
+    })
+
+    it('should init a valid instance', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow instanceof QRow).to.eql(true)
+      expect(qRow.isValid).to.eql(true)
+    })
+  })
+
+  describe('.initFromArray', function () {
+    it('should init all object in array as valid object instance', async function () {
+      const qRowsToInit = [dummy, dummy, dummy]
+      qRows = QRow.initFromArray(qRowsToInit)
+      expect(qRows).to.have.lengthOf(qRowsToInit.length)
+      qRows.forEach((el) => {
+        expect(el instanceof QRow).to.eql(true)
+      })
+    })
+
+    it('should skip null in array as valid object instance', async function () {
+      const qRowsToInit = [dummy, null, dummy]
+      qRows = QRow.initOnlyValidFromArray(qRowsToInit)
+      expect(qRows).to.have.lengthOf(2)
+      qRows.forEach((el) => {
+        expect(el instanceof QRow).to.eql(true)
+      })
+    })
+  })
+
+  describe('.get', function () {
+    it('should get the corresponding key from data', async function () {
+      qRow = QRow.init(dummy)
+      const firstName = qRow.get('firstName')
+      expect(firstName).to.eql(dummy.row.firstName)
+    })
+
+    it('getter read to return opposite of unread', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.unread).to.eql(true)
+      expect(qRow.read).to.eql(false)
+    })
+  })
+
+  describe('instance methods', function () {
+    it('replace setUnread() by toggleRead()', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.setUnread).to.eql(undefined)
+      expect(typeof qRow.toggleRead).to.eql('function')
+    })
+
+    it('toggleRead() will toggle unread', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.unread).to.eql(true)
+      expect(qRow.read).to.eql(false)
+      qRow.toggleRead()
+      expect(qRow.read).to.eql(true)
+      qRow.toggleRead()
+      expect(qRow.read).to.eql(false)
+    })
+
+    it('toggleNew() will toggle new', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.new).to.eql(true)
+      qRow.toggleNew()
+      expect(qRow.new).to.eql(false)
+      qRow.toggleNew()
+      expect(qRow.new).to.eql(true)
+    })
+
+    it('isSameCreator(user) will verify the creator id', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.isSameCreator(user)).to.eql(false)
+    })
+
+    it('isSameCreator(user) with valid user', async function () {
+      qRow = QRow.init(dummy)
+      const validUser = '1234'
+      expect(qRow.isSameCreator(validUser)).to.eql(true)
+    })
+
+    it('isSameCreator(user) with invalid creator', async function () {
+      qRow = QRow.init({
+        ...dummy,
+        creator: null
+      })
+      expect(qRow.isSameCreator(user)).to.eql(false)
+    })
+
+    it('isSameOwner(user) will verify the owner id', async function () {
+      qRow = QRow.init(dummy)
+      expect(qRow.isSameOwner(user)).to.eql(true)
+    })
+
+    it('isSameOwner(user) with invalid user', async function () {
+      qRow = QRow.init(dummy)
+      const inValidUser = '1234'
+      expect(qRow.isSameOwner(inValidUser)).to.eql(false)
+    })
+
+    it('isSameOwner(user) with invalid owner', async function () {
+      qRow = QRow.init({
+        ...dummy,
+        owner: null
+      })
+      expect(qRow.isSameOwner(user)).to.eql(false)
+    })
+  })
+
+  describe('.shouldBeDisabled', function() {
+    it('should return boolean', async function () {
+      qRow = QRow.init({
+        ...dummy,
+      })
+      expect(qRow.shouldBeDisabled(dummy)).to.eql(false)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeDisabled: true
+      })
+      expect(qRow.shouldBeDisabled(dummy)).to.eql(false)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeDisabled: (dummy) => {
+          return dummy.unread
+        }
+      })
+      expect(qRow.shouldBeDisabled(dummy)).to.eql(true)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeDisabled: (dummy) => {
+          return dummy.deleted
+        }
+      })
+      expect(qRow.shouldBeDisabled(dummy)).to.eql(false)
+    })
+  })
+  describe('.shouldBeVisible', function() {
+    it('should return boolean', async function () {
+      qRow = QRow.init({
+        ...dummy,
+      })
+      expect(qRow.shouldBeVisible(dummy)).to.eql(true)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeVisible: false
+      })
+      expect(qRow.shouldBeVisible(dummy)).to.eql(true)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeVisible: (dummy) => {
+          return dummy.deleted
+        }
+      })
+      expect(qRow.shouldBeVisible(dummy)).to.eql(false)
+      qRow = QRow.init({
+        ...dummy,
+        shouldBeVisible: (dummy) => {
+          return dummy.unread
+        }
+      })
+      expect(qRow.shouldBeVisible(dummy)).to.eql(true)
+    })
+  })
+})

package/lib/test.setup.js

@@ -0,0 +1,15 @@
+const sinon = require('sinon')
+
+before(function before() {
+})
+
+after(function after() {
+})
+
+beforeEach(function beforeEach() {
+  this.sandbox = sinon.createSandbox()
+})
+
+afterEach(function afterEach() {
+  this.sandbox.restore()
+})