ptb-be/controller/auto.controller.js

const handleError = require('../utils/handleError')
const response = require('../utils/responseHandler')
const { notifWA } = require('../utils/notifFunction')
const sanksiModel = require('../model/sanksi.model')
const laporanModel = require('../model/laporan.model')
const chunkModel = require('../model/chunk.model')
const dokumenModel = require('../model/dokumen.model')
const backupModel = require('../model/backup.model')
const pemantauanModel = require('../model/pemantauan.model')
const fs = require('fs')
const {
  TEMPLATE_KEBERATAN,
  TEMPLATE_BANDING,
  TEMPLATE_REMINDER,
  TEMPLATE_REMINDER2,
} = require('../utils/constanta')
const moment = require('moment')
const autoSaveModel = require('../model/autoSave.model')
const { cekSatuDataSanksi, cekSatuDataLaporan } = require('../utils/cekData')
const userModel = require('../model/user.model')
const { addManyDokumen } = require('../utils/dokumenFunction')
const logModel = require('../model/log.model')
const kontakModel = require('../model/kontak.model')

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

  if (!dataSanksi.length) {
    return response.success(res, {
      message: 'Tidak ada notifikasi yg dikirim',
    })
  }

  Promise.all(
    dataSanksi.map(
      async (sanksi) =>
        await sanksiModel.findByIdAndUpdate(sanksi._id, {
          is_pengajuan_keberatan: false,
          last_step: "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().add(-1, 'day').toISOString(),
      },
      'is_pengajuan_banding': {
        $exists: false,
        $eq: null,
      },
      'batas_waktu.jawaban_keberatan': {
        $exists: true,
        $ne: null,
      },
      ['pengajuan.cabut_sanksi']: {
        $exists: false,
        $eq: null,
      },
    })
    .populate('user')
    .populate('laporan')

  if (!dataSanksi.length) {
    return response.success(res, {
      message: 'Tidak ada notifikasi yg dikirim',
    })
  }

  Promise.all(
    dataSanksi.map(
      async (sanksi) => {
        // await notifWA(TEMPLATE_BANDING, [
        //   {
        //     key: '1',
        //     value: 'nama_pt',
        //     value_text: sanksi.laporan.pt.nama,
        //   },
        //   {
        //     key: '2',
        //     value: 'pemberi_sanksi',
        //     value_text: sanksi.user.lembaga.nama,
        //   },
        //   {
        //     key: '3',
        //     value: 'no_laporan',
        //     value_text: sanksi.laporan.no_laporan,
        //   },
        // ])
        await sanksiModel.findByIdAndUpdate(sanksi._id, {
          is_pengajuan_banding: false,
          last_step: "Dokumen Perbaikan"
        })
      }
    )
  )
  return response.success(res, {
    message: 'Notifikasi berhasil terkirim',
  })
})

exports.reminderKeberatan = handleError(async (req, res) => {
  let dataSanksi = await sanksiModel
    .find({
      'batas_waktu.jawaban_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.`,
            },
          ])
        } 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'
    const contacts = await kontakModel.find()
    await logModel.create({
      aktivitas: `Server berhasil mengirim notif wa kepada ${contacts.map((e) => e.nama).join(', ')} untuk reminder keberatan`
    })
  }

  return response.success(res, {
    message,
  })
})

exports.reminderBanding = handleError(async (req, res) => {
  let dataSanksi = await sanksiModel
    .find({
      'batas_waktu.jawaban_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.`,
            },
          ])
        } 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'
    const contacts = await kontakModel.find()
    await logModel.create({
      aktivitas: `Server berhasil mengirim notif wa kepada ${contacts.map((e) => e.nama).join(', ')} untuk reminder banding`
    })
  }

  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,
  })

  Promise.all(
    sanksi.map(async (e) =>
      sanksiModel.findByIdAndUpdate(e._id, {
        aktif: false,
      })
    )
  )

  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.backup = handleError(async (req, res) => {
  const dataBakup = await Promise.all([
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-sanksi.json'
      const sanksi = await sanksiModel.find()
      fs.writeFileSync(path, JSON.stringify(sanksi))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'sanksi.json' }
    })(),
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-laporan.json'
      const laporan = await laporanModel.find()
      fs.writeFileSync(path, JSON.stringify(laporan))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'laporan.json' }
    })(),
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-user.json'
      const user = await userModel.find()
      fs.writeFileSync(path, JSON.stringify(user))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'user.json' }
    })(),
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-chunk.json'
      const chunk = await chunkModel.find()
      fs.writeFileSync(path, JSON.stringify(chunk))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'chunk.json' }
    })(),
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-dokumen.json'
      const dokumen = await dokumenModel.find()
      fs.writeFileSync(path, JSON.stringify(dokumen))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'dokumen.json' }
    })(),
    (async () => {
      const path = 'backup/' + new Date().getTime() + '-pemantauan.json'
      const pemantauan = await dokumenModel.find()
      fs.writeFileSync(path, JSON.stringify(pemantauan))
      const { size } = fs.statSync(path)
      const mimetype = 'application/json'
      const buffer = fs.readFileSync(path)
      return { buffer, mimetype, size, originalname: 'pemantauan.json' }
    })(),
  ])
  const dokumen = await addManyDokumen(dataBakup)
  const tes = await backupModel.create({
    dokumen: dokumen.map(e => e._id)
  })
  return response.success(res, {
    message: 'berhasil membuat backup',
    data: tes
  })
})


exports.getBackup = handleError(async (req, res) => {
  const { id } = req.params
  const data = await backupModel.findById(id).populate('dokumen')
  if (!data) return response.error(res, {
    code: 404,
    message: 'Not Found',
  })

  return response.success(res, {
    message: 'berhasil mengambil data backup',
    data: data.dokumen
  })
})

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++;
      } catch (error) {
        return response.error(res, {
          message: 'Notifikasi gagal terkirim',
          error: error.message,
        })
      }
    }
  }))
  const contacts = await kontakModel.find()
  let message = 'Notifikasi berhasil terkirim'
  if (count === 0) message = 'tidak ada notifikasi yg dikirim'
  else await logModel.create({
    aktivitas: `Server berhasil mengirim notif wa kepada ${contacts.map((e) => e.nama).join(', ')} untuk reminder berakhirnya sanksi`
  })
  return response.success(res, {
    message,
  })
})