wechat,wechat-api,mongoose,winston等的使用

Posted 2020-10-23 maoriaty

目录：

app.js

const express = require(\'express\');
const app = express();
const wechat = require(\'wechat\');
const config = require(\'./conf/config\');
require(\'./db/mongo\');
const userService = require(\'./service/userService\');
const locationService = require(\'./service/locationService\');
const logger = require(\'./util/logger\');

app.use(config.path,wechat(config.wechat).text(function(message, req, res, next){
    logger.info(\'文本信息：\' + JSON.stringify(message));
    if(message.Content == \'1\'){
        res.reply(\'kkkkkkkkkkkkkkkdkdkddkkdk\');
    }
}).event(function(message, req, res, next){
    logger.info(\'事件消息：\' + JSON.stringify(message));
    if(message.Event === \'LOCATION\'){
        userService.addUser(message.FromUserName, function(err, user){
            if(err) logger.error(\'LOCATION saveOrUpdateUser error: %s\', err)
            locationService.save(message,function(err, location){
                logger.info(\'location is : %s\', location)
                res.reply({type: \'text\', content: location});
                // res.reply(\'\');
            })
        })
    }else if(message.Event === \'subscribe\'){
        res.reply(\'Welcome to subscribe!\')
    }
})
.middlewarify());

const server = app.listen(18080, () => console.log(\'port is %s\',server.address().port));

config.js

const config = {
    mongo: {
        connectStr: \'mongodb://user:123456@47.52.199.163:27017/test\'
    },
    wechat: {
        token: \'maoriaty1\',
        appid: \'wx1af02f9490ff3e98\',
        encodingAESKey: \'\',
        checkSignature: false
    },
    appSecret: \'92bd3a03d76da03abba6b7d1c25c23a7\',
    path: \'/wxService\',
    logStdout: true //是否禁止输出debug日志
}

module.exports = config;

mongo.js

const config = require(\'../conf/config\');
const mongoose = require(\'mongoose\');

module.exports = (function(){
    mongoose.connect(config.mongo.connectStr, {auto_reconnect: true, native_parser: true}, function() {
        console.log(\'mongodb connected\');
    })
    mongoose.set(\'debug\', false);
    connection = mongoose.connection;
    connection.on(\'error\', function(err) {
        console.log(new Date() + \'connect error :\' + err);
    });
    connection.on(\'close\', function(){
        console.log(new Date() + \'connection close retry connect\');
    });
    return connection;
})();

locationModel.js

const mongoose = require(\'mongoose\');
const Schema = require(\'mongoose\').Schema;

const location = new Schema({
    openId: {type: String, required: true},
    loc: {type: [Number], required: true, index: \'2dsphere\', sparse: true},
    precision: {type: Number, required: true, default: 0},
    createTime: {type: Date, required: true, default: Date.now},
    __v: {type: Number, select: false}
},{collection: \'location\'});

module.exports = locationModel = mongoose.model(\'location\', location);

userModel.js

const mongoose = require(\'mongoose\');
const Schema = require(\'mongoose\').Schema;

const sexStates = [0, 2, 3]; //0-未知，1-男，2-女
const User = new Schema({
    openId: {type: String, unique: true, required: true, index: true},
    nickname: {type: String},
    sex: {type: Number, enum: sexStates},
    birthday: {type: Date},
    astroId: {type: String},
    province: {type: String, trim: true},
    city: {type: String, trim: true},
    conuntry: {type: String, trim: true},
    headimgurl: {type: String},
    privilege: {type: Array},
    createTime: {type: Date, default: Date.now, require: true},
    lastUpdateTime: {type: Date, default: Date.now, require: true},
    __v: {type: Number, select: false}
},{collection: \'user\'});

module.exports = userModel = mongoose.model(\'user\', User);

locationService.js

const locationModel = require(\'../model/locationModel\')

exports.save = function(message, callback){
    let location = new locationModel({
        openId: message.FromUserName,
        loc: [message.Longitude, message.Latitude],
        precision: message.Precision,
        createTime: new Date(parseInt(message.CreateTime) * 1000)
    })
    location.save(function(err, loc){
        if(err) console.log(\'save location error : %s\', err)
        if(callback && callback instanceof Function){
            callback(err, loc)
        }
    })
}

userService.js

const config = require(\'../conf/config\');
const userModel = require(\'../model/userModel\');
const wechatApi = require(\'../util/wechatApi\');
const API = wechatApi.API;

exports.addUser = function(openId, callback){
    callback = callback || function(){};
    userModel.findOne({openId: openId}, function(err, user){
        if(err) return callback(err)
        if(user){
            return callback(null, user);
        }else {
            API.getUser(openId, function(err2, newUser){
                if(err2) return callback(err2)
                user = new userModel({
                    openId: newUser.openid,
                    nickname: newUser.nickname,
                    sex: newUser.sex,
                    province: newUser.province,
                    city: newUser.city,
                    country: newUser.country,
                    headimgurl: newUser.headimgurl,
                    privilege: newUser.privilege,
                    createTime: new Date(),
                    lastUpdateTime: new Date()
                })
                user.save(function(err3){
                    if(err3) return callback(err3)
                    callback(null, user)
                })
            })
        }
    })
}

logger.js

const winston = require(\'winston\');
const moment = require(\'moment\');
const config = require(\'../conf/config\');
let customLevels = {
    levels: {
        debug: 0,
        info: 1,
        warn: 2,
        error: 3
    },
    colors: {
        debug: \'blue\',
        info: \'green\',
        warn: \'yellow\',
        error: \'red\'
    }
};

// create the main logger 等级高的包含等级低的输出日志
module.exports = logger = new (winston.Logger)({
    level: \'debug\',
    levels: customLevels.levels,
    transports: [
        new (winston.transports.Console)({
            level: \'error\',
            levels: customLevels.levels,
            timestamp: function(){return moment().format(\'YYYY-MM-DD HH:mm:ss\')},
            colorize: true,
            silent: config.logStdout
        }),
        new (winston.transports.File)({
            name: \'info\',
            filename: \'./logs/info.log\', //项目根目录
            maxsize: 1024 * 1024 * 50, //50M
            level: \'info\',
            levels: customLevels.levels,
            timestamp: function(){return moment().format(\'YYYY-MM-DD HH:mm:ss\')},
            json: false
        })
    ]
})
winston.addColors(customLevels.colors);

wechatApi.js

const config = require(\'../conf/config\');
const mongoose = require(\'mongoose\');
const Schema = require(\'mongoose\').Schema;
const wechatApi = require(\'wechat-api\');
const _ = require(\'underscore\');

let Token = new Schema({
    accessToken: {type: String, required: true},
    expireTime: {type: Number, required: true},
    createTime: {type: Date, default: Date.now, required: true},
    expireAt: {type: Date, required: true, expires: 0, select: false}, //过期自动删除
    __v: {type: Number, select: false}
},{collection: \'token\'});
let tokenModel = mongoose.model(\'token\', Token);

let BaseToken = {
    getWXToken: function(callback){
        tokenModel.findOne({},callback);
    },
    saveWXToken: function(token, callback){
        let update = _.clone(token);
        update.createTime = new Date();
        update.expireAt = new Date(update.expireTime);
        tokenModel.findOneAndUpdate({}, update, {upsert: true}, function(err){
            if(err) console.log(\'save token error : %s\', err)
            callback(err)
        })
    }
}

module.exports.API = new wechatApi(config.wechat.appid, config.appSecret, BaseToken.getWXToken, BaseToken.saveWXToken);