PTB-be/controller/graph.controller.js

const handleError = require('../utils/handleError')
const excel = require('../utils/excel')
const response = require('../utils/responseHandler')
const {
  cekBanyakDataLaporan,
  dataLaporanAggregate,
  cekBanyakDataSanksi,
} = require('../utils/cekData')
const laporanModel = require('../model/laporan.model')
const sanksiModel = require('../model/sanksi.model')
const moment = require('moment')

exports.laporan = handleError(async (req, res) => {
  const user = req.user
  const data = {}
  const date = new Date()

  // let berdasarkan_tahun = {}
  const {
    jumlahLaporan,
    jadwal,
    evaluasi,
    sanksi,
    newLaporan,
    laporanBulan,
    laporanTahun,
    bulan,
    tahun,
    listJadwal,
  } = req.query

  // if (tahun) {
  berdasarkan_tahun = {
    $and: [
      {
        createdAt: {
          $gte: new Date(`${tahun || date.getFullYear()}`),
        },
      },
      {
        createdAt: {
          $lt: new Date(`${parseInt(tahun) + 1 || date.getFullYear() + 1}`),
        },
      },
    ],
  }
  // }

  const laporan = await cekBanyakDataLaporan(user, { ...berdasarkan_tahun })

  if (jumlahLaporan == 'true') {
    const delegasi = await cekBanyakDataLaporan(user, {
      delegasi: true,
      ...berdasarkan_tahun,
    })
    const ditutup = await cekBanyakDataLaporan(user, {
      aktif: false,
      ...berdasarkan_tahun,
    })

    data.jumlah_laporan = {
      dikti: laporan.length,
      lldikti: delegasi.length,
      ditutup: ditutup.length,
      tes: {
        delegasi: true,
        ...berdasarkan_tahun,
      },
    }
  }

  if (jadwal == 'true') {
    const hasJadwal = laporan.filter((e) => e.jadwal.judul).length
    const notHasJadwal = laporan.filter((e) => !e.jadwal.judul).length

    data.jadwal = {
      hasJadwal,
      notHasJadwal,
    }
  }

  if (evaluasi == 'true') {
    const hasEvaluasi = laporan.filter(
      (e) => e.evaluasi.length && e.jadwal.judul
    ).length
    const notHasEvaluasi = laporan.filter(
      (e) => e.evaluasi.length == 0 && e.jadwal.judul
    ).length

    data.evaluasi = {
      hasEvaluasi,
      notHasEvaluasi,
    }
  }

  if (sanksi == 'true') {
    const hasSanksi = laporan.filter(
      (e) => e.sanksi && e.evaluasi.length
    ).length
    const notHasSanksi = laporan.filter(
      (e) => !e.sanksi && e.evaluasi.length
    ).length

    data.sanksi = {
      hasSanksi,
      notHasSanksi,
    }
  }

  if (newLaporan == 'true') {
    data.newLaporan = await cekBanyakDataLaporan(user, {
      limit: 3,
      select: 'no_laporan pt.nama -user createdAt',
    })
  }

  if (laporanBulan == 'true') {
    let date = {}
    if (bulan || (bulan && tahun)) {
      const temp = new Date()
      date = {
        $expr: {
          $and: [
            { $eq: [{ $month: '$createdAt' }, parseInt(bulan)] },
            {
              $eq: [
                { $year: '$createdAt' },
                parseInt(tahun) || temp.getFullYear(),
              ],
            },
          ],
        },
      }
    }

    data.laporan_perbulan = await dataLaporanAggregate(
      user,
      { ...date },
      {
        _id: {
          bulan: {
            $month: '$createdAt',
          },
          tahun: {
            $year: '$createdAt',
          },
        },
        jumlah_laporan: {
          $sum: 1,
        },
      }
    )
  } else if (laporanTahun == 'true') {
    const temp = new Date()
    let date = {
      $expr: {
        $eq: [{ $year: '$createdAt' }, parseInt(tahun) || temp.getFullYear()],
      },
    }

    data.laporan_perTahun = await dataLaporanAggregate(
      user,
      { ...date },
      {
        _id: {
          bulan: {
            $month: '$createdAt',
          },
          tahun: {
            $year: '$createdAt',
          },
        },
        jumlah_laporan: {
          $sum: 1,
        },
      }
    )
  }

  if (listJadwal == 'true') {
    const temp = new Date()
    let date = {
      $expr: {
        $and: [
          {
            $eq: [
              { $month: '$jadwal.dari_tanggal' },
              parseInt(bulan) || temp.getMonth() + 1,
            ],
          },
          {
            $eq: [
              { $year: '$jadwal.dari_tanggal' },
              parseInt(tahun) || temp.getFullYear(),
            ],
          },
        ],
      },
    }

    data.list_jadwal = await dataLaporanAggregate(
      user,
      {
        aktif: true,
        ...date,
        jadwal: {
          $ne: null,
          $exists: true,
        },
      },
      {
        _id: {
          bulan: {
            $month: '$jadwal.dari_tanggal',
          },
          tahun: {
            $year: '$jadwal.dari_tanggal',
          },
        },
        jadwal: {
          $push: '$jadwal',
        },
      }
    )
  }

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

exports.excel = handleError(async (req, res) => {
  const user = req.user
  const w = {}
  const date = new Date()
  switch (user.role.id) {
    case 2020:
      w['$or'] = [
        {
          role_asal: 'dikti',
        },
        {
          role_data: 'dikti',
        },
      ]
      break
    case 2021:
      w['$or'] = [
        {
          role_asal: 'lldikti',
        },
        {
          role_data: 'lldikti',
        },
      ]
      w['pt.pembina.id'] = user.lembaga.id
      break
  }

  const { tahun } = req.query

  berdasarkan_tahun = {
    $and: [
      {
        createdAt: {
          $gte: new Date(`${tahun || date.getFullYear()}`),
        },
      },
      {
        createdAt: {
          $lt: new Date(`${parseInt(tahun) + 1 || date.getFullYear() + 1}`),
        },
      },
    ],
  }

  const laporan = await laporanModel
    .find({ ...w, ...berdasarkan_tahun })
    .populate('user')

  const dataDelegasi = laporan.map((value) => ({
    Tanggal: moment(value.createdAt).format('DD-MMMM-YYYY'),
    'No. Laporan': value.no_laporan,
    'Nama Perguruan Tinggi': value.pt.nama,
    'Keterangan Laporan': value.keterangan,
    'Dibuat Oleh': value.user.nama,
    Status: !value.aktif
      ? 'Ditutup'
      : (value.role_asal === 'dikti' && value.role_data === 'dikti') ||
        (value.role_data == 'dikti' && user.role.id === 2020) ||
        (value.role_asal === 'lldikti' && value.role_data === 'lldikti') ||
        (value.role_data == 'lldikti' && user.role.id === 2021)
      ? `Ditindaklanjuti ${value.role_data === 'dikti' ? 'DIKTI' : 'LLDIKTI'}`
      : `Delegasi Ke ${value.role_data === 'dikti' ? 'DIKTI' : 'LLDIKTI'}`,
  }))

  const dataLaporan = laporan.map((value) => ({
    Tanggal: moment(value.createdAt).format('DD-MMMM-YYYY'),
    'No. Laporan': value.no_laporan,
    'Nama Perguruan Tinggi': value.pt.nama,
    'Keterangan Laporan': value.keterangan,
    'Dibuat Oleh': value.user.nama,
    Status:
      value.sanksi || value.aktif === false
        ? 'Pelaporan Selesai'
        : 'Pelaporan Belum Selesai',
  }))

  const dataJadwal = laporan
    .filter((e) => e.aktif === true)
    .map((value) => ({
      Tanggal: moment(value.createdAt).format('DD-MMMM-YYYY'),
      'No. Laporan': value.no_laporan,
      'Nama Perguruan Tinggi': value.pt.nama,
      'Keterangan Laporan': value.keterangan,
      'Dibuat Oleh': value.user.nama,
      'Dari Tanggal':
        value.jadwal.judul &&
        moment(value.jadwal.dari_tanggal).format('DD-MMMM-YYYY'),
      'Sampai Tanggal':
        value.jadwal.judul &&
        moment(value.jadwal.sampai_tanggal).format('DD-MMMM-YYYY'),
      Status: value.jadwal.judul ? 'Sudah ada jadwal' : 'Belum ada jadwal',
    }))

  const dataPemeriksaan = laporan
    .filter((e) => e.aktif === true && e.jadwal.judul)
    .map((value) => ({
      Tanggal: moment(value.createdAt).format('DD-MMMM-YYYY'),
      'No. Laporan': value.no_laporan,
      'Nama Perguruan Tinggi': value.pt.nama,
      'Keterangan Laporan': value.keterangan,
      'Dibuat Oleh': value.user.nama,
      Status: value.evaluasi.length ? 'Sudah diperiksa' : 'Belum diperiksa',
    }))

  const dataSanksi = laporan
    .filter((e) => e.aktif === true && e.evaluasi.length)
    .map((value) => ({
      Tanggal: moment(value.createdAt).format('DD-MMMM-YYYY'),
      'No. Laporan': value.no_laporan,
      'Nama Perguruan Tinggi': value.pt.nama,
      'Keterangan Laporan': value.keterangan,
      'Dibuat Oleh': value.user.nama,
      Status: value.sanksi ? 'Sudah ditetapkan' : 'Belum ditetapkan',
    }))

  const buffer = excel.to_excel([
    {
      SheetNames: 'Delegasi',
      data: dataDelegasi,
    },
    {
      SheetNames: 'Pelaporan',
      data: dataLaporan,
    },
    {
      SheetNames: 'Penjadwalan',
      data: dataJadwal,
    },
    {
      SheetNames: 'Pemeriksaan',
      data: dataPemeriksaan,
    },
    {
      SheetNames: 'Sanksi',
      data: dataSanksi,
    },
  ])

  res.header(
    'Content-Type',
    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
  )
  return res.end(Buffer.from(buffer))
})

exports.laporanSelesai = handleError(async (req, res) => {
  const user = req.user

  laporan = await cekBanyakDataLaporan(user, { aktif: false })
  sanksi = await cekBanyakDataSanksi(user, { aktif: false })
  const data = {
    laporan,
    sanksi,
    jumlah_selesai: sanksi.length,
    jumlah_ditutup: laporan.length,
  }

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

exports.jumlahStatusLaporan = handleError(async (req, res) => {
  const pembina = await laporanModel.distinct('pt.pembina.nama')

  let data = await Promise.all(
    pembina.map(async (e) => {
      return {
        [e]: {
          jumlah_jadwal_evaluasi: await laporanModel
            .find({
              jadwal: {
                $ne: null,
                $exists: true,
              },
              'pt.pembina.nama': e,
            })
            .count(),
          jumlah_pemeriksaan: await laporanModel
            .find({
              evaluasi: {
                $ne: [],
                $exists: true,
              },
              'pt.pembina.nama': e,
            })
            .count(),
          jumlah_sanksi: await laporanModel
            .find({
              sanksi: {
                $ne: null,
                $exists: true,
              },
              'pt.pembina.nama': e,
            })
            .count(),
          jumlah_keberatan: (
            await sanksiModel
              .find({
                'pengajuan.keberatan': {
                  $ne: null,
                  $exists: true,
                },
              })
              .populate({
                path: 'laporan',
                match: {
                  'pt.pembina.nama': e,
                },
              })
          ).filter((e) => e.laporan != null).length,
          jumlah_banding: (
            await sanksiModel
              .find({
                'pengajuan.banding': {
                  $ne: null,
                  $exists: true,
                },
              })
              .populate({
                path: 'laporan',
                match: {
                  'pt.pembina.nama': e,
                },
              })
          ).filter((e) => e.laporan != null).length,
          jumlah_pemantauan_perbaikan: (
            await sanksiModel
              .find({
                perbaikan: {
                  $ne: [],
                  $exists: true,
                },
              })
              .populate({
                path: 'laporan',
                match: {
                  'pt.pembina.nama': e,
                },
              })
          ).filter((e) => e.laporan != null).length,
          jumlah_pencabutan_sanksi: (
            await sanksiModel
              .find({
                'pengajuan.cabut_sanksi': {
                  $ne: null,
                  $exists: true,
                },
              })
              .populate({
                path: 'laporan',
                match: {
                  'pt.pembina.nama': e,
                },
              })
          ).filter((e) => e.laporan != null).length,
        },
      }
    })
  )

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