整理node接口

整理接口

router文件

index.js （入口文件）

const {
  express,
  Router,
  json,
  urlencoded
} = require("express");
const router = Router();
const cors = require("../filter/cors");

//格式化url 
router.use(json(), urlencoded())

//允许跨域
router.use(cors);
const session = require('express-session');

//图书管理
const goods = require("./goods");
const library = require("../router/library")

const vcode = require("./vcode");
const token = require("../utils/token");
const login = require("./login")
const order = require("./order")
const muser = require("./muser")

// 短信验证码
const sendSms = require("./sendSms")

const {
  formatData
} = require("../utils/tools");

//设置会话 session 运行在服务器端，当客户端第一次访问服务器时，可以将客户的登录信息保存
router.use(session({
  secret: 'fqniu',
  resave: false,
  saveUninitialized: true,
  cookie: {
    // secure: true
    maxAge: 1000 * 60 * 60 * 2
  }
}))


//关于图书管理的接口
router.use("/goods", goods);
router.use("/library", library);

router.use("/vcode", vcode)

router.use("/login", login)
// router.use("/muser", muser)
router.use("/order", order)
router.use("/muser", muser)

// 短信验证码
router.use("/sendSms",sendSms)

//检验token
router.get("/jwtverify", (req, res) => {
  const {
    authorization
  } = req.query;

  // console.log("vvvv", authorization); //未定义？
  if (token.verify(authorization)) {
    res.send(formatData())
  } else {
    res.send(formatData({
      code: 0
    }))

  }
})

module.exports = router;

sendSms.js（短信接口）

const Core = require('@alicloud/pop-core');
const express = require('express');
const router = express.Router()
const {
  formatData
} = require('../utils/tools')
router.get('/:PhoneNumbers', (req, res) => {
    const {
        PhoneNumbers
    } = req.params
    let randomNum = (parseInt((Math.random() * 9900) + 100)).toString();
    randomNum = randomNum.padStart(4, '0');
    const TemplateParam = `{"code":${randomNum}}`
    req.session.Sms = randomNum
    var client = new Core({
        accessKeyId: 'xxLTAI4G2vNjhrGTESjtA9axB6xxx',
        accessKeySecret: 'xxQFNGnTnhvR5P1GDMZFz9ahFPm6zWwmxxx',
        endpoint: 'https://dysmsapi.aliyuncs.com',
        apiVersion: '2017-05-25'
    });

    var params = {
        "RegionId": "cn-hangzhou",
        "PhoneNumbers": PhoneNumbers,
        "SignName": "xxx",
        "TemplateCode": "SMS_201715882",
        "TemplateParam": TemplateParam
    }

    var requestOption = {
        method: 'POST'
    };
    client.request('SendSms', params, requestOption).then(() => {
        res.send(formatData(1001));
    }, (ex) => {
        console.log(ex);
    })
})

module.exports = router;

vcdoe.js（图形验证码）

const express = require("express");
const router = express.Router()
// 制作图形码的包工具
const svgCaptcha = require("svg-captcha");
const {
  formatData
} = require("../utils/tools");

router.get("/", async (req, res) => {
  //1：图形验证码的配置项
  const options = {
    // size: 10,
    noise: 3,
    ignoreChars: '0o1il',
    background: '#58bc58',
    color: true,
    fontSize: 50,
    height: 54
  }
  //2：创建一个图形验证码！
  var captcha = svgCaptcha.create();
  // console.log(captcha); //{data: '<svg.../svg>', text: 'abcd'}

  //3：把验证码存入会话Session
  req.session.vcode = captcha.text.toLowerCase();
  res.send(formatData({
    data: captcha.data
  }));
})



module.exports = router;

upload.js（上传图片）

const express = require('express');
const router = express.Router();
const multer = require('multer');
const path = require('path');

const mongo = require('../utils/mongo');
const {
  formatData,
  md5
} = require('../utils/tools')


// 配置上传参数
let storage = multer.diskStorage({
  // destination: function (req, file, cb) {
  //   cb(null, './uploads/');
  // },

  // 上传文件保存目录，无则自动创建
  destination: path.join(__dirname, '../public/uploads/'),

  // 格式化文件名：字段名+时间戳+扩展名
  // avatar-1597202347355.jpg
  filename: function (req, file, cb) {
    // 获取文件后缀名
    let ext = path.extname(file.originalname);

    cb(null, file.fieldname + '-' + Date.now() + ext);
  }
})

// 设置中间件
const uploadMiddleware = multer({
  storage
});


