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.json");
const log = require("../logger").logger("r_base","info");
const fieldHandle = require("../tools/fieldHandle");
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('/showblocks', async (req, res) => {
  try {
    let [err, data] = await c.getEnableShowBlocks();
    if (err) {
      controlError(res, err, `获取启用的展示块失败 ${err.eMsg || err.message}`);
    } else {
      success(res, data);
    }
  } catch (e) {
    ServerError(res, e, `获取启用展示块失败 ${e.message}`);
  }
});

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

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

// 更新展示块
router.post('/showblocks', checkLogin(progressField.session_hfy), async (req, res) => {
  try {
    log.info(`[展示块修改] 开始修改展示块数据`);
    // 获取展示块数据
    let { blockId, updateItems } = req.body;
    let err, data;
    console.log(blockId);
    console.log(updateItems);
    // 检测参数
    if (isEmpty(blockId) || isEmpty(updateItems)) {
      return paramFail(res, '缺少必要参数');
    }
    [err, data] = await c.updateShowBlock(blockId, updateItems);
    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('/base',async (req,res)=>{
  try{
    log.info(`[基础数据获取] 获取基础数据信息,前后端通用数据`);
    let err, data;
    // 从数据库中读取数据.
    fieldHandle.isExpire();
   [err, data] = await c.getBaseData();
    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('/info', async(req, res)=>{
  try{
    log.info(`[平台基础信息获取] 获取基础数据信息,前后端通用数据`);
    let err, data;
    // 从数据库中读取数据.
    [err, data] = await c.getBaseInfo();
    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.post('/edit', checkLogin(progressField.session_hfy),
  async (req, res) => {
    try{
      log.info(`[平台基础信息编辑] 修改平台基础信息`);
      let body = req.body;
      let err, data;
      // 从数据库中读取数据.
      [err, data] = await c.editBaseInfo(body);
      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;