hfysite/server/router/r_base.js

const router = require('express').Router();
const {paramFail, ServerError, success, controlError, searchSuccess} = require("../tools/result");
const c = require("../control/c_base");
const typeTool = require("../tools/typeTool_cjs");
const decode = require("../tools/decode_cjs");
const time = require("../tools/time_cjs");
const {toSqlString} = require("../tools/searchSql");
const progressField = require('../map/progressField');
const {isEmpty, toNumber} = require("../tools/typeTool_cjs");
const checkLogin = require("../middleware/checkSession");
const upload = require("../middleware/upload");
const config_path = require("../configs/path");
const log = require("../logger").logger("r_base","info");

router.get('/carousel', async (req, res) => {
  try{
    let [err, data] = await c.getEnableCarousel();
    if(err){
      controlError(res, err,`获取启用的轮播图失败 ${err.eMsg||err.message}`);
    }else{
      success(res, data);
    }
  }catch (e){
    ServerError(res, e, `获取启用轮播图失败 ${e.message}`);
  }
});

router.get('/carousel/list', async (req, res) => {
  try{
    let [err, data] = await c.getAllCarousel();
    if(err){
      controlError(res, err,`获取所有轮播图失败 ${err.eMsg||err.message}`);
    }else{
      success(res, data);
    }
  }catch (e){
    ServerError(res, e, `获取所有轮播图失败 ${e.message}`);
  }
});

router.put('/carousel', checkLogin(progressField.session_hfy), async (req, res) => {
  try{
    log.info(`[轮播图新增] 开始新增轮播图`);
    // 获取轮播数据
    let {sort,fileId,type,value} = req.body;
    let err,data;
    // 检测参数
    if(isEmpty(sort) || isEmpty(fileId) || isEmpty(type) || isEmpty(value)){
      return paramFail(res, '缺少必要参数');
    }
    [err,data] = await c.addCarousel(sort,fileId,type,value);
    if(err){
      controlError(res, err,`新增轮播图失败 ${err.eMsg||err.message}`);
    }else{
      success(res, data);
    }
  }catch (e){
    ServerError(res, e, `新增轮播图接口异常 ${e.message}`);
  }
});

router.post('/carousel', checkLogin(progressField.session_hfy), async (req, res) => {
  try{
    log.info(`[轮播图修改] 开始修改轮播图数据`);
    // 获取轮播数据
    let {carouselId,updateItems} = req.body;
    let err,data;
    console.log(carouselId);
    console.log(updateItems);
    // 检测参数
    if(isEmpty(carouselId) || isEmpty(updateItems) ){
      return paramFail(res, '缺少必要参数');
    }
    [err,data] = await c.updateCarousel(carouselId,updateItems);
    if(err){
      controlError(res, err,`轮播图修改 ${err.eMsg||err.message}`);
    }else{
      success(res, data);
    }
  }catch (e){
    ServerError(res, e, `轮播图修改接口异常 ${e.message}`);
  }
});

router.delete('/carousel/:carouselId', checkLogin(progressField.session_hfy), async (req, res) => {
  try{
    log.info(`[删除轮播] 开始删除轮播图数据`);
    // 获取轮播数据
    let {carouselId} = req.params;
    let err,data;
    // 检测参数
    carouselId = toNumber(carouselId);
    if(carouselId < 1){
      return paramFail(res, '参数异常,请检查参数');
    }
    [err,data] = await c.deleteCarousel(carouselId);
    if(err){
      controlError(res, err,`删除轮播失败 ${err.eMsg||err.message}`);
    }else{
      success(res, data);
    }
  }catch (e){
    ServerError(res, e, `删除轮播接口异常 ${e.message}`);
  }
});

router.get('/files', checkLogin(progressField.session_hfy), async (req, res) => {
  try{
    let err, result;
    // 从数据库中读取数据.
    let {key, l, p, type} = req.query;
    console.log(req.query);
    console.log(type);
    [err, result] = await c.searchFiles(type, key, p, l);
    if(err){
      log.info(`[文件资源] 加载失败 ${err.message}`);
      return controlError(res, err, null);
    }
    console.log(result);
    searchSuccess(res,
      result.arr,
      result.total,
      result.page,
      result.limit,
    );
  }catch (e){
    console.log(e)
    ServerError(res, e, `[文件资源] 加载失败 ${e.message}`);
  }
})
router.post('/fileUp',checkLogin(progressField.session_hfy) ,upload({
  tmp:config_path.tmp,
  maxFileSize: 1024*1024*10,// 10M
}),async (req,res)=>{
  try{
    let err, data;
    let files = req.files;
    let type = req.body.type;
    if(!type){
      type = req.query.type;
    }
    // console.log(type);
    type = typeTool.toNumber(type);
    // console.log(type);
    [err, data] = await c.uploadFile(type, files);
    if(err){
      log.warn(`[文件上传] 上传文件失败 ${err.eMsg||err.message}`);
      controlError(res, err,`上传文件失败 ${err.eMsg||err.message}`);
    }
    // 返回地址数组
    return success(res, data);
  }catch (e){
    console.log(e);
    ServerError(res, e, `上传文件异常 ${e.message}`);
  }
});

router.delete('/file/:fileId',checkLogin(progressField.session_hfy),async (req,res)=>{
  try{
    let err, data;
    let fileId = req.params.fileId;
    if(!fileId){
      return paramFail(res, '缺少参数');
    }
    fileId = typeTool.toNumber(fileId);
    [err, data] = await c.deleteFile(fileId);
    if(err){
      log.warn(`[文件删除] 删除文件失败 ${err.eMsg||err.message}`);
      return controlError(res, err,`删除文件失败 ${err.eMsg||err.message}`);
    }
    return success(res, data);
  }catch (e) {
    console.log(e);
    ServerError(res, e, `删除文件移除 ${e.message}`);
  }
})

router.get('/types',async (req,res)=>{
  try{
    log.info(`[类型] 获取基础类型信息`);
    // 从数据库中读取数据.
    let [err, data] = await c.getTypes();
    if(err){
      log.warn(`[类型] 获取类型失败 ${err.eMsg||err.message}`);
      return controlError(res, err,`获取类型失败 ${err.eMsg||err.message}`);
    }
    return success(res, data);
  }catch (e){
    console.log(e);
    ServerError(res, e, `获取数据异常 ${e.message}`);
  }
});

module.exports =  router;