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, penjadwalan, pelaporan, pemeriksaan, delegasi, sanksi } =
    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 data = []
  if (delegasi === 'true') {
    data.push({ SheetNames: 'Delegasi', data: dataDelegasi })
  }
  if (pelaporan === 'true') {
    data.push({ SheetNames: 'Pelaporan', data: dataLaporan })
  }
  if (penjadwalan === 'true') {
    data.push({
      SheetNames: 'Penjadwalan',
      data: dataJadwal,
    })
  }
  if (pemeriksaan === 'true') {
    data.push({ SheetNames: 'Pemeriksaan', data: dataPemeriksaan })
  }
  if (sanksi === 'true') {
    data.push({ SheetNames: 'Sanksi', data: dataSanksi })
  }
  const buffer = excel.to_excel(data)

  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) => {
  let dataPembina = await laporanModel.find()
  const user = req.user

  dataPembina = [
    ...new Set(
      dataPembina.map((e) => `${e.pt.pembina.id};${e.pt.pembina.nama}`)
    ),
  ]
  dataPembina = dataPembina.map((e) => ({
    id: e.split(';')[0],
    name: e.split(';')[1],
  }))

  let data = await Promise.all(
    dataPembina.map(async (e) => {
      return {
        pembina: e,
        laporan: await cekBanyakDataLaporan(user, {
          all: true,
          ['pt.pembina.id']: e.id,
        }),
        sanksi: (
          await cekBanyakDataSanksi(
            user,
            { all: true },
            { ['pt.pembina.id']: e.id }
          )
        ).filter((e) => e.laporan != null),
        jumlah_jadwal_evaluasi: await laporanModel
          .find({
            jadwal: {
              $ne: null,
              $exists: true,
            },
            'pt.pembina.id': e.id,
          })
          .count(),
        jumlah_pemeriksaan: await laporanModel
          .find({
            evaluasi: {
              $ne: [],
              $exists: true,
            },
            'pt.pembina.id': e.id,
          })
          .count(),
        jumlah_sanksi: await laporanModel
          .find({
            sanksi: {
              $ne: null,
              $exists: true,
            },
            'pt.pembina.id': e.id,
          })
          .count(),
        jumlah_keberatan: (
          await sanksiModel
            .find({
              'pengajuan.keberatan': {
                $ne: null,
                $exists: true,
              },
            })
            .populate({
              path: 'laporan',
              match: {
                'pt.pembina.id': e.id,
              },
            })
        ).filter((e) => e.laporan != null).length,
        jumlah_banding: (
          await sanksiModel
            .find({
              'pengajuan.banding': {
                $ne: null,
                $exists: true,
              },
            })
            .populate({
              path: 'laporan',
              match: {
                'pt.pembina.id': e.id,
              },
            })
        ).filter((e) => e.laporan != null).length,
        jumlah_pemantauan_perbaikan: (
          await sanksiModel
            .find({
              perbaikan: {
                $ne: [],
                $exists: true,
              },
            })
            .populate({
              path: 'laporan',
              match: {
                'pt.pembina.id': e.id,
              },
            })
        ).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.id': e.id,
              },
            })
        ).filter((e) => e.laporan != null).length,
      }
    })
  )

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