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

const sanksiModel = require('../../model/sanksi.model')
const autoSaveModel = require('../../model/autoSave.model')
const handleError = require('../../utils/v1/handleError')
const response = require('../../utils/responseHandler')
const { addManyDokumen, addDokumen } = require('../../utils/dokumenFunction')
const { validate } = require('../../utils/v1/validation')
const pemantauanModel = require('../../model/pemantauan.model')
const pelanggaranModel = require('../../model/pelanggaran.model')
const batchModel = require('../../model/batch.model')
const logModel = require('../../model/log.model')
const { hariKerja } = require('../../utils/hariKerja')
const {
  cekSatuDataSanksi,
  cekSatuDataLaporan,
  cekBanyakDataSanksi
} = require('../../utils/v1/cekData')
const laporanModel = require('../../model/laporan.model')
const { SANKSI, SELESAI, TRUE, FALSE, KEBERATAN, PERBAIKAN, BANDING, CREATE_SANKSI, UPDATE_SANKSI } = require('../../utils/constanta')
const pddiktiService = require('../../services/v2/pddikti.service')

exports.create = handleError(async (req, res) => {
  const { no_sanksi, keterangan, from_date, to_date, tanggal_terima_sanksi, tanggal_akhir_keberatan } = req.body
  const sanksiBody = JSON.parse(req.body.sanksi)
  let { pelanggaran_id } = req.body
  const { laporan_id } = req.params
  const { dokumen: files, berita_acara, dokumen_terima_sanksi } = req.files
  const user = req.user

  const isValid = validate(res, req.body, {
    no_sanksi: 'string',
    keterangan: 'string',
    pelanggaran_id: 'string',
    sanksi: 'string',
  })
  if (!isValid) return

  const laporan = await cekSatuDataLaporan(res, user, laporan_id, {
    evaluasi: { $exists: true, $ne: [] }
  })
  if (!laporan) return

  const id_pelanggaran = pelanggaran_id.split(',')
  const pelanggaran = await pelanggaranModel.find({
    _id: {
      $in: id_pelanggaran
    }
  })
  if (!pelanggaran.length) {
    return response.error(res, { message: 'pelanggaran_id tidak ada' })
  }
  pelanggaran_id = pelanggaran.map((e) => e._id)

  const sanksi = await sanksiModel.findOne({ laporan: laporan_id })
  if (sanksi) {
    return response.error(res, {
      message: 'Sanksi sudah ada'
    })
  }

  if (!files) {
    return response.error(res, {
      message: 'dokumen harus ada'
    })
  }
  let dokumenBeritaAcara_id = null
  if (berita_acara) {
    const dokumenBeritaAcara = await addManyDokumen(berita_acara)
    dokumenBeritaAcara_id = dokumenBeritaAcara[0]
  }
  let dokumenTerimaSanksi_id = []
  if (dokumen_terima_sanksi) {
    const dokumenTerimaSanksi = await addManyDokumen(dokumen_terima_sanksi)
    dokumenTerimaSanksi_id = dokumenTerimaSanksi.map((e) => e._id)
  }

  const dokumen = await addManyDokumen(files)
  const dokumen_id = dokumen.map((e) => e._id)
  const autoSave = await autoSaveModel.findOne({ laporan_id: laporan._id })
  if (autoSave?.laporan?.PenetapanSanksi)
    await laporanModel.findByIdAndUpdate(laporan._id, {
      berita_acara: autoSave.laporan.PenetapanSanksi
    })
  const data = await sanksiModel.create({
    no_sanksi,
    laporan: laporan._id,
    user: user._id,
    pelanggaran: pelanggaran_id,
    keterangan,
    dokumen: dokumen_id,
    sanksi: sanksiBody,
    berita_acara: dokumenBeritaAcara_id,
    tanggal_terima_sanksi,
    dokumen_terima_sanksi: dokumenTerimaSanksi_id,
    tanggal_akhir_keberatan,
    masa_berlaku: from_date && to_date ? { from_date, to_date } : null,
    batas_waktu: from_date ? { keberatan: tanggal_akhir_keberatan } : null,
    aktif: from_date ? true : false,
    levelSanksi: Math.max(...sanksiBody.map(e => e.level))
  })
  await laporanModel.findByIdAndUpdate(laporan._id, {
    sanksi: data._id,
    $push: { step: from_date ? SANKSI : SELESAI },
    flag: from_date ? SANKSI : SELESAI
  })
  await pemantauanModel.create({
    laporan: laporan._id,
    sanksi: data._id,
    action: CREATE_SANKSI,
    pt_id: laporan.pt.id,
    user: user._id,
    keterangan: 'Melakukan penetapan Sanksi',
    dokumen: dokumen_id,
    berita_acara: dokumenBeritaAcara_id
  })

  return response.success(res, {
    message: 'Berhasil membuat Sanksi',
    data
  })
})

