ptb-be/controller/v1/auto.controller.js

const handleError = require('../../utils/v1/handleError')
const response = require('../../utils/responseHandler')
const { notifWA } = require('../../utils/v1/notifFunction')
const sanksiModel = require('../../model/sanksi.model')
const laporanModel = require('../../model/laporan.model')
const {
  TEMPLATE_REMINDER,
  TEMPLATE_REMINDER2, TRUE, UPDATE_SANKSI, CREATE_SANKSI, PTB_ADMIN, PTB_DIKTI, PTB_LLDIKTI
} = require('../../utils/constanta')
const moment = require('moment')
const autoSaveModel = require('../../model/autoSave.model')
const { cekSatuDataSanksi, cekSatuDataLaporan } = require('../../utils/v1/cekData')
const logModel = require('../../model/log.model')
const kontakModel = require('../../model/kontak.model')
const pemantauanModel = require('../../model/pemantauan.model')
const batchModel = require('../../model/batch.model')
const pddiktiService = require('../../services/v2/pddikti.service')

exports.keberatan = handleError(async (req, res) => {
  const dataSanksi = await sanksiModel
    .find({
      'tanggal_akhir_keberatan': {
        $lte: moment().toISOString()
      },
      'is_pengajuan_keberatan': {
        $exists: false,
        $eq: null
      }
    })
    .populate('user')
    .populate('laporan')

  if (!dataSanksi.length) {
    return response.success(res, {
      message: 'Tidak ada keberatan yang diubah'
    })
  }

  await Promise.all(
    dataSanksi.map(
      async (sanksi) =>
        await sanksiModel.findByIdAndUpdate(sanksi._id, {
          is_pengajuan_keberatan: false,
          last_step: 'Dokumen Perbaikan'
        })
    )
  )
  await logModel.create({
    aktivitas: `Server berhasil merubah last_step PT ${dataSanksi.map((e) => e.laporan.pt.nama).join(', ')} menjadi Dokumen Perbaikan`
  })
  return response.success(res, {
    message: 'Notifikasi berhasil terkirim'
  })
})

exports.banding = handleError(async (req, res) => {
  const dataSanksi = await sanksiModel
    .find({
      'tanggal_akhir_banding': {
        $lt: moment().toISOString()
      },
      'is_pengajuan_banding': {
        $exists: false,
        $eq: null
      },
      'jawaban.keberatan': {
        $exists: true,
        $ne: null
      }
    })
    .populate('user')
    .populate('laporan')

  if (!dataSanksi.length) {
    return response.success(res, {
      message: 'Tidak ada banding yang diubah'
    })
  }

  await Promise.all(
    dataSanksi.map(
      async (sanksi) => {
        await sanksiModel.findByIdAndUpdate(sanksi._id, {
          is_pengajuan_banding: false,
          last_step: 'Dokumen Perbaikan'
        })
      }
    )
  )
  await logModel.create({
    aktivitas: `Server berhasil merubah last_step PT ${dataSanksi.map((e) => e.laporan.pt.nama).join(', ')} menjadi Dokumen Perbaikan`
  })
  return response.success(res, {
    message: 'Notifikasi berhasil terkirim'
  })
})

exports.reminderKeberatan = handleError(async (req, res) => {
  let dataSanksi = await sanksiModel
    .find({
      'tanggal_akhir_keberatan': {
        $exists: true,
        $ne: null
      },
      'jawaban.keberatan': {
        $exists: false,
        $eq: null
      }
    })
    .populate('user')
    .populate('laporan')
  const notif = await Promise.all(
    dataSanksi.map(async (e) => {
      const dayLeft = moment(e.batas_waktu.jawaban_keberatan).diff(
        new Date(),
        'days'
      )
      if (dayLeft > 0 && dayLeft <= 7) {
        try {
          await notifWA(TEMPLATE_REMINDER, [
            {
              key: '1',
              value: 'no_laporan',
              value_text: e.laporan.no_laporan
            },
            {
              key: '2',
              value: 'keterangan',
              value_text: 'Proses Menjawab Pengajuan Keberatan'
            },
            {
              key: '3',
              value: 'pt',
              value_text: e.laporan.pt.nama
            },
            {
              key: '4',
              value: 'masa',
              value_text: `menjawab pengajuan keberatan tersisa ${dayLeft} hari lagi.`
            }
          ])
          const contacts = await kontakModel.find({
            'role.id': {
              $in: [PTB_ADMIN, PTB_DIKTI, PTB_LLDIKTI]
            }
          })
          await logModel.create({
            aktivitas: `Server berhasil mengirim notifikasi Whatsapp kepada ${contacts.map((e) => e.nama).join(', ')} dengan Nomor Laporan ${e.laporan.no_laporan} terhadap ${e.laporan.pt.nama} untuk Mengajukan Keberatan`
          })
        } catch (error) {
          return response.error(res, {
            message: 'Notifikasi gagal terkirim',
            error: error.message
          })
        }
      }
    })
  )

  let message = 'Tidak ada notifikasi yang dikirim'
  if (notif.length) message = 'Notifikasi berhasil terkirim'
  return response.success(res, {
    message
  })
})