// post /api/upload/avatar
router.post('/avatar', uploadMiddleware.single('avatar'), (req, res) => {
  // 中间件会把图片信息格式化到req.file,req.files
  console.log('file=', req.file, req.body);
  const {
    _id
  } = req.body;

  // 更新用户信息
  const avatarUrl = '/uploads/' + req.file.filename
  mongo.update('user', {
    _id
  }, {
    $set: {
      avatarUrl
    }
  })

  res.send(formatData({
    data: {
      _id,
      avatarUrl
    }
  }));
})

// 一次性最多传5张图片
router.post('/goods', uploadMiddleware.array('goods', 5), (req, res) => {

})

module.exports = router;

增删改查

login.js （用户登录 查）

const express = require("express");
const router = express.Router();
// 用于加密crypto
const crypto = require('crypto');
// 封装的函数 
// formatData : 用户对返回的数据处理 / md5: 封装加密函数
const {
  formatData,
  md5
} = require("../utils/tools")

// 数据库mongo的封装
const mongo = require("../utils/mongo")
// token值的封装
const token = require("../utils/token")

//登录接口 用户的登录
router.post("/", async (req, res) => {
  let {
    username,
    password,
  } = req.body;

  console.log("登录参数", username, password)

  // 加密后进行查询
  // password = md5(password)

  let {
    result
  } = await mongo.find("m-user", { //[{}] 查询到的结果为一个数组的形式，里面是一个对象！
    username,
    password
  })
  // console.log("最初的", result);
  
  //存在的话，就显示可以登录
  if (result.length > 0) {
    const authorization = token.create({
      username
    })
    //登陆的时候，把当前的token存储在result之中，返回给前端 用于显示当前登陆用户
    result = result[0];
    result.authorization = authorization;
    console.log(result);
    res.send(formatData({
      data: result //返回一个 {}
    }))
  } else {
    res.send(formatData({
      code: 0
    }))
  }
})

module.exports = router;

reg.js （用户注册）

const express = require('express');
const router = express.Router();
// const crypto = require('crypto');

const {formatData,md5} = require('../utils/tools');
const mongo = require('../utils/mongo');

// RESTful api规范
// 用户注册
router.post('/',async (req,res)=>{
    let {username,password} = req.body;
    console.log('password=',password)

    // const hash = crypto.createHash('md5');
    // hash.update(password+'fqniu'); // 加盐 盐值
    // password = hash.digest('hex');
    // console.log('password2=',password,password.length)

    password = md5(password)
    let result
    try{
        result = await mongo.insert('user',{username,password});
        res.send(formatData());
    }catch(err){
        res.send(forMatData({code:0}))

    }
})

// 检查是否存在用户名
router.get('/check',async (req,res)=>{
    const {username} = req.query;

    const result = await mongo.find('user',{username});
    if(result.length>0){
        res.send(formatData({code:0}))
    }else{
        res.send(formatData())
    }
})


module.exports = router;

user.js （用户增删改）

const express = require('express');
const router = express.Router();
const mongo = require('../utils/mongo');
const {
  formatData
} = require('../utils/tools');

// 修改 修改用户的密码
router.put('/:username', async (req, res) => {
  let {
    username
  } = req.params;
  console.log("修改用户", req.params)

  // 1、先查询用户是否存在
  try {
    let {
      result
    } = await mongo.find('m-user', {
      username: username
    }, {
      // 过滤的字段 就比如不想要密码
      field: {
        password: false
      }
    });
    if (result.length === 0) {
      res.send(formatData({
        msg: "用户不存在"
      }))
      return false
    }
  } catch (e) {
    console.log('err=', err);
    res.send(formatData({
      msg: "用户的存在问题"
    }))
  }

  // 2、如果用户存在 再进行密码修改
  let {
    password,
  } = req.body;

  let newData = {}
  if (password) {
    newData.password = password
  }

  try {
    await mongo.updata('m-user', {
      username: username
    }, {
      $set: newData
    });
    res.send(formatData({
      msg: "修改成功"
    }))
  } catch (err) {
    console.log('err=', err);
    res.send(formatData({
      msg: "修改失败"
    }))
  }
})

