koacms(九)内容管理增删改查逻辑、内容分类增删改查逻辑

1、在controller文件夹的cms文件夹下新建cmsContentSort.js文件,这边后期还要修改调整

const { SuccessModel, ErrorModel } = require('../../model/resModel')
const cmsContentSortModel = require('../../model/cmsContentSortModel')
const cmsContentModel = require('../../model/cmsContentModel')
const UT = require('../../utils/common');

class CmsContentSortController {

    async page(ctx, next) {
        const { page = 1, size = 10, cate_name } = ctx.request.body
        const where = {}

        if (cate_name) {
            where.cate_name = cate_name
        }


        try {
            const data = await cmsContentSortModel.page(page, size, where)
            if (!data) return ctx.body = new ErrorModel('获取数据失败')
            for (let item of data) {
                const fields = await cmsFieldModel.getInfo({ models_id: item.models_id })
                item.fields = fields
                item.app_icos = []
                item.pc_icos = []
                item.imgs = []
                if (item.app_ico) {
                    item.app_icos = [{
                        fileUrl: item.app_ico,
                        url: (process.env.ALI_OSS ? process.env.ALI_URL : process.env.BASE_URL) + '/' + item.app_ico
                    }]
                }
                if (item.pc_ico) {
                    item.pc_icos = [{
                        fileUrl: item.pc_ico,
                        url: (process.env.ALI_OSS ? process.env.ALI_URL : process.env.BASE_URL) + '/' + item.pc_ico
                    }]
                }
                if (item.img) {
                    item.imgs = [{
                        fileUrl: item.img,
                        url: (process.env.ALI_OSS ? process.env.ALI_URL : process.env.BASE_URL) + '/' + item.img
                    }]
                }
            }
            const listJson = JSON.parse(JSON.stringify(data))
            const menuTree = UT.jsonToTree(listJson)
            ctx.body = new SuccessModel('获取数据成功', menuTree)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async list(ctx, next) {
        try {
            const data = await cmsContentSortModel.list(where)
            if (!data) return ctx.body = new ErrorModel('获取数据失败')
            const listJson = JSON.parse(JSON.stringify(data))
            const menuTree = UT.jsonToTree(listJson)
            ctx.body = new SuccessModel('获取数据成功', menuTree)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async classlist(ctx, next) {
        const where = {
            models_id: 1,
            cate_attr: 1
        }
        try {
            const data = await cmsContentSortModel.list(where)
            if (!data) return ctx.body = new ErrorModel('获取数据失败')
            const listJson = JSON.parse(JSON.stringify(data))
            const menuTree = UT.jsonToTree(listJson)
            ctx.body = new SuccessModel('获取数据成功', menuTree)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async catelist(ctx, next) {
        const { page = 1, size = 10, id } = ctx.request.body
        const where = {}

        if (id) {
            where.id = id
        }

        try {
            const data = await cmsContentSortModel.catelist(page, size, where)
            console.log('data', data.cates)
            // if(data) return ctx.body = new ErrorModel('获取数据失败')
            for (let item of data.cates) {
                const fields = await cmsFieldModel.getInfo({ models_id: item.models_id })
                item.fields = fields
                item.ico = []
                item.pic = [] 
                if (item.ico) {
                    item.ico = [{
                        fileUrl: item.ico,
                        url: process.env.BASE_URL + '/' + item.ico
                    }]
                }
                if (item.pic) {
                    item.pic = [{
                        fileUrl: item.pic,
                        url: process.env.BASE_URL + '/' + item.pic
                    }]
                }
                
            }
            data.cates = data.cates[0]
            ctx.body = new SuccessModel('获取数据成功', data)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async add(ctx, next) {
        const { name, scode, pcode = 0, subname = '', keywords = '', content = '', title, listtpl = '', contenttpl = '', outlink = '', mcode, ico = '', pic = '', filename = '', sorting = 50, status = 1 } = ctx.request.body
        try {
            const time = new Date().getTime() / 1000
            const res = await cmsContentSortModel.create({
                name,
                scode,
                pcode,
                subname,
                keywords,
                content,
                title,
                listtpl,
                contenttpl,
                outlink,
                mcode,
                ico,
                pic,
                filename,
                sorting, 
                status,
                create_user: 1,
                update_user: 1,
                create_time: time,
                update_time: time
            })
            if (!res) return ctx.body = new ErrorModel('分类添加失败')
            ctx.body = new SuccessModel('分类添加成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async update(ctx, next) {
        const { id, name, scode, pcode = 0, subname = '', keywords = '', content = '', title, listtpl = '', contenttpl = '', outlink = '', mcode, ico = '', pic = '', filename = '', sorting = 50, status = 1 } = ctx.request.body;
        try {
            const exitRes = await cmsContentSortModel.getInfo({ id })
            if (exitRes.length === 0) return ctx.body = new ErrorModel('该分类不存在')
            const time = new Date().getTime() / 1000
            const result = await cmsContentSortModel.update(id, {
                name,
                scode,
                pcode,
                subname,
                keywords,
                content,
                title,
                listtpl,
                contenttpl,
                outlink,
                mcode,
                ico,
                pic,
                filename,
                sorting, 
                status,
                update_time: time
            })

            if (!result) return ctx.body = new ErrorModel('修改分类失败')
            // 修改后需要把该分类下的内容模型也要改下
            const exitConent = await cmsContentModel.getInfo({ cate_id: id })

            const ids = []
            exitConent.forEach(item => {
                ids.push(item.id)
            })

            const updateConent = await cmsContentModel.updateModel(ids, models_id)
            ctx.body = new SuccessModel('修改分类成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }

    }

    async updateStatus(ctx, next) {
        const { id, status } = ctx.request.body;
        try {
            const exitRes = await cmsContentSortModel.getInfo({ id })
            if (exitRes.length === 0) return ctx.body = new ErrorModel('分类不存在!')
            const time = new Date().getTime() / 1000
            const result = await cmsContentSortModel.update(id, {
                status,
                update_time: time
            })

            if (!result) return ctx.body = new ErrorModel('修改状态失败')
            ctx.body = new SuccessModel('修改状态成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }

    }

    async delete(ctx, next) {
        const { id } = ctx.request.body;
        try {
            const exitRes = await cmsContentSortModel.getInfo({ id })
            if (!exitRes.length === 0) return res.json({ code: 400, data: '', msg: '分类不存在!' })
            // const time =new Date().getTime() / 1000
            const result = await cmsContentSortModel.delete(id)

            if (!result) return ctx.body = new ErrorModel('删除分类失败')
            ctx.body = new SuccessModel('删除分类成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }
}
module.exports = new CmsContentSortController()

2、在controller文件夹的cms文件夹下新建cmsContent.js文件,这边后期还要修改调整

const db = require('../../config/knex')
const { SuccessModel, ErrorModel } = require('../../model/resModel')
const cmsContentModel = require('../../model/cmsContentModel')
const cmsContentSortModel = require('../../model/cmsContentSortModel')
const cmsFieldModel = require('../../model/cmsFieldModel')
const cmsModelsModel = require('../../model/cmsModelsModel')
class CmsContentController {

    async page(ctx, next) {
        const { page = 1, size = 10, name, cate_id } = ctx.request.body
        const where = {}

        if (name) {
            where.name = name
        }

        if (cate_id) {
            // 查询当前分类下有没有子类
            const types = await cmsContentSortModel.getInfo({ pid: cate_id })

            const product_type_ids = [cate_id]
            if (types.length > 0) {
                types.forEach(item => {
                    product_type_ids.push(item.id)
                })
            }

            where.cate_id = product_type_ids
        }

        try {
            const data = await cmsContentModel.page(page, size, where)
            if (!data) return ctx.body = new ErrorModel('获取数据失败')

            for (let item of data.list) {
                const icos = []
                if (item.ico) {
                    const ico = item.ico.split(',')
                    ico.forEach(kk => {
                        icos.push({
                            url: `${(process.env.ALI_OSS ? process.env.ALI_URL : process.env.BASE_URL)}/${kk}`,
                            fileUrl: kk
                        })
                    })

                }
                item.icos = icos
                const fields = await cmsFieldModel.getInfo({ models_id: item.models_id })
                if (fields.length > 0) {
                    fields.map(i => {
                        switch (i.field_type) {
                            case 2:
                                i.values = i.field_values.split(',')
                                break;
                            case 3:
                                i.values = i.field_values.split(',')
                                break;
                            case 4:
                                i.values = i.field_values.split(',')
                                break;
                            case 6:
                                i[`${i.field_ename}Images`] = []
                                break;
                        }

                    })
                }
                item.fields = fields
                const fieldvals = await db.knex(`cms_ext_${item.table_name}`).where('aid', item.id)
                item.fieldvals = fieldvals[0]
                item.hotslist = []
                item.questionlist = []
                if (item.hots) {
                    const hotslist = item.hots.split(',')
                    const res = await cmsContentModel.listByIds(hotslist)
                    item.hotslist = res
                }

                if (item.questions) {
                    const questionslist = item.questions.split(',')
                    const res = await cmsContentModel.listByIds(questionslist)
                    item.questionlist = res
                }
            }

            ctx.body = new SuccessModel('获取数据成功', data)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async list(ctx, next) {
        try {
            const data = await cmsContentModel.list()
            // console.log('data',data)
            if (!data) return ctx.body = new ErrorModel('获取数据失败')
            ctx.body = new SuccessModel('获取数据成功', data)
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }
    async add(ctx, next) {
        const { acode = 1, scode, subscode, title, subtitle, filename, author, outlink, date, ico, tags, enclosure, keywords, description, sorting, status = 1, istop = 0, isrecommend = 0, isheadline = 0, visits, likes, tpl } = ctx.request.body
        try {

            const time = new Date().getTime() / 1000
            const res = await cmsContentModel.create({
                acode,
                scode,
                subscode,
                title,
                subtitle,
                filename,
                author,
                outlink,
                click,
                date,
                ico,
                tags,
                enclosure,
                keywords,
                description,
                visits,
                likes,
                tpl,
                sorting,
                status,
                isheadline,
                istop,
                isrecommend,
                create_user: 1,
                update_user: 1,
                create_time: time,
                update_time: time
            })
            if (!res || res.length == 0) return ctx.body = new ErrorModel('内容添加失败')

            fieldvals.aid = res[0]
            const fieldvalsRes = await db.knex.insert(fieldvals).into(`cms_ext_${table_name}`);
            if (fieldvalsRes.length == 0) return ctx.body = new ErrorModel('内容添加失败')

            ctx.body = new SuccessModel('内容添加成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }

    async update(ctx, next) {
        const { id, acode = 1, scode, subscode, title, subtitle, filename, author, outlink, date, ico, tags, enclosure, keywords, description, sorting, status = 1, istop = 0, isrecommend = 0, isheadline = 0, visits, likes, tpl } = ctx.request.body;
        try {
            const exitRes = await cmsContentModel.getInfo({ id })
            if (exitRes.length === 0) return ctx.body = new ErrorModel('该内容不存在')
            const time = new Date().getTime() / 1000
            const result = await cmsContentModel.update(id, {
                acode,
                scode,
                subscode,
                title,
                subtitle,
                filename,
                author,
                outlink,
                click,
                date,
                ico,
                tags,
                enclosure,
                keywords,
                description,
                visits,
                likes,
                tpl,
                sorting,
                status,
                isheadline,
                istop,
                isrecommend,
                update_time: time
            })

            if (result.length == 0) return ctx.body = new ErrorModel('修改内容失败')
            if (exitRes[0].models_id != models_id) {
                const fieldvals1 = await db.knex(`cms_ext_${table_name}`).where('aid', id)

                if (fieldvals1.length == 0) {
                    fieldvals.aid = id
                    const fieldvalsRes = await db.knex.insert(fieldvals).into(`cms_ext_${table_name}`);
                    if (fieldvalsRes.length == 0) return ctx.body = new ErrorModel('修改内容失败')
                } else {
                    const fieldvalsRes = await db.knex(`cms_ext_${table_name}`).where('aid', id).update(fieldvals);
                    if (fieldvalsRes.length == 0) return ctx.body = new ErrorModel('修改内容失败')
                }

            } else {
                const fieldvals1 = await db.knex(`cms_ext_${table_name}`).where('aid', id)

                if (fieldvals1.length == 0) return ctx.body = new ErrorModel('修改内容失败')
                if (Object.values(fieldvals).lentgh > 0) {
                    await db.knex(`cms_ext_${table_name}`).where('aid', id).update(fieldvals);
                }

            }
            ctx.body = new SuccessModel('修改内容成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }

    }

    async delete(ctx, next) {
        const { id } = ctx.request.body;
        try {
            const exitRes = await cmsContentModel.getInfo({ id })
            if (!exitRes.length === 0) return res.json({ code: 400, data: '', msg: '内容不存在!' })
            const result = await cmsContentModel.delete(id)
            if (!result) return ctx.body = new ErrorModel('删除内容失败')
            const model = await cmsModelsModel.getInfo({ id: exitRes[0].models_id })
            // console.log('fieldvals',model)
            const fieldvals = await db.knex(`cms_ext_${model[0].table_name}`).where('aid', id).del();

            if (fieldvals.length == 0) return ctx.body = new ErrorModel('删除内容失败')

            ctx.body = new SuccessModel('删除内容成功')
        } catch (error) {
            return ctx.body = new ErrorModel(error)
        }
    }


}
module.exports = new CmsContentController()

3、在model文件夹下新建cmsContentSortModel.js文件

const db = require('../config/knex')
const UT = require('../utils/common')
class cmsContentSortModel {
    async create(data){
        return await db.create('cms_content_sort',data)
    }

    async getInfo(id){
        return await db.find('cms_content_sort',id)
    }
    
    async update(id,data){
        return await db.update('cms_content_sort',id,data)
    }
    async batchInsert(data){
        return await db.batchInsert('cms_content_sort',data)
    }
    async batchDelete(ids){
        return await db.batchDelete('cms_content_sort',ids)
    }

    async delete(id){
        return await db.remove('cms_content_sort',id)
    }

    async page(page=1,size=10, where={},orderBy='',fields='*'){
      const offset = (page - 1) * size;
      const order = orderBy ? order : ['cms_content_sort.id' ,'desc'];
      return await db.knex('cms_content_sort')
            .join('cms_models','cms_content_sort.mcode','cms_models.id')
            .select('cms_content_sort.*','cms_models.model_name','cms_models.table_name')
            .where((qb) => {
                if (where.cate_name) {
                  qb.where('cms_content_sort.cate_name', 'like', `%${where.cate_name}%`);
                }
                if (where.form_type) {
                  qb.where('cms_content_sort.form_type', '=', where.form_type);
                }
              })
            .orderBy(order[0],order[1])
  }

  async catelist(page=1,size=10, where={},orderBy='',fields='*'){
    const offset = (page - 1) * size;
    const order = orderBy ? order : ['cms_content_sort.id' ,'desc'];
    const arr =  await db.knex('cms_content_sort')
          .join('cms_models','cms_content_sort.mcode','cms_models.id')
          .select('cms_content_sort.*','cms_models.model_name','cms_models.table_name')
          .where((qb) => {
              if (where.cate_name) {
                qb.where('cms_content_sort.cate_name', 'like', `%${where.cate_name}%`);
              }
              if (where.id) {
                qb.where('cms_content_sort.id', '=', where.id);
              }
            })
    
    arr[0].fields = await db.knex('cms_field').where('mcode',arr[0].mcode).where('status',1)
    
    // 获取当前栏目以及其子栏目的id
    let cate_ids = [where.id]
    const ids = await db.knex('cms_content_sort').where('pid',where.id).orderBy('order','asc').orderBy('id','desc')
    
    if(ids.length > 0){
      cate_ids = cate_ids.concat(ids)
    } 
    
    const [countResult, rows] = await Promise.all([
        db.knex('cms_content').count('* as total').whereIn('cms_content.scode',cate_ids),
        db.knex('cms_content')
            .join(`cms_ext_${arr[0].table_name}`,`cms_ext_${arr[0].table_name}.aid`,'cms_content.id')
            .join('cms_content_sort','cms_content_sort.id','cms_content.scode')
            .select('cms_content.*',`cms_ext_${arr[0].table_name}.*`,'cms_content_sort.cate_name','cms_content_sort.cate_attr','cms_content_sort.list_tmp','cms_content_sort.index_tmp','cms_content_sort.article_tmp')
            .whereIn('cms_content.scode',cate_ids)
            .orderBy('cms_content.id','desc')
            .offset(offset)
            .limit(size)
    ]);
    const goodsData = {
      current_page:page,
      data: rows,
      total:countResult[0].total,
      size
    }
 
  let topcid = 0
  const allIds = await db.knex('cms_content_sort').select('id','pid','cate_attr')
  
  if(arr[0].pid == 0){
    topcid = where.id
  } else { 
  const filterIds = UT.findTopLevelIds(allIds,arr[0].pid)
    topcid = filterIds[0]
  }
  const topCates = await db.knex('cms_content_sort').where('id',topcid)
  const cateChildrenData =await db.knex('cms_content_sort')
                                .join('cms_models','cms_content_sort.mcode','cms_models.id')
                                .select('cms_content_sort.*','cms_models.model_name','cms_models.table_name')
                                .where('cms_content_sort.pid',topcid).where('cms_content_sort.status',1) 

 
  
  let positionData = []
  if(topcid == arr[0].id){
    positionData.push(topCates)
  }else{
    positionData = UT.position(allIds,arr[0].id)
  }

  // console.log('filterIds',positionData)

    return {
      goodsData,
      positionData,
      topCates,
      cateChildrenData,
      topcid,
      cates:arr
    }
  }

  
    async list(where={},fields='*'){
        return await db.knex('cms_content_sort')
          .select(fields)
          .where((qb) => {
              if (where.mcode) {
                qb.where('cms_content_sort.mcode', '=', where.mcode);
              }
              if (where.cate_attr) {
                qb.where('cms_content_sort.cate_attr', '=', where.cate_attr);
              }
            })
          .orderBy('order','asc')
          .orderBy('id','desc')
    }

    async listByIds(ids){
      return await db.getListByIds('cms_content_sort',ids)
    }

}

module.exports = new cmsContentSortModel()

4、在model文件夹下新建cmsContentModel.js文件

const db = require('../config/knex')

class CmsContentModel {
    async create(data){
        return await db.create('cms_content',data)
    }

    async getInfo(id){
        return await db.find('cms_content',id)
    }
    
    async update(id,data){
        return await db.update('cms_content',id,data)
    }

    async batchInsert(data){
        return await db.batchInsert('cms_content',data)
    }

    async updateModel(ids,models_id){
      return await db.knex('cms_content').whereIn('id', ids).update({models_id})
  }

    async delete(id){
        return await db.remove('cms_content',id)
    }

    async page(page=1,size=10, where={},orderBy='',fields='*'){
      const offset = (page - 1) * size;
      const order = orderBy ? order : ['cms_content.id' ,'desc'];
      
      const [countResult, rows] = await Promise.all([
          db.knex('cms_content').count('* as total')
          .where((qb) => {
              if (where.name) {
                qb.where('name', 'like', `%${where.name}%`);
              }
             
              if (where.scode) {
                qb.whereIn('scode', where.scode)
              }
          
          }),
          db.knex('cms_content')
              .join('cms_content_sort', 'cms_content.scode', 'cms_content_sort.id')
              .join('cms_models', 'cms_content.mcode', 'cms_models.id')
              .select('cms_content.*','cms_content_sort.cate_name','cms_content_sort.cate_attr','cms_content_sort.list_tmp','cms_content_sort.index_tmp','cms_content_sort.article_tmp','cms_models.model_name','cms_models.table_name')
              .where((qb) => {
                  if (where.name) {
                    qb.where('cms_content.name', 'like', `%${where.name}%`);
                  }
                 
                  if (where.scode) {
                    qb.whereIn('cms_content.scode', where.scode)
                  }
                })
              .orderBy(order[0],order[1])
              .offset(offset)
              .limit(size)
          ]);

      const count = countResult[0].total;
      const pageData = {
          page:Number(page),
          size,
          count,
          list: rows
      };
  
      return pageData;

  }

    async list(where=[],fields='*'){
        return await db.getList('cms_content',where,fields)
    }

    async listByIds(ids,fields='*'){
      return await db.getListByIds('cms_content',ids,fields)
    }
}

module.exports = new CmsContentModel()

5、修改routes下的admin.js

const router = require('koa-router')()
const jwt = require('../../utils/verify')

const AdminController = require('../../controller/admin')
const AuthGroupController = require('../../controller/authGroup')
const AuthRuleController = require('../../controller/authRule')
const ConfigController = require('../../controller/config')
const ConfigTypeController = require('../../controller/configType')
const CmsModelsController = require('../../controller/cms/cmsModels')
const CmsFieldController = require('../../controller/cms/cmsField')
const CmsContentController = require('../../controller/cms/cmsContent')
const CmsContentSortController = require('../../controller/cms/cmsContentSort')
router.prefix('/api')

//用户注册
router.post('/system/user/add', AdminController.add)
router.post('/system/user/login', AdminController.login)
router.post('/system/user/update', AdminController.update)
router.post('/system/user/status', AdminController.updateStatus)
router.post('/system/user/list', AdminController.list)
router.post('/system/user/page', AdminController.page)
router.post('/system/user/delete', AdminController.delete)
router.post('/system/user/batchDelete', AdminController.batchDelete)
router.post('/system/user/existence', AdminController.existence)
router.post('/system/user/password', AdminController.password)
// 角色
router.post('/system/roles/page', AuthGroupController.page)
router.get('/system/roles/list', AuthGroupController.list)
router.post('/system/roles/add', AuthGroupController.add)
router.post('/system/roles/update', AuthGroupController.update)
router.post('/system/roles/del', AuthGroupController.delete)
router.post('/system/roles/menu', AuthGroupController.menu)
router.post('/system/roles/menu/update', AuthGroupController.menuUpdate)
// 菜单 
router.get('/system/menu/user', AuthRuleController.user)
router.post('/system/menu/list', AuthRuleController.list)
router.post('/system/menu/add', AuthRuleController.add)
router.post('/system/menu/update', AuthRuleController.update)
router.post('/system/menu/del', AuthRuleController.delete)
// 系统配置
router.post('/system/config/page', ConfigController.page)
router.post('/system/config/list', ConfigController.list)
router.post('/system/config/add', ConfigController.add)
router.post('/system/config/update', ConfigController.update)
router.post('/system/config/del', ConfigController.delete)
router.post('/system/config/bulkUpdate', ConfigController.bulkUpdate)
// 系统配置类型
router.get('/system/config/type/list', ConfigTypeController.list)
router.post('/system/config/type/add', ConfigTypeController.add)
router.post('/system/config/type/update', ConfigTypeController.update)
router.post('/system/config/type/del', ConfigTypeController.delete) 
router.post('/system/config/getSysInfo', ConfigController.getSysInfo)
// 模型
router.post('/cms/models/page', CmsModelsController.page)
router.post('/cms/models/list', CmsModelsController.list)
router.post('/cms/models/add', CmsModelsController.add)
router.post('/cms/models/update', CmsModelsController.update)
router.post('/cms/models/del', CmsModelsController.delete)
// 模型字段
router.post('/cms/field/page', CmsFieldController.page)
router.post('/cms/field/list', CmsFieldController.list)
router.post('/cms/field/add', CmsFieldController.add)
router.post('/cms/field/update', CmsFieldController.update)
router.post('/cms/field/del', CmsFieldController.delete)
// 分类
router.post('/cms/cate/page', CmsContentSortController.page)
router.get('/cms/cate/list', CmsContentSortController.list)
router.post('/cms/cate/add', CmsContentSortController.add)
router.post('/cms/cate/update', CmsContentSortController.update)
router.post('/cms/cate/del', CmsContentSortController.delete)
router.post('/cms/cate/status', CmsContentSortController.updateStatus)
router.get('/cate/class', CmsContentSortController.classlist)
router.post('/cate/cate', CmsContentSortController.catelist)
// 内容
router.post('/cms/content/page', CmsContentController.page)
router.post('/cms/content/list', CmsContentController.list)
router.post('/cms/content/add', CmsContentController.add)
router.post('/cms/content/update', CmsContentController.update)
router.post('/cms/content/del', CmsContentController.delete)

module.exports = router

6、最后用apifox测试下接口

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值