// 靜態目錄及緩存設置

config.static = {

    prefix: '/', //靜態化URL  我這裏默認網站根目錄（項目需要）

    dir: path.join(appInfo.baseDir, 'app/public'), // 靜態文件夾地址 可以設置多個 可以簡寫為 ：['app/public','app/public1']

    dynamic: true, //是否緩存靜態資源

    preload: false, //啓動項目開啓緩存

    // maxAge: 31536000,

    maxAge: 0, //緩存時間 開發建議設0 跳坑

    buffer: true, //是否緩存到内存 默認prod 緩存

};

    config.bodyParser = {

        enable: true,

        // @see https://github.com/hapijs/qs/b ... %23L8 for more options

        queryString: {

            arrayLimit: 100,

            depth: 5,

            parameterLimit: 1000,

        },

        enableTypes: ['json', 'form', 'text'],

        extendTypes: {

            text: ['text/xml', 'application/xml'],

        },

    };

同样的方法可以处理其他的任何格式

npm i egg-mongoose --save

exports.mongoose = {

  enable: true,

  package: 'egg-mongoose',

};

exports.mongoose = {

  url: 'mongodb://127.0.0.1/example',

  options: {},

  plugins: [createdPlugin, [updatedPlugin, pluginOptions]],

};

exports.mongoose = {

  clients: {

    // clientId, access the client instance by app.mongooseDB.get('clientId')

    db1: {

      url: 'mongodb://127.0.0.1/example1',

      options: {},

    },

    db2: {

      url: 'mongodb://127.0.0.1/example2',

      options: {},

    },

  },

};

module.exports = app => {

    const mongoose = app.mongoose;

    const Schema = mongoose.Schema;

    const {

        ctx,

        helper,

        service

    } = app.createAnonymousContext();

    const {

        objToQuery

    } = helper;

    const UserAddressSchema = new Schema({

        // 用户id

        _uid: {

            type: Schema.Types.ObjectId,

            ref: 'account_user',

            required: true,

            index: true

        },

        default_id: '',

        addresses: [{

            // 数组ID

            _id: mongoose.Schema.Types.ObjectId,

            // 收件人名称

            name: '',

            // 聯係電話

            phone: '',

            // 省市区地址

            Region: '',

            // 城市id

            RegionId: '',

            // 郵編

            postcode: '',

            // 详细地址

            location: '',

            // 地址标签

            tag: ''

        }]

    }, {

        timestamps: {

            createdAt: 'created',

            updatedAt: 'updated'

        }

    });

    UserAddressSchema.statics = {

        // 添加地址

        addAddress: async function(_uid, BODYS) {

            const { isDefault } = BODYS;

            const _id = mongoose.Types.ObjectId();

            const MODEL = this.findOneAndUpdate({

                _uid

            }, {

                $push: {

                    'addresses': {

                        ...BODYS,

                        _id

                    }

                },

                ...isDefault && { default_id: _id }

            }, {

                new: true,

                fields: 'addresses default_id -_id'

            })

            try {

                const DATAS = await MODEL;

                return !!DATAS.addresses.length

            } catch (error) {

                console.log(error)

                return error

            }

        },

        // 删除地址

        deleteAddress: async function(_uid, _id) {

            const MODEL = this.findOneAndUpdate({

                _uid

            }, {

                $pull: {

                    'addresses': {

                        _id

                    }

                }

            })

            try {

                const DATAS = await MODEL;

                console.log(DATAS)

                return DATAS

            } catch (error) {

                console.log(error)

                return error

            }

        },

        // 更新地址

        updateAddress: async function(_uid, BODYS) {

            const { _id, isDefault } = BODYS;

            delete BODYS._id;

            delete BODYS.isDefault;

            const MODEL = this.findOneAndUpdate({

                _uid,

                'addresses._id': _id

            }, {

                $set: {...objToQuery(BODYS, 'addresses')

                }

            }, {

                fields: 'addresses default_id -_id'

            });

            try {

                // 修改数据

                const DATAS = await MODEL;



                // 修改默认

                !!isDefault && await this.setDefault(_uid, isDefault, _id);

                return !!DATAS.addresses.length

            } catch (error) {

                console.log(error)

                return error

            }

        },

        // 設置默認

        setDefault: async function(_uid, isDefaults, _id) {

            const default_id = !!isDefaults ? _id : '';

            const MODEL = this.findOneAndUpdate({ _uid }, { default_id });

            try {

                const MB = await MODEL;

                return MB

            } catch (error) {

                console.log(error);

                return error

            }

        },

        // 获取单一地址

        getOne: async function(_uid, _id) {

            const MODEL = this.findOne({

                _uid,

            }, {

                'addresses': {

                    '$elemMatch': {

                        _id

                    }

                }

            }, {

                fields: 'addresses default_id -_id'

            });

            console.log(_id)

            try {

                if (_id !== "default") {

                    const DATAS = await MODEL;

                    return DATAS.addresses[0]

                }

            } catch (error) {

                console.log(error)

                return error

            }

        },

        // 获取全部地址

        getAllAddress: async function(_uid, query) {

            const MODEL1 = this.findOneAndUpdate({ _uid }, { _uid, query }, { new: true, upsert: true, fields: 'addresses default_id -_id' });

            // const MODEL2 = this.create({ _uid })

            try {

                const DATAS = await MODEL1;

                return DATAS

                    // console.log(!!DATAS._uid)

                    // return DATAS._uid ? DATAS.addresses : (await MODEL2).addresses

            } catch (error) {

                console.log(error)

                return error

            }

        },

        // 獲取默認地址

        getDefaultAddress: async function(_uid) {

            const MODEL = this.findOne({ _uid }, {}, {

                fields: 'default_id -_id'

            });

            try {

                const { default_id } = await MODEL;

                return await this.getOne(_uid, default_id)

            } catch (error) {

                console.log(error);

                return error

            }

        }

    }

    return mongoose.model('user_address', UserAddressSchema);

}