// 查询单个用户id
router.get('/find', async (req, res) => {
  // req.params从fetch哪里过来的
  const {
    username,
    vcode
  } = req.query;
  // console.log(req)
  // console.log(username, vcode)
  // console.log(req.session.vcode)

  // 其中vcode是前端输入的验证码
  // 从会话中获取验证码
  // 校验验证码 这里的req.session 是已经存有vcode的 Session 对象
  // console.log('login.session=', req.session)
  // vcode 是前端输入验证码之后，传过来的参数 
  // 而 req.session.vcode 是Session中的存的 vcode
  if (vcode !== req.session.vcode) {
    res.send(formatData({
      code: 10
    }))
    return;
  }

  let {
    result
  } = await mongo.find('m-user', {
    username: username
  }, {
    // 过滤的字段 就比如不想要密码
    field: {
      password: false
    }
  });
  console.log("用户", result)
  // 如果result的长度为0 则说明用户不存在 可以注册
  // 如果result的长度为1 则说明用户存在 可以修改密码
  if (result.length !== 0) {
    res.send(formatData({
      msg: 1
    }));
  } else {
    res.send(formatData({
      msg: 0
    }));
  }

})

// 注册，添加用户
router.post('/', async (req, res) => {
  let {
    username,
    password,
  } = req.body;

  // 验证码校验
  // if (vcode !== req.session.vcode) {
  //   res.send(formatData({
  //     code: 10
  //   }))
  //   return;
  // }

  try {
    const result = await mongo.insert('m-user', {
      username,
      password
    });
    // res.send(result);
    if (result.length !== 0) {
      res.send(formatData({
        msg: "添加成功"
      }));
    }
  } catch (err) {
    res.send(formatData({
      msg: "添加失败"
    }));
  }
})


// 查询单个用户id
router.get('/:username', async (req, res) => {
  // req.params从fetch哪里过来的
  const {
    username
  } = req.params;
  console.log(username)

  let {
    result
  } = await mongo.find('m-user', {
    username: username
  }, {
    // 过滤的字段 就比如不想要密码
    field: {
      password: false
    }
  });
  console.log(result)
  if (result.length !== 0) {
    res.send(formatData({
      msg: 1
    }));
  } else {
    res.send(formatData({
      msg: 0
    }));
  }
})

// // 添加用户 用于用户的注册
// router.post('/', async (req, res) => {
//     const {
//       username,
//       password,
//       vcode
//       // gender,
//       // age
//     } = req.body;
//     console.log(req.body, 666)
//     // 要添加全部字段值 因为有些设置了 不能为空
//     try {
//       const result = await mongo.insert('m-user', {
//         username,
//         password
//         // gender,
//         // age
//       });
//       // res.send(result);
//       res.send(formatData({
//         msg: "添加成功"
//       }));
//     } catch (err) {

//       res.send(formatData({
//         msg: "添加失败"
//       }));
//     }
//   })

// // async函数修饰的函数会返回一个promise对象 await一定时在async内部
// router.get('/', async (req, res) => {
//   try {
//     // 接收从前端拿到的数据 万一有分页这些东西呢
//     const {
//       page,
//       size,
//       username: query,
//     } = req.query;
//     // 因为size有可能是字符串 所以转成数字
//     const limit = size * 1;
//     const skip = (page - 1) * limit;
//     // 等待promise对象执行成功后 也就是resolve这个状态返回给的值 接收这个值 如果接受不到 那就报错
//     // 并且执行catch里面的东西

//     console.log("参数1", query);
//     //判断是否存在 query这个查询参数
//     let queryShow = {}
//     if (query) {
//       queryShow.username = query.trim();
//     }
//     console.log("我是muser", query);
//     let {
//       result,
//       datalen
//     } = await mongo.find("m-user", queryShow, {
//       skip,
//       limit
//     })
//     res.send(formatData({
//       data: result,
//       datalen: datalen
//     }))

// const {
//   result
// } = await mongo.find('m-user', {}, {
//   limit,
//   skip,
//   username
// });
// res.send(formatData({
//   data: result
// }));

//   } catch (err) { //err是try里面的代码报的错误
//     res.send(formatData({
//       code: 0
//     }))
//   }

// })

// // 查询单个用户id
// router.get('/:id', async (req, res) => {
//   // req.params从fetch哪里过来的
//   const {
//     id
//   } = req.params;
//   console.log(id)

//   let {
//     result
//   } = await mongo.find('m-user', {
//     _id: id
//   }, {
//     // 过滤的字段 就比如不想要密码
//     field: {
//       password: false
//     }
//   });
//   console.log(result)
//   res.send(formatData({
//     data: result[0]
//   }));
// })


// // 查询单个用户id
// router.get('/s', async (req, res) => {
//   // req.params从fetch哪里过来的
//   const {
//     id
//   } = req.params;
//   console.log(id)

//   let result = await mongo.find('m-user', {
//     _id: id
//   }, {
//     // 过滤的字段 就比如不想要密码
//     field: {
//       password: false
//     }
//   });
//   console.log(result)
//   res.send(formatData({
//     data: result[0]
//   }));
// })