exports.updatePDDIKTI = handleError(async (req, res) => {
  const { sanksi_id } = req.params
  const sanksi = await sanksiModel.findOne({ _id: sanksi_id }).populate('pelanggaran').populate('laporan')
  if (sanksi.masa_berlaku.from_date) {
    await batchModel.create({
      sanksi: sanksi._id,
      type: UPDATE_SANKSI
    })
  }
  return response.success(res, {
    message: 'Berhasil memasukkan data ke dalam batch update status PDDIKTI'
  })
})

exports.update = handleError(async (req, res) => {
  const { no_sanksi, keterangan, from_date, to_date } = req.body
  let sanksiBody = req.body.sanksi
  const { sanksi_id } = req.params
  const files = req.files
  const user = req.user

  const isValid = validate(res, req.body, {
    no_sanksi: 'string',
    keterangan: 'string',
    sanksi: 'string',
    from_date: {type: 'string', optional: true},
    to_date: {type: 'string', optional: true}
  })
  if (!isValid) return

  const sanksi = await cekSatuDataSanksi(res, user, sanksi_id, { all: true })
  if (!sanksi) return

  sanksiBody = JSON.parse(sanksiBody)

  if (!files.length) {
    return response.error(res, {
      message: 'Dokumen Harus Ada!'
    })
  }

  const dokumen = await addManyDokumen(files)
  const dokumen_id = dokumen.map((e) => e._id)
  const masa_berlaku = from_date && to_date ? { from_date, to_date } : null
  const data = await sanksiModel.updateOne(
    { _id: sanksi._id },
    {
      no_sanksi,
      sanksi: sanksiBody,
      keterangan,
      dokumen: dokumen_id,
      aktif: from_date ? true : false,
      levelSanksi: Math.max(...sanksiBody.map(e => e.level)),
      masa_berlaku,
      $push: {
        riwayat_sanksi: sanksi
      }
    }
  )
  await pemantauanModel.create({
    laporan: sanksi.laporan._id,
    sanksi: sanksi._id,
    action: UPDATE_SANKSI,
    pt_id: sanksi.laporan.pt.id,
    user: user._id,
    keterangan: 'Melakukan Perubahan Sanksi',
    dokumen: dokumen_id,
    data: {
      no_sanksi,
      sanksi: sanksiBody,
      keterangan,
      masa_berlaku,
    }
  })

  return response.success(res, {
    message: 'Berhasil merubah Sanksi',
    data
  })
})

exports.updatePt = handleError(async (req, res) => {
  const { is_pengajuan_keberatan, is_pengajuan_banding, is_dokumen_perbaikan } = req.body
  const { sanksi_id } = req.params
  const user = req.user

  const isValid = validate(res, req.body, {
    is_pengajuan_keberatan: { type: 'string', optional: true },
    is_pengajuan_banding: { type: 'string', optional: true },
    is_dokumen_perbaikan: { type: 'string', optional: true }
  })
  if (!isValid) return

  const sanksi = await cekSatuDataSanksi(res, user, sanksi_id)
  if (!sanksi) return

  let data = {}
  let data2 = {}
  let keterangan = ''
  let last_step = ''
  let flag
  if (is_pengajuan_keberatan) {
    if (is_pengajuan_keberatan === TRUE) {
      last_step = 'Permohonan Keberatan'
      keterangan = 'Menerima Pengajuan Keberatan'

    } else if (is_pengajuan_keberatan === FALSE) {
      keterangan = 'Membatalkan Pengajuan Keberatan'
      last_step = 'Dokumen Perbaikan'
    }
    data = { is_pengajuan_keberatan: is_pengajuan_keberatan === TRUE }
    flag = is_pengajuan_keberatan === TRUE ? KEBERATAN : PERBAIKAN
  }

  if (is_pengajuan_banding) {
    if (is_pengajuan_banding === TRUE) {
      last_step = 'Permohonan Banding'
      keterangan = 'Menerima Pengajuan Banding'
    } else if (is_pengajuan_banding === FALSE) {
      keterangan = 'Membatalkan Pengajuan Banding'
      last_step = 'Dokumen Perbaikan'
    }
    data = { is_pengajuan_banding: is_pengajuan_banding === TRUE }
    flag = is_pengajuan_banding === TRUE ? BANDING : PERBAIKAN
  }

  if (is_pengajuan_keberatan || is_pengajuan_banding) {
    await pemantauanModel.create({
      laporan: sanksi.laporan._id,
      sanksi: sanksi._id,
      action: UPDATE_SANKSI,
      pt_id: sanksi.laporan.pt.id,
      user: user._id,
      keterangan
    })
  }

  if (is_dokumen_perbaikan === TRUE) {
    last_step = 'Dokumen Perbaikan'
    flag = PERBAIKAN
  }

  if (!last_step) {
    return response.error(res, {
      message: 'Gagal merubah Sanksi'
    })
  }

  data.last_step = last_step
  data2.flag = flag
  const checkStep = await laporanModel.findOne({ sanksi: sanksi._id, step: flag })
  if (!checkStep) data2.$push = { step: flag }
  await laporanModel.findOneAndUpdate({ sanksi: sanksi._id }, data2)
  await sanksiModel.updateOne(
    { _id: sanksi._id },
    data
  )

  return response.success(res, {
    message: 'Berhasil merubah Sanksi'
  })
})

