Highways4Good/api/app/lib/controllers/report/index.js

'use strict';
const { QueryTypes } = require('sequelize');

async function reportList (ctx) {
    try {
        const models = ctx.fs.dc.models;
        const { limit, page, startTime, endTime, keyword, userId, reportType, isTop, asc, projectType } = ctx.query
        let findOption = {
            where: {

            },
            attributes: ['id', 'road', 'time', 'projectType', 'roadSectionStart', 'roadSectionEnd', 'reportType', 'content', 'longitude', 'latitude', 'projectName', 'handleState'],
            include: [{
                model: models.User,
                attributes: ['name']
            }],
            order: [['time', asc ? 'ASC' : 'DESC']],
        }
        if (limit) {
            findOption.limit = limit
        }
        if (page && limit) {
            findOption.offset = page * limit
        }
        if (startTime && endTime) {
            findOption.where = {
                time: {
                    '$between': [startTime, endTime]
                }
            }
        }
        if (keyword) {
            if (reportType == 'road') {
                findOption.where.projectName = {
                    '$like': `%${keyword}%`
                }
            } else {
                findOption.where.road = {
                    '$like': `%${keyword}%`
                }
            }
        }
        if (userId) {
            findOption.where.userId = userId
        }
        if (reportType) {
            findOption.where.reportType = reportType
        }
        if (projectType) {
            findOption.where.projectType = projectType
        }
        let reportRes = null;

        if (isTop) {
            const sqlStr = 'select * from (SELECT R.*, "row_number"() OVER(PARTITION BY R.user_id ORDER BY R."time" DESC) AS NEWINDEX FROM report AS R ) AS NR WHERE NEWINDEX = 1'
            const sequelize = ctx.fs.dc.orm;
            reportRes = await sequelize.query(sqlStr, { type: QueryTypes.SELECT });
        } else {
            reportRes = await models.Report.findAll(findOption)
        }

        ctx.status = 200;
        ctx.body = reportRes
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

async function reportPosition (ctx) {
    try {
        const models = ctx.fs.dc.models;
        const { startTime, endTime, userId, reportType } = ctx.query
        const sequelize = ctx.fs.dc.ORM;

        let findMxTimeOption = {
            attributes: [
                'userId',
                [sequelize.fn('MAX', sequelize.col('time')), 'maxTime'],
            ],
            where: {

            },
            group: ['report.user_id'],
        }

        if (startTime && endTime) {
            findMxTimeOption.where = {
                time: {
                    '$between': [startTime, endTime]
                }
            }
        }

        if (userId) {
            findMxTimeOption.where.userId = userId
        }
        if (reportType) {
            findMxTimeOption.where.reportType = reportType
        }

        const reportMaxTimeRes = await models.Report.findAll(findMxTimeOption)
        const timeArr = reportMaxTimeRes.map(item => item.dataValues.maxTime)
        const reportRes = await models.Report.findAll({
            where: {
                time: { '$in': timeArr }
            }
        })
        ctx.status = 200;
        ctx.body = reportRes
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

async function reportDetail (ctx) {
    try {
        const models = ctx.fs.dc.models;
        const { reportId } = ctx.params

        const reportRes = await models.Report.findOne({
            where: {
                id: reportId
            }
        })

        ctx.status = 200;
        ctx.body = reportRes
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

async function reportHandle (ctx) {
    try {
        const { models } = ctx.fs.dc;

        const { reportId } = ctx.params
        const { handleState } = ctx.request.body

        await models.Report.update({
            handleState: handleState
        }, {
            where: {
                id: reportId
            }
        })

        ctx.status = 200;
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

async function createReport (ctx) {
    try {
        const { userId } = ctx.fs.api
        const models = ctx.fs.dc.models;
        const data = ctx.request.body;

        await models.Report.create({
            ...data,
            userId,
            time: new Date(),
        })

        ctx.status = 204
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

async function deleteReport (ctx) {
    try {
        const models = ctx.fs.dc.models;
        const { reportId } = ctx.params;

        await models.Report.destroy({
            where: {
                id: reportId
            }
        })

        ctx.status = 204
    } catch (error) {
        ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
        ctx.status = 400;
        ctx.body = {
            message: typeof error == 'string' ? error : undefined
        }
    }
}

// TODO 小程序填写道路名称的时候的道路筛选 是一起都返回 还是不断传关键字搜索返回

module.exports = {
    reportList,
    reportPosition,
    reportDetail, createReport, deleteReport, reportHandle
};