api/middleware/VegetableTypes.js

const models = require('../models')
const vegetableTypes = models.vegetableTypes

class VegetableTypes {
  static getAll (req, callback) {
    vegetableTypes.findAndCountAll({
      order: [
        ['name', 'ASC']
      ],
      include: [{
        model: models.vegetables,
        as: 'Vegetables',
        order: [
          ['name', 'ASC']
        ]
      }]
    })
      .then(items => {
        if (!items) {
          callback(new Error('No vegetable type found'), 204)
          return false
        }

        let res = []

        for (let i = 0; i < items.rows.length; i += 1) {
          let type = items.rows[i].toJSON()
          let vegetables = []

          for (let j = 0; j < type.Vegetables.length; j += 1) {
            let k = 0
            for (k = 0; k < vegetables.length; k += 1) {
              if (type.Vegetables[j].name.localeCompare(vegetables[k].name) === -1) {
                break
              }
            }

            vegetables.splice(k, 0, type.Vegetables[j])
          }
          type.Vegetables = vegetables
          res.push(type)
        }

        callback(null, { count: res.length, rows: res })
      })
      .catch((e) => {
        console.log('ERR:', e)
        callback(e, null)
      })
  }

  createOne (req, callback) {
    vegetableTypes.create(req.body)
      .then(item => {
        callback(null, item)
      })
      .catch(e => {
        callback(e, null)
      })
  }

  static getOne (req, callback) {
    vegetableTypes.findById(
      req.params.vegetableTypesId,
      {
        include: [{
          model: models.vegetables,
          as: 'Vegetables',
          order: [
            ['name', 'ASC']
          ]
        }]
      })
      .then(item => {
        if (!item) {
          callback(new Error('Item vegetable type not found'), 404)
          return false
        }

        let type = item.toJSON()
        let vegetables = []

        for (let j = 0; j < type.Vegetables.length; j += 1) {
          let k = 0
          for (k = 0; k < vegetables.length; k += 1) {
            if (type.Vegetables[j].name.localeCompare(vegetables[k].name) === -1) {
              break
            }
          }

          vegetables.splice(k, 0, type.Vegetables[j])
        }
        type.Vegetables = vegetables

        callback(null, type)
      })
      .catch((e) => {
        callback(e, null)
      })
  }

  patchOne (req, callback) {
    VegetableTypes.getOne(req, (err, item) => {
      if (err) {
        callback(err, item)
        return false
      }

      item.update(req.body)
        .then(animal => {
          callback(null, animal)
        })
        .catch(e => {
          callback(e, null)
        })
    })
  }

  deleteOne (req, callback) {
    VegetableTypes.getOne(req, (err, item) => {
      if (err) {
        callback(err, item)
        return false
      }

      vegetableTypes.destroy({
        where: {
          id: req.params.vegetableTypesId
        }
      })
        .then(deleted => {
          if (deleted === 0) {
            callback(new Error('Error when trying to delete item'))
            return false
          }

          callback(null, null)
        })
        .catch(e => {
          callback(e, null)
        })
    })
  }
}

module.exports = VegetableTypes