exports.getAll = handleError(async (req, res) => {
  const user = req.user
  const {
    keberatan,
    jawaban,
    banding,
    cabutSanksi,
    perbaikan,
    aktif,
    delegasi,
    naikSanksi,
    turunSanksi,
    pengajuan_keberatan,
    bypassCabutSanksi
  } = req.query
  const where = {}
  const q = {}
  const sort = { createdAt: -1 }
  if (aktif && aktif === FALSE) {
    where.aktif = false
  } else if (aktif && aktif === TRUE) {
    where.aktif = true
  }
  if (pengajuan_keberatan === TRUE) {
    where.is_pengajuan_keberatan = true
  }
  if (keberatan === TRUE) {
    where['pengajuan.keberatan'] = { $exists: true, $ne: null }
    where.is_pengajuan_keberatan = true
    if (jawaban === TRUE) {
      where['jawaban.keberatan'] = { $exists: true, $ne: null }
    }
  }
  if (banding === TRUE) {
    where.banding = true
    where.is_pengajuan_banding = true
    where['pengajuan.keberatan'] = { $exists: true, $ne: null }
    where['jawaban.keberatan'] = { $exists: true, $ne: null }
    where['pengajuan.banding'] = { $exists: true, $ne: null }
    if (jawaban === 'true') {
      where['jawaban.banding'] = { $exists: true, $ne: null }
    }
  }
  if (cabutSanksi === TRUE) {
    where.$or = [
      { perbaikan: { $exists: true, $ne: [] } },
      { bypass_cabut_sanksi: { $eq: true } }
    ]
    if (jawaban === FALSE) {
      where.$or = [
        {
          'pengajuan.cabut_sanksi': {
            $exists: true, $ne: null
          }
        }, {
          bypass_cabut_sanksi: true
        }
      ]
      where.aktif = true
    }
  }
  if (perbaikan === TRUE) {
    where.perbaikan = { $exists: true, $ne: [] }
    where.aktif = true
    sort['perbaikan.updatedAt'] = -1
  }
  if (delegasi === TRUE) {
    where.delegasi = true
  }
  if (naikSanksi === TRUE) {
    where['sanksi.level'] = { $in: [1, 2] }
  }
  if (turunSanksi === TRUE) {
    where['sanksi.level'] = { $in: [2, 3] }
  }
  if (bypassCabutSanksi === TRUE) {
    where['masa_berlaku.from_date'] = {
      $exists: true,
      $ne: null
    }
    where.aktif = true
    where.bypass_cabut_sanksi = {
      $exists: false,
      $eq: null,
    }
  }
  const data = await cekBanyakDataSanksi(user, where, q, sort)
  return response.success(res, {
    message: 'Berhasil ambil data Sanksi',
    data
  })
})