const indexController = require('../index');

class invoiceAddressController extends indexController {

constructor(ctx) {

super(ctx);

this.MODEL = ctx.model.User.Address;

};

/**

* @name  获取所有用户地址列表

* 

*/

async index() {

const ctx = this.ctx;

const isDefault = Object.keys(ctx.query).includes('default');

const RESULT = !!isDefault ?

await this.MODEL.getDefaultAddress(ctx._uid()) :

await this.MODEL.getAllAddress(ctx._uid());

ctx.body = RESULT

};

/**

* @name 获取用户地址列表

*/

async show() {

const ctx = this.ctx;

const RESULT = await this.MODEL.getOne(ctx._uid(), ctx.params.id);

ctx.body = RESULT

};

/**

* @name 创建地址

*/

async create() {

const ctx = this.ctx;

const {

name,

phone,

postcode,

Region,

RegionId,

location,

isDefault,

tag

} = ctx.request.body;

const BODYS = this.DUFN({

name,

phone,

postcode,

Region,

RegionId,

location,

isDefault,

tag

})

const RESULT = await this.MODEL.addAddress(ctx._uid(), BODYS);

ctx.body = RESULT

};

/**

* @name 更新

* 

*/

async update() {

const {

ctx

} = this;

const _id = ctx.params.id

const {

name,

phone,

postcode,

Region,

RegionId,

location,

isDefault,

tag,

action

} = ctx.request.body;

const BODYS = this.DUFN({

name,

phone,

postcode,

Region,

RegionId,

location,

isDefault,

tag,

action,

_id

})

const RESULT = action === 'setDefault' ?

await this.MODEL.setDefault(ctx._uid(), isDefault, _id) :

await this.MODEL.updateAddress(ctx._uid(), BODYS);

ctx.body = RESULT

};

/**

* @name 删除

*/

async destroy() {

const ctx = this.ctx;

const RESULT = await this.MODEL.deleteAddress(ctx._uid(), ctx.params.id);

ctx.body = RESULT

}

}

module.exports = invoiceAddressController

router.resources('user_address', '/user/address', app.jwt, controller.user.address);

npm i egg-jwt --save

    config.jwt = {

        secret: appInfo.name + '_1539582326426_4353',

        unless: {

            path: 

        }

    };

exports.jwt = {

    enable: true,

    package: "egg-jwt"

};

class jwtService extends Service {

    constructor(ctx) {

        super(ctx)

    };

    // jwt 加密 使用HS256

    /**

     * 

     * @param {Object} parmas 需封装的参数

     * @param {String} type 类型  default:'web' ->24hrs

     * @param {Boolean} expires 是否设置过期  default:true

     */

