mongoose koa nuxt 记录

mongoose 

查询过滤
  const results = await User.find({
        "$and": [{
            "date": {
                "$gt": "2019-11-26 14:19:31"
            }
        }, {
            "date": {
                "$lt": "2019-11-26 14:52:15"
            }
        }]
    }, 'uid age')
查询条件date是2019-11-26 14:19:31 到 2019-11-26 14:52:15 区间的值（小于等于是$lte 大于等于是$gte） 并且返回uid age字段其余不返回（findOne，findById类似）

mongoose常用操作(你当然也可以用原生的mongodb 不过没必要重复造轮子)
models = 》 User
import mongoose from 'mongoose';
const Schema = mongoose.Schema
const UserSchema = new Schema({
    uid: {
        type: Number,
        unique: true,
        index: true
    },
    user: {
        type: String,
        unique: true,
        index: true
    },
    password: String,
    status: {
        type: Boolean,
        default: true
    }
})
export default mongoose.model('User', UserSchema)
user.js
 let result = []
//Model.find(query, fields, options, callback)
 result = await User.find()//返回User的全部数据   
 result = await User.find({
                user: 'zhang',
                password: '123456'
            }, { _id: 0, __v: 0, password: 0 },function(err.doc){console.log(doc)})//返回User中user为'zhang',password为'123456' 并且返回的结果中除去_id _v password键名的全部数据   docs 是查询的结果数组
findOne是只返回一个结果即第一个
findById是根据id查询
User.findById(obj._id, function (err, doc){
  // doc 是单个文档
});

 await User.find(}, function(err, doc) { }).count() //符合条件的总数

  result = await User.find({}, { _id: 0 ,password:0}) //过滤_id password
          //  .where('level').gte(6) //level的值得大于等于6
            .where({
                'level': {
                    $gt: 3,
                    $lt: 6
                },
                'user': /zhang/,  //模糊搜索zhang
             })//level的值得:3<level<6
            .skip(0 * 5)   //skip是分页 参数格式是 pageNo*pageSize
            .limit(5)       //limit是显示几个 参数 pageSize
            .sort({ 'uid': -1 }) //uid大小排序

methods方法 statics 静态方法
var animalSchema = new Schema({ name: String, type: String });

    animalSchema.methods.findSimilarTypes = function(cb) {
        return this.model("Animal").findOne({ type: 'dog' }, cb);
    };
    animalSchema.statics.findByName = function(cb) {
        return this.model("Animal").findOne({ type: 'dog' }, cb);
    };

    var Animal = mongoose.model('Animal', animalSchema);
    var dog = new Animal({ type: 'dog' });
    // // dog.save()
    dog.findSimilarTypes(function(err, dogs) {
        console.log(dogs.type); // dog
    });
    Animal.findByName(function(err, dogs) {
        console.log(dogs.type);
    });

 

分页查询
数据格式
[{
    _id: 5ddde8a2ea18323164978d2a,
    user: 'zhang10',
    uid: 10,
    email: '',
    date: '2019-11-27 11:08:18',
    level: 1
  }]