exports.getOne = handleError(async (req, res) => {
  const user = req.user
  const { sanksi_id } = req.params

  const w = {}
  const { banding, aktif, delegasi, all } = req.query
  if (banding === TRUE) {
    w.banding = true
    w['pengajuan.keberatan'] = { $exists: true, $ne: null }
    w['jawaban.keberatan'] = { $exists: true, $ne: null }
    w['pengajuan.banding'] = { $exists: true, $ne: null }
  }
  if (delegasi === TRUE) {
    w.delegasi = true
  }
  if (all === TRUE) {
    w.all = true
  }
  if (aktif === FALSE) {
    w.aktif = false
  }

  const sanksi = await cekSatuDataSanksi(res, user, sanksi_id, w)
  if (!sanksi) return

  return response.success(res, {
    message: 'Berhasil ambil satu data Sanksi',
    data: sanksi
  })
})

exports.editTmt = handleError(async (req, res) => {
  const user = req.user
  const { id } = req.params
  const { from_date, to_date, no_surat } = req.body
  const files = req.files

  const sanksi = await cekSatuDataSanksi(res, user, id)
  if (!sanksi) return

  const isValid = validate(res, req.body, {
    from_date: { type: 'date', convert: true },
    to_date: { type: 'date', convert: true },
    // no_surat: 'string'
  })
  if (!isValid) return

  if (!files.length) {
    return response.error(res, {
      message: 'dokumen harus ada'
    })
  }

  const dokumen = await addManyDokumen(files)
  const dokumen_id = dokumen.map((e) => e._id)

  const data = await sanksiModel.findByIdAndUpdate(sanksi._id, {
    masa_berlaku: {
      from_date,
      to_date
    },
    index_perpanjangan: sanksi.index_perpanjangan + 1,
    $push: {
      riwayat_perpanjangan_sanksi: {
        masa_berlaku: {
          from_date: sanksi.masa_berlaku.from_date,
          to_date: sanksi.masa_berlaku.to_date,
        },
        index: sanksi.index_perpanjangan,
        dokumen: dokumen_id
      }
    },
    // 'pengajuan.update_tmt': { no_surat, dokumen: dokumen_id }
  })

  await pemantauanModel.create({
    laporan: sanksi.laporan._id,
    user: user._id,
    action: 'EDIT TMT',
    pt_id: sanksi.laporan.pt.id,
    keterangan: 'Mengubah masa berlaku sanksi',
    for_public: true
  })

  return response.success(res, {
    message: 'Berhasil update tmt',
    data
  })
})

exports.addPesertaPleno = handleError(async (req, res) => {
  const isValid = validate(res, req.body, {
    laporan_id: 'string',
    nama: 'string'
  })
  if (!isValid) return

  const { laporan_id, nama } = req.body

  const laporan = await laporanModel.findOne({
    _id: laporan_id
  })
  if (!laporan) return response.error(res, {
    code: 404,
    message: 'laporan_id tidak ada'
  })

  const file = req.file
  if (!file) {
    return response.error(res, {
      message: 'ttd harus ada'
    })
  }
  const dokumen = await addDokumen(file)

  await laporanModel.findOneAndUpdate(
    { _id: laporan._id },
    {
      $push: {
        peserta_penetapan_sanksi: {
          nama,
          ttd: dokumen.id
        }
      }
    }
  )

  return response.success(res, {
    message: 'Berhasil tambah peserta pleno'
  })
})

exports.removePesertaPleno = handleError(async (req, res) => {
  const isValid = validate(res, req.body, {
    peserta_id: 'string',
    laporan_id: 'string'
  })
  if (!isValid) return
  const user = req.user

  const { laporan_id, peserta_id } = req.body

  const laporan = await cekSatuDataLaporan(res, user, laporan_id, {
    evaluasi: { $exists: true, $ne: [] }
  })
  if (!laporan) return

  await laporanModel.findOneAndUpdate(
    { _id: laporan._id },
    {
      $pull: {
        peserta_penetapan_sanksi: {
          _id: peserta_id
        }
      }
    }
  )

  return response.success(res, {
    message: 'Berhasil menghapus peserta pleno'
  })
})

exports.updateToDokumenPerbaikan = handleError(async (req, res) => {
  const isValid = validate(res, req.body, {
    sanksi_id: 'string'
  })
  if (!isValid) return

  const { sanksi_id } = req.body
  const user = req.user
  const sanksi = await cekSatuDataSanksi(res, user, sanksi_id)

  await sanksiModel.updateOne({
    _id: sanksi._id
  }, {
    is_pengajuan_keberatan: false,
    'pengajuan.cabut_sanksi': null
  })

  return response.success(res, {
    message: 'Berhasil update data Sanksi ke Dokumen Perbaikan'
  })
})