    async sign(parmas, type = 'web', expires = true) {

        const app = this.app;

        return await app.jwt.sign({ ...parmas }, app.config.jwt.secret, { algorithm: 'HS256', ...(expires && { expiresIn: `${type === 'web' ? '24 hrs' : '30 days'}` }) })

    }

    // JWT 解密

    async verify(token) {

        const { app } = this;

        return await app.jwt.verify(token, app.config.jwt.secret, { algorithm: 'HS256' })

    }

}

module.exports = jwtService

class weChatTemplateService extends indexService {

    constructor(ctx) {

        super(ctx);

        this.userMODEL = ctx.model.Account.User;

        this.tokenSERVICE = ctx.service.account.jwt

    };

    ...

    setToken(params, other) {

        return { 'token': this.tokenSERVICE.create(params), ...other }

    };

    ...

}

module.exports = {

    isAdmin() {

        return this.state.user.group === 1 ? false : true;

    },

    _uid() {

        return this.state.user._id

    }

};

npm install  egg-cors --save

exports.cors: {

    enable: true,

    package: 'egg-cors'

}

config.security = {

　　csrf: {

　　　　enable: false

　　},

　　domainWhiteList: [ '*' ]

};



config.cors = {

    origin: '*',

    allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH,OPTIONS'

};

'use strict';

const Controller = require('egg').Controller;

// 文件存储

const fs = require('fs');

const path = require('path');

const awaitWriteStream = require('await-stream-ready').write;

const sendToWormhole = require('stream-wormhole');



class UploadController extends Controller {

    /**

     * 

     * @param {*} stream  传入的Buffer流

     * @param {*} paths 保存的路径

     * @param {*} multiple 是否多文件

     * @param {*} files 多文件返回

     */

    async upload(stream, paths = "app/public/img", multiple = false, files = []) {

        const filename = Math.random().toString(36).substr(2) + new Date().getTime() + path.extname(stream.filename).toLocaleLowerCase();

        const target = path.join(this.config.baseDir, paths, filename);

        const writeStream = fs.createWriteStream(target);

        try {

            await awaitWriteStream(stream.pipe(writeStream));

            return !!multiple ? files.push(filename) : filename;

        } catch (err) {

            await sendToWormhole(stream);

            return { code: 422, message: '上传失败，请重试！' }

        }

    };

    // 单文件

    async create() {

        const ctx = this.ctx;

        // 获取流

        const stream = await ctx.getFileStream();

        // 生成文件名

        const filename = Math.random().toString(36).substr(2) + new Date().getTime() + path.extname(stream.filename).toLocaleLowerCase();

        // pipe流写入信息

        const target = path.join(this.config.baseDir, 'app/public/img', filename);

        const writeStream = fs.createWriteStream(target);

        try {

            // 保存

            await awaitWriteStream(stream.pipe(writeStream));

        } catch (err) {

            // 保存失败销毁stream 不然接口会pending到超时

            await sendToWormhole(stream);

            this.ctx.body = { code: 422, message: '上传失败，请重试！' }

            throw err;

        }

        this.ctx.body = {

            data: filename

        };

    };

    // 多文件

    async creates() {

        const ctx = this.ctx;

        // 获取文件流组

        const streams = ctx.multipart();

        let stream;

        // 保存返回的文件信息

        let files = [];

        // 其他form 参数

        let fields = {}

        while ((stream = await streams()) != null) {

            // 检查是否有其他参数 如果有写入 这里做案例 不做处理

            if (stream.length) {

                fields[stream[0]] = stream[1]

            } else {

                // 空文件处理

                if (!stream.filename) {

                    return;

                }

                // 设置文件名称

                const filename = Math.random().toString(36).substr(2) + new Date().getTime() + path.extname(stream.filename).toLocaleLowerCase();

                // pipe 设置

                const target = path.join(this.config.baseDir, 'app/public/img', filename);

                const writeStream = fs.createWriteStream(target);

                try {

                    // 保存

                    await awaitWriteStream(stream.pipe(writeStream));

                    // 写入数组

                    files.push({ filename, path: `/img/${filename}` })

                } catch (err) {

                    await sendToWormhole(stream);

                    this.ctx.body = { code: 422, message: '上传失败，请重试！' }

                    throw err;

                }

            }

        }

        this.ctx.body = {

            data: { files, fields }

        };

    }

}



module.exports = UploadController

