/**
 * 自定义 404 错误类
 * 未找到指定资源
 */
class NotFountError extends Error{
    constructor(message) {
        super(message);
        this.name = 'NotFountError';
    }
}

/**
 * 自定义 401错误类
 * 未经认证错误
 */
class UnauthorizedError extends Error {
    constructor(message) {
        super(message);
        this.name = 'UnauthorizedError'
    }
}

/**
 * 自定义400错误
 * 传参错误类
 */
class BadRequestError extends Error {
    constructor(message) {
        super(message);
        this.name = 'BadRequestError'
    }
}
module.exports = {
    BadRequestError,
    UnauthorizedError,
    NotFoundError
}

/**
 * 响应成功
 * @param res 响应体
 * @param message 响应信息
 * @param data 数据
 * @param code 状态码
 */
function success(res, message, data={}, code = 200){
    res.status(code).json({
        status:true,
        message,
        data,
    })
}

/**
 * 响应错误
 * @param res 响应体
 * @param error 错误类
 * @returns {*}
 */
function failure(res,error){
    if(error.name === 'SequelizeValidationError'){
        const errors = error.errors.map(e=>e.message)
        return res.status(400).json({
            status: false,
            message: '请求参数错误',
            errors:errors
        })
    }
    if(error.name === 'NotFoundError'){
        return res.status(404).json({
            status:false,
            message:'资源不存在',
            errors:[error.message]
        })
    }
    if(error.name === 'BadRequestError'){
        return res.status(400).json({
            status:false,
            message:'请求参数错误',
            errors:[error.message]
        })
    }
    if(error.name === 'UnauthorizedError'){
        return res.status(401).json({
            status:false,
            message:'认证失败',
            errors:[error.message]
        })
    }
    if(error.name === 'JsonWebTokenError'){
        return res.status(401).json({
            status:false,
            message:'认证失败',
            errors:['您提交的token错误']
        })
    }
    if(error.name === 'TokenExpiredError'){
        return res.status(401).json({
            status:false,
            message:'认证失败',
            errors:['您的token已过期']
        })
    }
    res.status(500).json({
        status: false,
        message:'服务器错误',
        errors:[error.message]
    })
}

module.exports = {
    success,
    failure
}

const express = require('express');
const router = express.Router();
const {Web} = require('../../models')
const {Op} = require("sequelize");
const {NotFoundError} = require("../../utils/errors");
const {success, failure} = require("../../utils/response");

/** 查询站点列表 */
router.get('/',async (req,res)=>{
  try{
    const {name} = req.query
    const currentPage = Math.abs(Number(req.query.currentPage || 1))
    const pageSize = Math.abs(Number(req.query.pageSize || 10))
    const offset = (currentPage - 1) * pageSize
    const condition = {
      order:[['id','desc']],
      limit:pageSize,
      offset
    }
    if(name){
      condition.where = {
        name:{[Op.like]:`%${name}%`}
      }
    }
    const {rows, count} = await Web.findAndCountAll(condition)
    success(res,'站点列表查询成功',{
      webs:rows,
      pagination:{
        total:count,
        currentPage,
        pageSize
      }
    })
  }catch(error){
    failure(res,error)
  }
})

/** 查询站点详情 */
router.get('/:id',async (req,res)=>{
  try{
    const web = await getDataById(req)
    success(res,'站点详情查询成功',web)
  }catch(error){
    failure(res,error)
  }
})

/** 新建站点 */
router.post('/',async (req,res)=>{
  try{
    const body = {
      ...getFilterBody(req),
      view:0
    }
    const web = await Web.create(body)
    success(res,'创建站点成功',web,201)
  }catch(error){
    failure(res,error)
  }
})

/** 删除站点 */
router.delete('/:id',async (req,res)=>{
  try{
    const web = await getDataById(req)
    await web.destroy()
    success(res,'删除站点成功')
  }catch(error){
    failure(res,error)
  }
})

/** 更新站点 */
router.put('/:id',async (req,res)=>{
  try{
    const web = await getDataById(req)
    const body = getFilterBody(req)
    await web.update(body)
    success(res,'站点更新成功',web)
  }catch(error){
    failure(res,error)
  }
})

/**
 * 根据id获取指定数据
 * @param req
 * @returns {Promise<void>}
 */
async function getDataById(req){
  const {id} = req.params
  const data = await Web.findByPk(id)
  if(!data){
    throw new NotFoundError(`未找到ID为：${id} 的站点`)
  }
  return data
}

/**
 * 获取到过滤后的body参数
 * @param request
 */
function getFilterBody(req){
  const {
    href, name, webIcon, webCover,
    content, categoryId, github, blogHref
  } = req.body
  return{
    href, name, webIcon, webCover, content,
    categoryId:Number(categoryId),
    github, blogHref
  }
}

module.exports = router;