activityControllers.js

const { crudControllers } = require('../../utils/crud')
const { Activity } = require('./activityModel')
const { User } = require('../user/userModel')
const { Attendance } = require('../attendance/attendanceModel')
const { Comment } = require('../comment/commentModel')
const { omit, pick } = require('lodash')

const pickedKeys = [
  '_id',
  'title',
  'description',
  'date',
  'type',
  'createdAt',
  'attendance',
  'comment',
]

exports.default = crudControllers(Activity, pickedKeys)

exports.default.createOne = async (req, res) => {
  try {
    // Invalid Date provided
    if (!req.body.date || Date.parse(req.body.date) < new Date().getTime())
      return res.status(403).json({ messages: ['Invalid date'] })

    let activity = await Activity.create({ ...req.body })

    // Create Initial participants
    if (
      !(
        req.body.initialParticipants != null &&
        req.body.initialParticipants == false
      )
    ) {
      let acceptedUsers = await User.find({ role: 'accepted' }).lean().exec()
      acceptedUsers = acceptedUsers.map(function getUserSchaccs(user) {
        return { schacc: user.schacc }
      })

      let attendances = activity.attendance
      for await (let user of acceptedUsers) {
        const newAttendance = await Attendance.create({
          activity: activity._id,
          user: user.schacc,
        })
        attendances.push(newAttendance._id)
      }

      await Activity.findOneAndUpdate(
        { _id: activity._id },
        { attendance: attendances },
        { new: true }
      )
        .lean()
        .exec()
    }

    await activity
      .populate({
        path: 'comment',
        select: '_id creator text createdAt',
      })
      .populate({
        path: 'attendance',
        select: '_id user state',
      })
      .execPopulate()

    // conver to JS Object to overwrite .creator
    let objActivity = activity.toObject()
    objActivity.creator = objActivity._creator

    res
      .status(200)
      .json({
        data: pick(objActivity, pickedKeys),
      })
      .end()
  } catch (err) {
    if (err.name == 'ValidationError') {
      // Throwed by Mongoose
      let messages = []
      for (field in err.errors) {
        messages.push(err.errors[field].message)
      }
      return res.status(422).json({ messages })
    }
    console.error(err)
    return res.status(500).json({ message: err.message })
  }
}

exports.default.getOne = async (req, res) => {
  try {
    const activity = await Activity.findOne({ _id: req.params.id })
      .populate({
        path: 'comment',
        select: '_id creator text createdAt',
      })
      .populate({
        path: 'attendance',
        select: '_id user state',
      })
      .select('-__v')
      .lean()
      .exec()

    if (!activity)
      return res.status(404).json({ messages: ['No such activity.'] })

    return res.status(200).json({ data: pick(activity, pickedKeys) })
  } catch (err) {
    console.error(err)
    return res.status(500).json({ message: err.message })
  }
}

exports.default.getMany = async (req, res) => {
  try {
    const activity = await Activity.find()
      .populate({
        path: 'comment',
        select: '_id creator text createdAt',
      })
      .populate({
        path: 'attendance',
        select: '_id user state',
      })
      .select('-__v')
      .lean()
      .exec()

    if (!activity)
      return res.status(404).json({ message: 'Activity not found!' })

    res.status(200).json({
      data: activity.map(function pickKeys(doc) {
        return pick(doc, pickedKeys)
      }),
    })
  } catch (err) {
    console.error(err)
    res.status(500).json({ message: err.message })
  }
}

exports.default.removeOne = async (req, res) => {
  try {
    const activity = await Activity.findByIdAndDelete({
      _id: req.params.id,
    })
      .populate({
        path: 'comment',
        select: '_id creator text createdAt',
      })
      .select('-__v')
      .lean()
      .exec()

    if (!activity) {
      return res.status(404).json({ message: 'Activity not found!' }).end()
    }

    await Attendance.deleteMany({
      _id: activity.attendance.map(function getAttendanceIds(element) {
        return element._id
      }),
    })

    await Comment.deleteMany({
      _id: activity.comment.map(function getCommentIds(element) {
        return element._id
      }),
    })

    return res
      .status(200)
      .json({ data: pick(activity, pickedKeys) })
      .end()
  } catch (err) {
    console.error(err)
    return res.status(500).json({ message: err.message }).end()
  }
}

//TODO req.user.role === 'mentor'
exports.default.updateOne = async (req, res) => {
  //validate
  try {
    const activity = await Activity.findOneAndUpdate(
      { _id: req.params.id },
      req.body,
      { new: true }
    )
      .populate({
        path: 'comment',
        populate: { path: 'creator', select: '-_id fullName nickName' },
      })
      .select('-_id -__v')
      .lean()
      .exec()
    if (!activity) {
      res.status(404).json({ message: 'Activity not found!' }).end()
    }

    res.status(200).json({ data: activity }).end
  } catch (err) {
    res.status(500).json({ message: err.message }).end()
  }
}