router.post('/queryUsers', async(ctx) => {
    let query = { }
    let pageSize = 10
    let pageNo = 1

    let levelList = []
    let level1 = 0,
        level2 = 0,
        level3 = 0,
        level4 = 0,
        level5 = 0,
        level6 = 0



    if (ctx.request.body.pageSize) {
        pageSize = ctx.request.body.pageSize
    }
    if (ctx.request.body.pageNo) {
        pageNo = ctx.request.body.pageNo
    }

    if ((ctx.request.body.startDate && ctx.request.body.endDate)) {
        // pageNo = 1
        let q = query["$and"] ? query["$and"] : ''
        query["$and"] = [...q, {
            "date": {
                "$gt": ctx.request.body.startDate
            }
        }, {
            "date": {
                "$lt": ctx.request.body.endDate
            }
        }]
    }


    if (ctx.request.body.searchName) {
        // pageNo = 1
        let q = query["$and"] ? query["$and"] : ''
        query["$and"] = [...q, {
            // "user": `zhang` 具体搜索
            "user": {
                $regex: ctx.request.body.searchName,
                $options: '$i'
            }
        }]
    }

    if (ctx.request.body.authority) {
        // pageNo = 1
        let q = query["$and"] ? query["$and"] : ''
        query["$and"] = [...q, {
                "level": ctx.request.body.authority // 具体搜索
            }]
    }

    const results = await User.find(query, 'user  uid  level  date  email')
        .skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize))
    const total = await User.find(query).count()
        // const total = results.length
    level1 = await User.find(query).where({ "level": 1 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    level2 = await User.find(query).where({ "level": 2 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    level3 = await User.find(query).where({ "level": 3 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    level4 = await User.find(query).where({ "level": 4 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    level5 = await User.find(query).where({ "level": 5 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    level6 = await User.find(query).where({ "level": 6 }).skip((pageNo - 1) * pageSize)
        .limit(Number(pageSize)).count()
    levelList = [
        ["level1", level1],
        ["level2", level2],
        ["level3", level3],
        ["level4", level4],
        ["level5", level5],
        ["level6", level6]
    ]

    console.log(results)
    console.log(results.length)
    console.log(total)

    try {
        ctx.body = {
            code: 200,
            msg: '请求成功',
            data: {
                result: results ? results : [],
                levelList: levelList ? levelList : [],
                total: total ? total : 0
            }
        }
    } catch (error) {

    }
})

$or 或关系
$nor 或关系取反
$gt 大于
$gte 大于等于
$lt 小于
$lte 小于等于
$ne 不等于
$in 在多个值范围内
$nin 不在多个值范围内
$all 匹配数组中多个值
$regex 正则，用于模糊查询
$size 匹配数组大小
$maxDistance 范围查询，距离（基于LBS）
$mod　　　　 取模运算
$near 邻域查询，查询附近的位置（基于LBS）
$exists 字段是否存在
$elemMatch 匹配内数组内的元素
$within 范围查询（基于LBS）
$box 范围查询，矩形范围（基于LBS）
$center 范围醒询，圆形范围（基于LBS）
$centerSphere 范围查询，球形范围（基于LBS）
$slice 查询字段集合中的元素（比如从第几个之后，第N到第M个元素

 

 koa

koa2参数获取
get 在请求参数里
ctx.request.query.name;
post 在请求体里
ctx.request.body.name;
获取参数以及设置默认值
post    const { pageSize = 10, pageNo = 1, user, password } = ctx.request.body
get     const { pageSize = 10, pageNo = 1, user, password } = ctx.request.query
{
 user:'zhang'
}
console.log(pageSize, pageNo, user, password)
// 10 1 zhang undefined
未传参的处理
 if (password == undefined) {
        ctx.body = {
            code: 200,
            msg: "password不能为空",
            result: {}
        }
        return
    } else {
        // other operat
    }
    ctx.body = {
        code: 200,
        msg: "请求成功",
        result: { pageSize, pageNo, user, password }
    }


抛出错误
       ctx.status = 500
或者   ctx.throw(5000);
或者   throw new Error(500, '信息有误，请重填')
 


中间件的使用 
必须使用next()连接不然不执行下一个中间件即app.use(()=>{})里面的内容 中间件的执行顺序是洋葱模型 即中间件如果有await的话先执行await的内容然后在执行再从下到上执行
 app.use((ctx, next) => {
            next()
        })


koa为什么有很多的async和await?可以不用或者有别的方案吗（可以 有）
async函数是es7的异步函数，await只能在其之内 其他地方会出错 await是等待异步操作结束的意思
你可能会觉得你有时候用不用await好像没有区别 有两个可能 
第一 你的代码中并没有异步的操作 比如数据请求（koa操作mongodb也是异步的）
第二 你的异步请求非常快
你的数据请求了api 然后后面的代码逻辑是和数据请求的结果是有关联的这时候你没有使用async await等待异步请求完成就继续其他操作是会出现问题的 
你当然也可以不使用async和await，async和await只是不让你再用回调的方式而已 你不用就得使用then()操作异步请求的结果，这看起来相比之下会很不优雅，async await会返回prosime对象

中间件验证
// tokenValid.js
const jwt = require('jsonwebtoken')
module.exports = function(req) {
    const token = req.headers['authorization'];
    console.log("token的值：")
    console.log(token)
    return jwt.verify(token, 'xxxxxxxxxxxx', function(err, decoded) {
        if (err) {
            return {
                success: false,
                data: {
                    code: -101,
                    message: 'Failed to authenticate token.'
                }
            }
        }
        return {
            success: true,
        }
    })
}

user.js

const tokenValid = require('./tokenValid');
const checkLogin = async(ctx, next) => {
    if (['/user/login', '/user/loginout'].indexOf(ctx.url) !== -1) {
        await next();
        return;
    }
    const isLogin = await tokenValid(ctx.request); //
    // console.log(ctx.request)
    console.log("login vallid返回值:")
    console.log(isLogin)
    if (!isLogin.success) {
        ctx.response.status = 401;
        // ctx.response.body = 'token Vaild Error';
        // ctx.throw(401, 'token Vaild Error');
        ctx.body = {
            code: 401,
            msg: 'token Vaild Error'
        }
        return
    }
    await next();
}

router.use(checkLogin);

nuxt 

nuxt中ssr服务器异步请求的时候asyncData的时候token处理
因为服务器端没有window对象所以不能使用缓存的方式axios带上token  可以通过设置cookie(js-cookie) 即设置cookie的时候服务端是可以获取到的(在asyncData(({app})=>{}) 对象里面获取cookie对象) 
跳转的时候用router对象 用window会报错
数据请求
const Cookie = require("js-cookie");
async asyncData({ app, params, store, require }) {
    let { data } = await post("http://127.0.0.1:3000/shop/queryShop", {}, app);
    const token = {
      token: "this is asyncData post token ####"
    };
    // store.commit("setToken", token);
     Cookie.set("token", token);
    return { demo: store.state.token };
  }

login.vue
登陆成功后设置
            Cookie.set("token", res.token, { expires: 2*(60 * 60 * 1000) });
            Cookie.set("userInfo", res.result.user, { expires:  2*(60 * 60 * 1000) });

待更新.....