有一种函数叫偏函数( 左倾 )，其原理是将一些函数组合封装到一个函数中，调用时可以按顺序实现全部功能。使用时大多需要配合reduceRight

const compose = (...args) => x => args.reduceRight((result, cb) => cb(res), x);

db.dbname.aggregate([

    // _id 以你可以排除认定为重复kv

    {

        $group:{_id:{title:'$title'},count:{$sum:1},dups:{$addToSet:'$_id'}}

    },

    {

        $match:{count:{$gt:1}}

    }



    ]).forEach(function(it){



         it.dups.shift();

            db.dbname.remove({_id: {$in: it.dups}});



    });

当然数据太大的时候配合 limit 来选取

'use strict';



const Controller = require('egg').Controller;



class IndexController extends Controller {

    /**

     * @name constructor

     * 

     * @param {*} ctx 

     * @param {Function}    DuFn     清理空字段函数

     * @param {Object}      auth     用户JWT

     * 

     */

    constructor(ctx) {

        super(ctx);

        this.auth = ctx.state.user;

        this.DUFn = ctx.helper.deleteUndefined;

        this.QPFn = ctx.helper.queryParamFn;

        this.SERVICE = ctx.service.openstack.compute.index;

        this.serverSERVICE = ctx.service.openstack.server.servers

    }

    /**

    * name 计算相关配额

    * 

    * @description 

    * 

    * @example  GET /openstack/blcokstorage/limits

    * 

    * @return {Object}

    *  - cores                VCPU数量可用                  颗

    *  - floatingIps          自定义IP可用                  个

    *  - instances            N/A                          

    *  - RAM                  内存可用量                    MB

    *  - securityGroups       实例数量                      个

    *  - serverGroups         实例分组数量                  个

    */

    async limits() {

        const { ctx, service } = this;

        // if (!ctx.isAdmin()) return;

        const DATAS = await this.SERVICE.limits(this.auth.id, ctx.isAdmin());

        ctx.body = DATAS

    }

}



module.exports = IndexController;

'use strict';

const ServerIndex = require('../index')

class ComputeIndexService extends ServerIndex {

    constructor(ctx) {

        super(ctx);

        this.actions = ':8774/v2.1/'

    };

    // 获取服务器相关配额

    async limits(_ucid, isAdmin) {

        try {

            const DATAS = await this.OSAJax(`${this.actions}limits`, {

                ...!isAdmin && { _ucid }

            });

            const { maxImageMeta, maxPersonality, maxPersonalitySize, maxSecurityGroupRules, maxSecurityGroups, maxServerGroupMembers, maxServerGroups, maxServerMeta, maxTotalCores, maxTotalFloatingIps, maxTotalInstances, maxTotalKeypairs, maxTotalRAMSize, totalCoresUsed, totalFloatingIpsUsed, totalInstancesUsed, totalRAMUsed, totalSecurityGroupsUsed, totalServerGroupsUsed } = (await DATAS).limits.absolute

            return {

                data: {

                    maxTotalKeypairs,

                    'cores': maxTotalCores - totalCoresUsed,

                    'RAM': maxTotalRAMSize - totalRAMUsed,

                    maxTotalInstances,

                    totalInstancesUsed,

                    'instances': maxTotalInstances - totalInstancesUsed,

                    maxServerGroups,

                    'serverGroups': maxServerGroups - totalServerGroupsUsed,

                }

            }

        } catch (error) {

            return error

        }

    }

}



module.exports = ComputeIndexService;

'use strict';



const Controller = require('egg').Controller;



class OSKeypairController extends Controller {

    /**

     * @name constructor

     * 

     * @param {*} ctx 

     * @param {Function}    DuFn     清理空字段函数

     * @param {Object}      auth     用户JWT

     * 

     */

    constructor(ctx) {

        super(ctx);

        this.auth = ctx.state.user;

        this.DUFn = ctx.helper.deleteUndefined;

        this.QPFn = ctx.helper.queryParamFn;

        this.SERVICE = ctx.service.openstack.compute.keypair;

        this.MODEL = ctx.model.Openstack.Servers.Keypair

    }

    /**

     * @name  获取用户所有密钥对

     * 

     * @example  

     * - GET /openstack/compute/keypairs

     */