// // 修改 
// router.put('/:id', async (req, res) => {
//   const {
//     usename
//   } = req.params;
//   console.log(req.params)
//   let {
//   
//     password,
//     age,
//     gender
//   } = req.body;

//   let newData = {
//     ge,
//     gender
//   }
//   // console.log(newData)

//   if (password) {
//     // password = md5(password);
//     newData.password = password
//   }

//   try {
//     console.log(id)
//     await mongo.updata('m-user', {
//       _id: id
//     }, {
//       $set: newData
//     });
//     res.send(formatData({
//       data: {
//         _id: id,
//         ...newData
//       }
//     }))
//   } catch (err) {
//     console.log('err=', err);
//     res.send(formatData({
//       code: 0
//     }))
//   }
// })

// // 当method是删除的方式的时候
// router.delete('/:id', async (req, res) => {
//   // req.params从fetch哪里过来的
//   const {
//     id
//   } = req.params;
//   // let sql = `delete from username where id=${id}`;

//   try {
//     const result = await mongo.remove('m-user', {
//       _id: id
//     });
//     res.send(formatData({
//       msg: "删除成功"
//     }));
//   } catch (err) {
//     res.send(formatData({
//       code: 0
//     }))
//   }
// })

// // 添加用户 用于用户的注册
// router.post('/', async (req, res) => {
//   const {
//     username,
//     password
//     // gender,
//     // age
//   } = req.body;
//   console.log(req.body, 666)
//   // 要添加全部字段值 因为有些设置了 不能为空

//   try {
//     const result = await mongo.insert('m-user', {
//       username,
//       password
//       // gender,
//       // age
//     });
//     // res.send(result);
//     res.send(formatData({
//       msg: "添加成功"
//     }));
//   } catch (err) {

//     res.send(formatData({
//       msg: "添加失败"
//     }));
//   }
// })

module.exports = router;

utils文件下

mongo.js （数据库的增删改查）

//引入mongodb数据库 => MongoClient mongo =>客户端
const {
  MongoClient,
  ObjectId
} = require("mongodb");

// mongo连接网址
const url = 'mongodb://localhost:27017';

//mongo连接 数据库名称
const dbName = 'ali-novel';

async function connect() {
  // 注意点：由于 MongoClient.connect() 返回的是一个promise对象 因此可以使用async 和 await
  // console.log(MongoClient.connect(url)); //（MongoClient.connect(url) 返回一个Promise对象）
  const client = await MongoClient.connect(url); //链接数据库

  const db = client.db(dbName); //匹配数据库
  return {
    client,
    db
  }
}

// 数据库之 查找 find
async function find(cloName, query = {}, options = {}) { //参数1：数据库中的集合（表） 参数2：操作的数据库语句 参数3：配置参数 
  //1:链接数据库
  let {
    db,
    client
  } = await connect();
  //2:匹配数据库集合 
  let collection = db.collection(cloName);

  const datalen = await collection.count().then(data => data)
  // console.log("我是总数", datalen);
  //3：最后根据所选的集合 操作数据库 查询操作
  let result = collection.find(query, {
    projection: { //查询的时候 过滤字段！ 密码不返回给前端！
      password: false
    }
  });

  if (query._id && typeof query._id === 'string') {
    query._id = ObjectId(query._id);
  }

  //分页功能 
  // 需要的参数：页数 限制显示的多少页 跳过的数据条数 eg: 1页 - 0~5 - 0条 2页 - 5~10条 - 5条 3页 - 10~15 - 10条
  //01：查询跳过的记录
  if (options.skip) {
    result = result.skip(options.skip) //result.skip()方法 设置跳过记录 
  }
  //02：设置显示的条数
  if (options.limit) {
    result = result.limit(options.limit)
  }
  //排序的功能
  if (options.sort) { //前端传来的之 ["peice"] 或者["price","1"] 第一种为默认的降序 第二种为升序
    let key, val;
    key = options.sort[0]; //拿到key值 
    if (options.sort.length > 1) {
      val = options.sort[1] * 1;
    } else {
      val = -1;
    }
    result = result.sort({ //对象[字符串] 
      [key]: val
    })
  }

  // 模糊查询
  // db.user.find({'username':{'$regex':'s',"$options":'i'}})
  if (query.name) {
    const font = query.name
    let result = collection.find({
      'name': {
        '$regex': font,
        "$options": 'i'
      }
    });
    result = await result.toArray();
    return {
      result
    };
  }


  // 关于订单搜索
  if (query.orderNum) {
    const font = query.orderNum

    let result = collection.find({
      'orderNum': {
        '$regex': font,
        "$options": 'i'
      }
    });
    result = await result.toArray();
    return {
      result
    };
  }

  // 关于用户搜索
  // if (query.username) {
  //   const font = query.username

  //   let result = collection.find({
  //     'username': {
  //       '$regex': font,
  //       "$options": 'i'
  //     }
  //   });
  //   result = await result.toArray();
  //   return {
  //     result
  //   };
  // }

  async function queryName(query, params) { //query是morder.js传递过来的query
    const font = params

    for (var key in query) {
      queryCheck = key
    }
    let result = collection.find({
      queryCheck: {
        '$regex': font,
        "$options": 'i'
      }
    });
    result = await result.toArray();
    // console.log("我是res2", result);
    return result;
  }

  result = await result.toArray(); //返回的是一个数组的形式！给与前端！
  //最后 客户端关闭数据库  
  client.close();
  return {
    result,
    datalen
  } //返回查询结果 一个promise对象
}