exports.reminderBanding = handleError(async (req, res) => {
  let dataSanksi = await sanksiModel
    .find({
      'tanggal_akhir_banding': {
        $exists: true,
        $ne: null
      },
      'jawaban.banding': {
        $exists: false,
        $eq: null
      }
    })
    .populate('user')
    .populate('laporan')
  const notif = await Promise.all(
    dataSanksi.map(async (e) => {
      const dayLeft = moment(e.batas_waktu.jawaban_banding).diff(
        new Date(),
        'days'
      )
      if (dayLeft > 0 && dayLeft <= 7) {
        try {
          await notifWA(TEMPLATE_REMINDER, [
            {
              key: '1',
              value: 'no_laporan',
              value_text: e.laporan.no_laporan
            },
            {
              key: '2',
              value: 'keterangan',
              value_text: 'Proses Menjawab Pengajuan Banding'
            },
            {
              key: '3',
              value: 'pt',
              value_text: e.laporan.pt.nama
            },
            {
              key: '4',
              value: 'masa',
              value_text: `menjawab pengajuan banding tersisa ${dayLeft} hari lagi.`
            }
          ])
          const contacts = await kontakModel.find({
            'role.id': {
              $in: [PTB_ADMIN, PTB_DIKTI, PTB_LLDIKTI]
            }
          })
          await logModel.create({
            aktivitas: `Server berhasil mengirim notifikasi Whatsapp kepada ${contacts.map((e) => e.nama).join(', ')} dengan Nomor Laporan ${e.laporan.no_laporan} terhadap ${e.laporan.pt.nama} untuk Mengajukan Banding`
          })
        } catch (error) {
          return response.error(res, {
            message: 'Notifikasi gagal terkirim',
            error: error.message
          })
        }
      }
    })
  )

  let message = 'Tidak ada notifikasi yang dikirim'
  if (notif.length) message = 'Notifikasi berhasil terkirim'
  return response.success(res, {
    message
  })
})

exports.updateStatusSanksi = handleError(async (req, res) => {
  const sanksi = await sanksiModel.find({
    'masa_berlaku.to_date': {
      $lte: new Date().toISOString()
    },
    aktif: true,
    'masa_berlaku.berakhir': {
      $exists: false,
      $eq: null
    }
  }).populate('laporan')

  await Promise.all(
    sanksi.map(async (e) => {
      await pemantauanModel.create({
        laporan: e.laporan._id,
        sanksi: e._id,
        action: UPDATE_SANKSI,
        pt_id: e.laporan.pt.id,
        keterangan: 'Masa berlaku sanksi sudah melewati TMT',
        levelSanksi: 0
      })
      await sanksiModel.findByIdAndUpdate(e._id, { 'masa_berlaku.berakhir': true })
      await batchModel.create({
        sanksi: e._id,
        type: UPDATE_SANKSI
      })
    })
  )

  return response.success(res, {
    message: 'update status sanksi berhasil'
  })
})

exports.save = handleError(async (req, res) => {
  const { id } = req.params
  const { laporan: isLaporan, sanksi: isSanksi } = req.query
  const user = req.user

  let autoData = null
  let laporan = null
  let sanksi = null
  if (isLaporan === TRUE) {
    laporan = await cekSatuDataLaporan(res, user, id)
    if (!laporan) return
    autoData = await autoSaveModel.findOne({ laporan_id: laporan._id })
  } else if (isSanksi === TRUE) {
    sanksi = await cekSatuDataSanksi(res, user, id)
    if (!sanksi) return
    autoData = await autoSaveModel.findOne({ sanksi_id: sanksi._id })
  } else {
    return response.error(res, {
      message: 'query harus sanksi atau laporan yg bernilai true'
    })
  }

  if (autoData) {
    if (isLaporan) {
      const dataSave = await autoSaveModel.findOne({ laporan_id: laporan._id })
      await autoSaveModel.updateOne({ laporan_id: laporan._id }, {
        laporan: {
          ...req.body, PenetapanSanksi: {
            dataSuratBA: req.body?.PenetapanSanksi?.dataSuratBA || dataSave.laporan.PenetapanSanksi?.dataSuratBA,
            dataUpload: req.body?.PenetapanSanksi?.dataUpload || dataSave.laporan.PenetapanSanksi?.dataUpload,
            dataPelanggaran: req.body?.PenetapanSanksi?.dataPelanggaran || dataSave.laporan.PenetapanSanksi?.dataPelanggaran,
            activeStep: req.body?.PenetapanSanksi?.activeStep || dataSave.laporan.PenetapanSanksi?.activeStep
          }
        }
      })
    } else {
      await autoSaveModel.updateOne({ sanksi_id: sanksi._id }, { sanksi: req.body })
    }
  } else {
    if (isLaporan) {
      await autoSaveModel.create({ laporan_id: laporan._id, laporan: req.body })
    } else {
      await autoSaveModel.create({ sanksi_id: sanksi._id, sanksi: req.body })
    }
  }

  return response.success(res, {
    message: 'Berhasil menyimpan data auto save'
  })
})