    async index() {

        const ctx = this.ctx;

        // const DATAS = await this.SERVICE.index(this.auth.id, this.QPFn(ctx.query));

        // ctx.body = DATAS

        const RESULT = await this.MODEL.getAll(this.auth.id, this.QPFn({ ...ctx.query

        }));

        ctx.body = RESULT

    }

    /**

     * @name  创建密钥对

     * 

     * @param {String}      name      密钥对名称

     * 

     * @example  

     * - POST  application/x-www-form-urlencoded /openstack/compute/keypairs 

     */

    async create() {

        const ctx = this.ctx;

        const {

            name,

            public_key,

            description

        } = ctx.request.body;

        const BODYS = this.DUFn({

            name,

            public_key,

            description

        });

        // const DATAS = await this.SERVICE.create(this.auth.id, BODYS);

        // ctx.body = DATAS

        const RESULT = await this.MODEL.createOne(this.auth.id, BODYS);

        ctx.body = RESULT

    }

    /**

     * @name 获取指定密钥对信息

     * 

     * @param {String}      ctx.params.id      密钥对名称

     * 

     * @example  

     * - GET /openstack/compute/keypairs/{ctx.params.id}

     */

    async show() {

        const ctx = this.ctx;

        const DATAS = await this.MODEL.getOne(this.auth.id, ctx.params.id);

        ctx.body = DATAS

    }

    /**

     * @name  删除密钥对

     * 

     * @param {String}      ctx.params.id      密钥对名称

     * 

     * @example  

     * - DELETE /openstack/compute/keypairs/{ctx.params.id}

     */

    async destroy() {

        const ctx = this.ctx;

        const DATAS = await this.MODEL.deleteOne(this.auth.id, ctx.params.id);

        ctx.body = DATAS

    }

    /**

     * @name 绑定ECS

     * 

     * @param {String} name                         密钥对名称

     * @param {String} type      'bind|unbind'      方式  

     * @param {String} _ECS_id                      服务器id

     * 

     */

    async setBindECS() {

        const ctx = this.ctx;

        const {

            name,

            type,

            _ECS_id

        } = ctx.request.body;

        const BODYS = this.DUFn({

            name,

            type,

            _ECS_id

        })

        const DATAS = await this.MODEL.setBindEcs(this.auth.id, BODYS);

        ctx.body = DATAS

    }

}



module.exports = OSKeypairController;

'use strict';

const ServerIndex = require('../index')

class ComputeKeypairService extends ServerIndex {

    constructor(ctx) {

        super(ctx);

        this.actions = ':8774/v2.1/os-keypairs'

    };

    /**

     * @name 列表

     * @param {*} _ucid         用户id

     */

    async index(_ucid, query) {

        try {

            const datas = await this.OSAJax(`${this.actions}`, {

                _ucid,

                body: { ...query.querys }

            });

            return {

                data: {

                    'result': datas.keypairs,

                    'totalCount': datas.keypairs.length

                },

            }

        } catch (error) {

            return error

        }

    }

    /**

     * @name 获取

     * @param {*} _ucid            用户id

     * @param {*} keypair_name     密钥对名称

     */

    async show(_ucid, keypair_name) {

        try {

            const datas = await this.OSAJax(`${this.actions}/${keypair_name}`, { _ucid });

            return {

                data: datas.keypair

            }

        } catch (error) {

            return error

        }

    }

    /**

     * @name 创建

     * @param {*} _ucid          用户id

     * @param {*} body           需要提交的参数

     */

    async create(_ucid, body) {

        try {

            const datas = await this.OSAJax(`${this.actions}`, {

                _ucid,

                method: 'POST',

                body: {

                    'keypair': {

                        ...body,

                    }

                }

            });

            return {

                ...!!datas.conflictingRequest ? { code: 422, message: `密钥对名称为：${body.name}的密钥对已存在` } : { data: datas }

            }

        } catch (error) {

            return error

        }

    }

    /**

     * @name 删除

     * @param {*} _ucid             用户id

     * @param {*} keypair_name      密钥对名称

     */

    async destroy(_ucid, keypair_name) {

        try {

            const datas = await this.OSAJax(`${this.actions}/${keypair_name}`, {

                _ucid,

                method: 'DELETE',

                full: true

            });

            return {

                code: datas.status,

                message: datas.status === 404 && `${keypair_name}不存在或已删除`

            }

        } catch (error) {



        }

    }

}



module.exports = ComputeKeypairService;