// 数据库之 增 insert
//数据库操作之 增函数 参数1：集合 参数2：data数据（增的数据）
async function insert(colName, data) {
  //1:链接数据库 并且把db 和 client在链接数据库中导出 
  let {
    db,
    client
  } = await connect()

  //2：匹配数据库集合
  const collection = db.collection(colName);
  //3：需要判断传入的数据 是一条还是多条 一条就是insertOne 多条就是insertMany 在集合之中插入数据 
  const result = await collection[Array.isArray(data) ? "insertMany" : "insertOne"](data);

  //3：关闭数据库连接
  client.close();
  return result
}


// 数据库之 删 
// db.集合的名称.deleteMany({name:"ppp"})
async function remove(colName, query) {
  //1：链接数据库
  let {
    db,
    client
  } = await connect()
  //根据id删除 数据

  if (query._id && typeof query._id === 'string') {
    query._id = ObjectId(query._id);
  }
  //批量删除的时候 query是数组 需要遍历转化id
  // console.log("我query", query._id.$in);
  else if (query._id.$in.length >= 1)
    query._id.$in = query._id.$in.map(item => {
      if (item && typeof item === 'string') {
        item = ObjectId(item);
      }
      // console.log("我是item", item, typeof item);
      return item
    })


  console.log("我是mongo", query);
  //2：匹配集合
  let collection = db.collection(colName);

  let result = await collection.deleteMany(query);

  // result = result.toArray();
  client.close();
  return result;
}

//数据库之 改
// db.集合的名称.updateOne( {name:"fqniu",age:25 } , { $set : { name:"牛牛",age:18} } );
//根据id来修改 数据库中的data
async function updata(colName, query, newData) { //newData{$set:{price:200,qty:2},$inc:{view:1}}
  let {
    db,
    client
  } = await connect();
  let collection = db.collection(colName);

  //根据id删除 数据
  if (query._id && typeof query._id === 'string') {
    query._id = ObjectId(query._id);
  }

  let result = await collection.updateMany(query, newData);
  // console.log("我是更新的result" + result);
  return result;
}

//把增删改查 导出  在引入这个工具函数时候 调用！
module.exports = {
  insert,
  find,
  remove,
  updata
}

token.js （token的创建和校验）

const jwt = require('jsonwebtoken');

const privateKey = 'fqniu';

//创建一个token函数！
function create(data = {}, expiresIn = '2h') {
  const token = jwt.sign({
    ...data
  }, privateKey, {
    // token有效期
    expiresIn
  });

  return token;
}

//验证token是否存在！
function verify(token) {
  let result;
  try {
    jwt.verify(token, privateKey); //验证这个token 假如存在，result为true！
    result = true;
  } catch (err) {
    result = false
  }

  return result;
}


module.exports = {
  create,
  verify
}

tools.js（封装工具函数）

const crypto = require('crypto');

// 返回数据处理函数
function formatData({
  code = 1,
  data = [],
  msg = 'success',
  datalen = "",
  kucun = ""
} = {}) {

  if (code === 0) {
    msg = 'fail';
  }

  return {
    code,
    data,
    msg,
    //数据的长度
    datalen,
    // 库存
    kucun
  }
}

// 加密函数
function md5(data, privateKey = 'fqniu') {

  const hash = crypto.createHash('md5');
  hash.update(data + privateKey); // 加盐 盐值
  const result = hash.digest('hex');

  return result;
}

module.exports = {
  formatData,
  md5
}