exports.getSave = handleError(async (req, res) => {
  const { id } = req.params
  const { laporan: isLaporan, sanksi: isSanksi } = req.query

  let data = null
  let laporan = null
  let sanksi = null
  if (isLaporan === TRUE) {
    laporan = await laporanModel.findById(id)
    if (!laporan) return response.error(res, {
      code: 404,
      message: 'laporan_id tidak ada'
    })
    data = (await autoSaveModel.findOne({ laporan_id: laporan._id })).laporan
  } else if (isSanksi === 'true') {
    sanksi = await sanksiModel.findById(id)
    if (!sanksi) return response.error(res, {
      code: 404,
      message: 'sanksi_id tidak ada'
    })
    data = (await autoSaveModel.findOne({ sanksi_id: sanksi._id })).sanksi
  } else {
    return response.error(res, {
      message: 'harus terdapat query sanksi atau laporan yg bernilai true'
    })
  }

  return response.success(res, {
    message: 'Berhasil mengambil data auto save',
    data: data
  })
})

exports.berakhirSanksi = handleError(async (req, res) => {
  const sanksi = await sanksiModel.find({
    'masa_berlaku.to_date': {
      $ne: null,
      $exists: true
    }
  }).populate('laporan')
  let count = 0

  await Promise.all(sanksi.map(async e => {
    const dayLeft = moment(e.masa_berlaku.to_date).diff(
      new Date(),
      'days'
    )
    if (dayLeft > 0 && dayLeft <= 7) {
      try {
        await notifWA(TEMPLATE_REMINDER2, [
          {
            key: '1',
            value: 'no_sanksi',
            value_text: `nomor sanksi ${e.no_sanksi}`
          },
          {
            key: '2',
            value: 'nama_pt',
            value_text: `${e.laporan.pt.nama}`
          },
          {
            key: '3',
            value: 'keterangan',
            value_text: `habis masa berlaku sanksi tersisa ${dayLeft} hari lagi.`
          }
        ])
        count++
        const contacts = await kontakModel.find({
          'role.id': {
            $in: [PTB_ADMIN, PTB_DIKTI, PTB_LLDIKTI]
          }
        })
        await logModel.create({
          aktivitas: `Server berhasil mengirim notifikasi reminder Whatsapp kepada ${contacts.map((e) => e.nama).join(', ')} dengan Nomor Sanksi ${e.no_sanksi} terhadap ${e.laporan.pt.nama} bahwa Masa Berlaku Sanksi tersisa ${dayLeft} hari lagi.`
        })
      } catch (error) {
        return response.error(res, {
          message: 'Notifikasi gagal terkirim',
          error: error.message
        })
      }
    }
  }))
  let message = 'Notifikasi berhasil terkirim'
  if (count === 0) message = 'tidak ada notifikasi yg dikirim'
  return response.success(res, {
    message
  })
})

exports.batchUpdateSanksi = handleError(async (req, res) => {
  const data = await batchModel.find({
    type: UPDATE_SANKSI
  })
    .populate({
      path: 'sanksi',
      populate: ['laporan']
    })
  let error = []
  await Promise.all(data.map(async e => {
    const { sanksi } = e
    if (!sanksi?.laporan) return
    try {
      await pddiktiService.updatePDDIKTI({
        ptKode: sanksi.laporan.pt.kode,
        noSanksi: sanksi.laporan.no_laporan,
        fromDate: moment(sanksi.masa_berlaku.from_date).format('YYYY-MM-DD'),
        levelSanksi: sanksi.levelSanksi,
        terimaSanksi: moment(sanksi.tanggal_terima_sanksi).format('YYYY-MM-DD')
      })
      await logModel.create({
        aktivitas: `Server berhasil mengirimkan data Ke API PDDIKTI untuk update Status PT ${sanksi.laporan.pt.nama}`
      })
      await batchModel.deleteOne(e._id)
    } catch (e) {
      error.push(e.message)
      await Promise.all([
        logModel.create({
          aktivitas: `Server gagal mengirimkan data Ke API PDDIKTI untuk update Status PT ${sanksi.laporan.pt.nama}, dengan error ${e.message}`
        }),
        pemantauanModel.deleteOne({
          laporan: sanksi.laporan._id,
          sanksi: sanksi._id,
          action: CREATE_SANKSI
        })
      ])
    }
  }))
  return response.success(res, {
    message: error.length ? 'Ada beberapa data yang tidak bisa dikirim ke PDDIKTI' : 'Berhasil mengirim data ke PDDIKTI',
    data: { error },
  })
})