/data/ugenIOT/Cloud/Release/publicComponent

.gitignore

+.idea/

PublicManager.js

+const ProviderManager = require('iot-cloud-core').BASE.ProviderManager;
+const Core = require("./core/CoreProvider")
+const Data = require("./data/DataProvider")
+class PublicManager extends ProviderManager{
+	constructor(){
+		super();
+		this.put("Core", Core);
+		this.put("Data", Data);
+	}
+}
+module.exports = new PublicManager();
\ No newline at end of file

core/CoreProvider.js

+const Provider = require('iot-cloud-core').BASE.Provider;
+const db_user = require('./model/mysql/User');
+const db_device = require('./model/mysql/Device');
+const db_user_device = require('./model/mysql/User_device');
+const dao_user = require('./dao/UserDao');
+const dao_device = require('./dao/DeviceDao');
+const controller_user = require('./controller/UserController');
+const controller_device = require('./controller/DeviceController');
+const controller_wx = require('./controller/WXController');
+const controller_product = require('./controller/ProductController');
+const controller_app = require('./controller/AppController');
+
+const public_class = require('./public/Public');
+class CoreProvider extends Provider{
+	constructor(dbManager){
+		super("core",dbManager);
+
+		this.registerModel(db_user);
+		this.registerModel(db_device);
+		this.registerModel(db_user_device);
+
+		this.registerDao("user",dao_user);
+		this.registerDao("device",dao_device);
+		
+		this.registerController("user",controller_user);
+		this.registerController("device",controller_device);
+		this.registerController("wx",controller_wx);
+        this.registerController("product",controller_product);
+        this.registerController("app",controller_app);
+
+
+		this.setPublicClass(public_class);
+	}
+}
+module.exports = CoreProvider;
\ No newline at end of file

core/Util/Role.js

+class Role{
+	constructor(){
+		this._role = new Map();
+		this._repeatCheck = new Array();
+		this._roleValue = new Map();
+		this._formalRole = new Map();		
+	}
+
+	setDao(dao){
+		this._dao = dao;
+	}
+
+	addRole(action,...role){
+		if(this._repeatCheck.includes(action)){
+			console.error(`[RoleManager]action:${action} is exists`);
+		}else{
+			this._repeatCheck.push(action);
+			role.forEach((value)=>{
+				if(this._role.has(value)){
+					this._role.get(value).push(action);
+				}else{
+					this._role.set(value,Array.of(action));
+				}
+			});
+			this._repeatCheck.forEach((role,index)=>{
+				this._roleValue.set(role,Math.pow(2,index));
+			});
+			
+			this._role.forEach((value,key)=>{
+				let v = 0;
+				value.forEach((action)=>{
+					v += parseInt(this._roleValue.get(action),10);
+				})
+				this._formalRole.set(key,v)
+			});
+		}
+	}
+
+
+	async checkRole(data,action){
+		let res=await this._dao.get('device').findRoleByUserId({user_id:data.user_id,device_id:data.device_id});
+		if (res) {
+			for (let i = 0; i < action.length; i++) {
+				if(this._formalRole.has(res) && this._roleValue.has(action[i])){
+					if(this._formalRole.get(res) & this._roleValue.get(action[i])){
+						return true;
+					}
+				}
+			}
+			
+		}
+		return false;
+	}
+}
+module.exports = Role;
\ No newline at end of file

core/Util/WXSDK.js

+const request = require('request');
+const crypto = require('crypto');
+const ServiceManager = require('iot-cloud-fs');
+const url = 'https://api.weixin.qq.com/';
+class WXSDK{
+	constructor(params) {
+        checkKeyExists(params, "appid");
+        this.appid = params.appid;
+    }
+
+	async auth(params){
+		checkKeyExists(params, "code");
+		let wxInfo = await this.getInfo();
+		if(wxInfo.isComponent){
+			return this.authComponent(params,wxInfo);
+		}
+		return this.send({ url: 'sns/oauth2/access_token?appid=' + wxInfo.wxAppId + '&secret=' + wxInfo.wxSecret + '&code=' + params.code + '&grant_type=authorization_code' });
+	}
+
+	authComponent(params,wxInfo){
+		checkKeyExists(params, "code");
+		return this.send({ url: 'sns/oauth2/component/access_token?appid=' + wxInfo.wxAppId + '&code=' + params.code + '&grant_type=authorization_code&component_appid=' + wxInfo.componentAppId + '&component_access_token=' + wxInfo.componentAccessToken });
+	}
+
+    getUserinfo(params) {
+        checkKeyExists(params, "openid");
+        return this.send({ url: 'sns/userinfo?access_token=' + params.access_token + '&openid=' + params.openid + '&lang=zh_CN' });
+    }
+
+    bindDevice(params){
+    	checkKeyExists(params, "openid", "device_id", "ticket");
+    	let data = {
+            "ticket": params.ticket,
+            "device_id": params.device_id,
+            "openid": params.openid
+        };
+    	return this.send({ url: 'device/bind?access_token=' + params.access_token,type:'post',data:data });
+    }
+
+    unBind(params){
+    	checkKeyExists(params, "openid", "device_id", "ticket");
+    	let data = {
+            "ticket": params.ticket,
+            "device_id": params.device_id,
+            "openid": params.openid
+        };
+    	return this.send({ url: 'device/unbind?access_token=' + params.access_token,type:'post',data:data });
+    }
+
+    compelUnbind(params){
+    	checkKeyExists(params, "openid", "device_id");
+    	let data = {
+            "device_id": params.device_id,
+            "openid": params.openid
+        };
+    	return this.send({ url: 'device/compel_unbind?access_token=' + params.access_token,type:'post',data:data });
+    }
+
+    async getInfo(){
+        let info = await ServiceManager.execute("WXToken","getWXInfo",{
+            appId:this.appid
+        });
+    	return {
+            accessToken:info.accessToken,
+            jsapiToken:info.jsapiToken,
+            isComponent:info.authType !== 1,
+            wxAppId:info.wxAppId,
+            wxSecret:info.wxSecret,
+            componentAppId:info.componentAppId,
+            componentAccessToken:info.componentAccessToken
+    	};
+    }
+
+	send(params) {
+        checkKeyExists(params, "url");
+		return new Promise((r,j)=>{
+			let data;
+			let p;
+	        if (params.type === 'post') {
+	        	p = request.post(url + params.url);
+	            if (params, "data") 
+	            	p.json(params.data);
+	        }else{
+	        	p = request.get(url + params.url);
+	        }
+	        p.on('response', (response) => {
+				if (response.statusCode !== 200)
+					j(response);
+			}).on('data', (data) => {
+				r(JSON.parse(data));
+			})
+			.on('error', (error) => {
+				j(error);
+			});
+		});
+    }
+
+
+	createNonceStr() {
+	    return Math.random().toString(36).substr(2, 15);
+	};
+
+	createTimestamp() {
+	    return parseInt(new Date().getTime() / 1000) + '';
+	};
+
+	raw(args) {
+		let keys = Object.keys(args);
+		keys = keys.sort()
+        let newArgs = {};
+		keys.forEach(function (key) {
+		    newArgs[key.toLowerCase()] = args[key];
+		});
+
+        let string = '';
+		for (let k in newArgs) {
+		    string += '&' + k + '=' + newArgs[k];
+		}
+		string = string.substr(1);
+		return string;
+	};
+
+	async getSign(params) {
+		checkKeyExists(params, "url");
+		let wxInfo = await this.getInfo();
+        let ret = {
+			jsapi_ticket: wxInfo.jsapiToken,
+			nonceStr: this.createNonceStr(),
+			timestamp: this.createTimestamp(),
+			url: params.url
+		};
+        let string = this.raw(ret);
+        let sha1 = crypto.createHash('sha1');
+		sha1.update(string);
+		ret.signature = sha1.digest('hex');
+		delete ret.jsapi_ticket;
+		return ret;
+	};
+
+}
+
+function checkKeyExists(map, ...keys) {
+	for(let key of keys){
+		if (!(key in map))
+			throw new ParamsError(key + " is undefined");
+	}
+}
+module.exports = WXSDK;
\ No newline at end of file

core/controller/Aliconfig.js

+module.exports = {
+	sign:{
+        Format:'JSON',
+		Version:'2017-04-20',
+		SignatureMethod:'HMAC-SHA1',
+		SignatureVersion:'1.0',
+		AccessKeyId:'LTAINKAyUzvMlgPa',
+		RegionId:'shanghai',
+		Action:'Pub',
+		// sign.Action='RegistDevice';
+		ProductKey:'CKurLGS9xnF'
+	}
+}

core/controller/AppController.js

+/**
+* DeviceController.js
+* Version: 0.1
+* User: felix
+* Date: 2018-03-13
+* Copyright(c)  2018. U-GEN Tech.Co,Ltd. All Rights Reserved.
+* Product 产品
+*/
+const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
+const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
+
+/**
+ * @class
+ */ 
+class AppController extends ControllerBase{
+	/**
+	* 获取当前应用的信息，版本号
+	* @example
+     * {
+     *  url:"http://iot.ugen.net",
+     *  min:"1.0.0",
+     *  max:"1.0.1"
+     * }
+     *
+     * error
+     * 20011    缺少参数os
+     * 20012    没有找到相关系统的版本
+	*/
+    @NoAuth
+	async getVersionAction(data){
+        let os = data.params.os;
+        let info = await this.public.data.getOption("app");
+        if(os === undefined)
+            this.error("not found param 'os'",20011);
+        if(info !== null){
+            if( info.value.hasOwnProperty(os.toLowerCase()))
+                return info.value[os.toLowerCase()];
+        }
+        this.error(`not found os info '${os.toLowerCase()}'`,20012);
+ 	}
+}
+module.exports = AppController;
\ No newline at end of file

core/controller/DeviceController.js

+/**
+* DeviceController.js
+* Version: 0.2
+* User: zym
+* Date: 2017-09-05
+* Copyright(c)  2017. U-GEN Tech.Co,Ltd. All Rights Reserved.
+* public method
+*/
+const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
+const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
+const moment=require('moment');
+
+/**
+ * @class
+ */ 
+class DeviceController extends ControllerBase{
+	constructor(){
+    	super();
+    }
+	/**
+	* getList 获取设备列表
+	* @example
+	let params = {
+		parent_id:0,
+		product_id:0,
+		start_id:0,
+		number:10
+	 }
+	* @param {number} parent_id - 父设备id
+	* @param {string} product_id - 设备产品id
+	* @param {number} start_id - 开始id，默认0
+	* @param {number} number - 每页条数 默认10
+	*/
+	async getListAction(data){
+		let product=this.getConfig();
+		let params=data.params;
+		params.user_id=data.user.uid;//获取userid
+		if (params.product_id){
+			if(typeof params.product_id=='object') {
+				for (let i = 0; i < params.product_id.length; i++) {
+					params.product_id[i]=product[params.product_id[i]];
+				}
+			}else{
+				params.product_id=product[params.product_id]
+			}
+		}
+		let res = await this.dao.get('device').findList(params);
+		return res;
+ 	}
+
+ 	/**
+	* getInfo 获取设备信息
+	* @example
+	let params = {
+		device_id:1
+	 }
+	* @param {number} device_id - 设备id
+	*/
+ 	async getInfoAction(data){
+ 		data.params.user_id=data.user.uid;
+ 		data.params.status=1;
+		let res = await this.dao.get('device').findInfo(data.params);
+ 		if (res) { 
+ 			return res;
+ 		}else{
+			return {msg:"device is undefined"};
+		}
+ 	}
+
+ 	/**
+	* setInfo 修改设备信息(覆盖)
+	* @example
+	let params = {
+		device_id:1，
+		info:{'a':1}
+	 }
+	* @param {number} device_id - 设备id
+	* @param {json} info - 要存储的信息(JSON格式)
+	*/
+ 	async setInfoAction(data){
+ 		let res =await this.dao.get('device').setDeviceInfoCover({
+ 			id:data.params.device_id,
+ 			info:data.params.info
+ 		})
+ 		return res;
+ 	}
+ 	/**
+	* setUserDeviceInfo 修改userdevice信息(覆盖)
+	* @example
+	let params = {
+		device_id:1，
+		info:{'a':1}
+	 }
+	* @param {number} device_id - 设备id
+	* @param {json} info - 要存储的信息(JSON格式)
+	*/
+ 	async setUserDeviceInfoAction(data){
+ 		let res =await this.dao.get('device').setUserDeviceInfoCover({
+ 			device_id:data.params.device_id,
+ 			user_id:data.user.uid,
+ 			info:data.params.info
+ 		})
+ 		return res;
+ 	}
+ 	/**
+	* getUserDeviceInfo 获取userdevice信息
+	* @example
+	let params = {
+		device_id:1
+	 }
+	* @param {number} device_id - 设备id
+	*/
+ 	async getUserDeviceInfoAction(data){
+ 		let res =await this.dao.get('device').findUserDeviceInfo({
+ 			device_id:data.params.device_id,
+ 			user_id:data.user.uid
+ 		})
+ 		return res;
+ 	}
+
+ 	/**
+	* getUsers 设备绑定的用户信息
+	* @example
+	let params = {
+		device_id:1
+	 }
+	* @param {number} device_id - 设备id
+	*/
+	async getUsersAction(data){
+ 		let res = await this.dao.get('device').findUsers(data.params);
+		return res;
+	}
+
+	/**
+	* setName 设置设备名称(管理员权限)
+	* @example
+	let params = {
+		device_id:1,
+		device_name:'我的设备',
+	 }
+	* @param {number} device_id - 设备id
+	* @param {string} device_name - 设备名称
+	*/
+	async setNameAction(data){
+		if(!await this.public.core.checkRole({user_id:data.user.uid,device_id:data.params.device_id},"admin")){
+			this.error('Wrong role',10002);
+		}
+ 		data.params.user_id=data.user.uid;
+ 		let res = await this.dao.get('device').updateName(data.params);
+ 		if (res) {
+ 			return {success:res};
+ 		}
+ 		this.error("fail to update",30300);
+	}
+
+	/**
+	* setNickname 修改设备昵称
+	* @example
+	let params = {
+		device_id:1,
+		nickname:'我的设备'
+	 }
+	* @param {number} device_id - 设备id
+	* @param {string} nickname - 设备昵称
+	*/
+	async setNicknameAction(data){
+ 		data.params.user_id=data.user.uid;
+ 		let res = await this.dao.get('device').updateNickname(data.params);
+ 		if (res) {
+ 			return {success:res};
+ 		}
+ 		this.error("fail to update",30500);
+	}
+
+	/**
+	* bind 绑定设备
+	* @example
+	let params = {
+		device_id:1,
+		mac:'acbdqf32aa',
+		product_id:'B001',
+		nickname:'我的设备'
+	 }
+	* @param {string} device_id - 设备id与mac必须存在一个
+	* @param {string} mac - 设备mac地址与id必须存在一个
+	* @param {string} product_id - 设备产品id
+	* @param {string} nickname - 设备昵称
+	*/
+	async bindAction(data){
+		data.params.user=data.user;
+		let bind = await this.public.core.bindDevice(data.params,true);
+		if (bind) {
+ 			return {success:true};
+ 		}
+		this.error('set failed',30500);
+	}
+
+	//绑定蓝牙设备
+	/**
+	* newBind 绑定设备
+	* @example
+	let params = {
+		device_id:1,
+		mac:'acbdqf32aa',
+		product_id:'B001',
+		nickname:'我的设备'
+	 }
+	* @param {string} device_id - 设备id与mac必须存在一个
+	* @param {string} mac - 设备mac地址与id必须存在一个
+	* @param {string} product_id - 设备产品id
+	* @param {string} nickname - 设备昵称
+	*/
+	async newBindAction(data){
+		data.params.user=data.user;
+		let bind = await this.public.core.bindDevice(data.params,false);
+		if (bind) {
+ 			return {success:true};
+ 		}
+		this.error('set failed',30500);
+	}
+
+	/**
+	* unbind 根据设备编号解绑用户设备
+	* @example
+	let params = {
+		device_id:1
+	 }
+	* @param {number} device_id - 设备编号
+	*/
+	async unbindAction(data){
+		data.params.user_id=data.user.uid;
+		let bind = await this.public.core.delBindByDeviceIdAndUserId(data.params);
+		if (bind) {
+ 			return bind;
+ 		}
+		this.error("fail to update",30500);
+	}
+	/**
+	* removeUser 解绑设备(管理员)
+	* @example
+	let params = {
+		device_id:1
+	 }
+	* @param {number} device_id - 设备id与mac必须存在一个
+	*/
+	async removeUserAction(data){
+		if(!await this.public.core.checkRole({user_id:data.user.uid,device_id:data.params.device_id},"admin")){
+			this.error('Wrong role',10002);
+		}
+		let res = await this.public.core.delBindByDeviceIdAndUserId(data.params);
+		if (res) {
+ 			return res;
+ 		}
+ 		this.error("fail to update",30500);
+	}
+
+	@NoAuth
+	async getVersionAction(data){
+		switch(data.params.type){
+			case 'ios':
+				return await this.public.core.getVersion({type:{'value.ios':1}});
+			case 'android':
+				return await this.public.core.getVersion({type:{'value.android':1}});
+		}
+		this.error('type is undefined',30010)
+	}
+
+	@NoAuth
+	async setVersionAction(data){
+		let params={};
+		switch(data.params.type){
+			case 'ios':
+				params={
+					key:this.getConfig().wxAppId,
+					'value.ios':{
+						version:data.params.version,
+						url:data.params.url
+					}
+				}
+				break;
+			case 'android':
+				params={
+					key:this.getConfig().wxAppId,
+					'value.android':{
+						version:data.params.version,
+						url:data.params.url
+					}
+				}
+				break;
+		}
+		console.log()
+		if (!params.key) {
+			this.error('type is undefined',30010)
+		}
+		let res = await this.public.core.setVersion(params);
+		return res;
+	}
+}
+module.exports = DeviceController;
\ No newline at end of file

core/controller/ProductController.js

+/**
+* DeviceController.js
+* Version: 0.1
+* User: felix
+* Date: 2018-03-13
+* Copyright(c)  2018. U-GEN Tech.Co,Ltd. All Rights Reserved.
+* Product 产品
+*/
+const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
+const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
+
+/**
+ * @class
+ */ 
+class ProductController extends ControllerBase{
+	/**
+	* 获取产品信息
+	* @example
+     * {
+           "min":{
+              "download":"http://192.168.2.184:8010/custom01.wgtu",
+              "support":{
+                 "ios":"0.0.1",
+                 "andoird":"0.0.1"
+              },
+              "ver":"0.0.1"
+           },
+           "now":{
+              "download":"http://192.168.2.184:8010/custom01.wgtu",
+              "support":{
+                 "ios":"1.0.0",
+                 "andoird":"1.0.0"
+              },
+              "ver":"1.0.0"
+           }
+        }
+	* @param {number} pid - 产品id
+	*/
+    @NoAuth
+	async getInfoByIdAction(data){
+        let info = await this.public.data.getOption(`pid_${data.params.pid}`);
+        if(info !== null){
+            return info.value;
+        }
+		this.error("not find info",20010);
+ 	}
+}
+module.exports = ProductController;
\ No newline at end of file

core/controller/UserController.js

+const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
+const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
+const ComponentManager = require('iot-cloud-core').BASE.ComponentManager;
+const log = require('iot-cloud-core').LOG;
+const UAformater = require('ua-format-js').UAFormat();
+const moment = require('moment');
+const crypto = require('crypto');
+const Calculation = require('./public/Calculation');
+const WXAuth = require('./public/WXAuth');
+
+/**
+ * @class
+ */ 
+class UserController extends ControllerBase{
+	afterInit(){
+		this.auth={};
+		this.auth.WXAuth=new WXAuth({appId:this.getConfig().wxThirdAppId});
+	}
+	/**
+	* reg 注册用户
+	* @example
+	let params = {
+		username:"用户",
+		pwd:"123456"
+	 }
+	* @param {string} username - 用户账号
+	* @param {string} pwd - 密码
+	*/
+	@NoAuth
+	async regAction(data){
+		return await this.public.core.userReg(data,data.params.username,data.params.pwd,data.params.clienId);
+	}
+	/**
+	* login 用户登录
+	* @example
+	let params = {
+		username:"用户",
+		pwd:"123456"
+	 }
+	* @param {string} username - 用户账号
+	* @param {string} pwd - 密码
+	*/
+	@NoAuth
+	async loginAction(data){
+		let user = await this.dao.get('user').searchByName(data.params);
+		if(!user)
+			this.error("username not exists",20200);
+		if(Calculation.generatePassword(data.params.pwd,user.salt) != user.password)
+			this.error("password error",20201);
+		let ua = UAformater.setUA(data.header['user-agent']).getResult();
+		let params={
+			id:user.id,
+			mobiletype:ua.os.name?ua.os.name:'null',
+			version:ua.os.version?ua.os.version:'null',
+			useragent:ua?ua:'null'
+		}
+		if (data.params.clienId) {
+			params.clienId=data.params.clienId;
+		}
+		let res = await this.dao.get('user').updateUserInfoId(params);
+		let token = data.auth.sign(Calculation.signParams(user.id));
+		return {
+			"username":user.username,
+			"nickname":user.nickname,
+			"head":user.head,
+			"utoken":token
+		};
+		return res;
+	}
+
+	/**
+	* verLogin 自动登录
+	* @example
+	* header:{
+		token:"JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOjEwLCJpYXQiOjE1MDMzNjkyNzksImV4cCI6MTUwNDIzMzI3OX0.iaW4QzyZAjiZdwI5a0aVuIRsAA0QnmxGweQQL5-yyes"
+	}
+	*/
+	async verLoginAction(data){
+		let user = await this.dao.get('user').findUserById({"uid":data.user.uid});
+		if(!user)
+			this.error("select failed",20300);
+		let logintime = moment(new Date()).format('YYYY-MM-DD HH:mm:ss');
+		let ua = UAformater.setUA(data.header['user-agent']).getResult();
+		let params={
+			id:user.id,
+			mobiletype:ua.os.name?ua.os.name:'null',
+			version:ua.os.version?ua.os.version:'null',
+			useragent:ua?ua:'null'
+		}
+		if (data.params.clienId) {
+			params.clienId=data.params.clienId;
+		}
+		let res = await this.dao.get('user').updateUserInfoId(params);
+		let token = data.auth.sign(Calculation.signParams(user.id));
+		return {
+			"username":user.username,
+			"nickname":user.nickname,
+			"head":user.head,
+			"loginTime":logintime,
+			"utoken":token,
+		};
+	}
+
+	async getInfoAction(data){
+		let user = await this.dao.get('user').findUserById({"uid":data.user.uid});
+		if(!user)
+			this.error("select failed",20300);
+		return {
+			"username":user.username,
+			"nickname":user.nickname,
+			"head":user.head
+		};
+	}
+	
+	/**
+	* resetPwd 重置密码,暂时没有短信验证
+	* @example
+	let params = {
+		pwd:"123456"
+	 }
+	* @param {string} pwd - 重置的密码？
+	*/
+	async resetPwdAction(data){
+		let user = await this.dao.get('user').findUserById({"uid":data.user.uid});
+		if(!user)
+			this.error("username is undefined",20400);
+		//验证码验证,暂时默认通过
+		let params = {
+			"id":user.id,
+			"pwd":data.params.pwd
+		};
+		let res = await this.dao.get('user').updatePwdById(params);
+		return res;
+	}
+	/**
+	* resetPwd 设置密码,暂时没有短信验证
+	* @example
+	let params = {
+		pwd:"123456"
+	 }
+	* @param {string} pwd - 重置的密码？
+	*/
+	async setPwdAction(data){
+		let user = await this.dao.get('user').findUserById({"uid":data.user.uid});
+		if(!user)
+			this.error("username is undefined",20500);
+
+		//验证密码是否正确
+		if(Calculation.generatePassword(data.params.old_pwd,user.salt) == user.password){
+			let newPwd = Calculation.generatePassword(data.params.new_pwd,user.salt);
+			if(newPwd == user.password)
+				this.error("new pwd is same with old pwd",20501)
+			let params = {
+				"id":user.id,
+				"pwd":newPwd
+			};
+			let res = await this.dao.get('user').updatePwdById(params);
+			return res;
+		}else{
+			this.error("password is error",20502);
+		}
+	}
+	@NoAuth
+	async sdsAuthAction(data){
+		let user=data.auth.verify(data);
+		let userinfo=await this.dao.get('user').findUserById({uid:user.uid});
+		let res={
+			sourceData:true,
+			data:{
+				"code": "1000",//1000是成功，其它是失败
+			    "msg": "成功",//错误提示
+			    "description": "",//错误详细描述
+			    "data": {//结果数据
+			        "userId":userinfo.id, //必填
+			        "userNick":userinfo.nickname //必填
+			    }
+			}
+		};
+		return res;
+	}
+
+	async setInfoAction(data){
+		data.params.user_id=data.user.uid;
+		let userinfo=await this.dao.get('user').setUserNameAndHeadAndInfo(data.params);
+		if (userinfo[0]) {
+			return 'success';
+		}
+		return 'set fail';
+	}
+
+	@NoAuth
+	async sds_loginAction(data){
+            let user = {
+				username:data.params.username,
+				nickname:'',
+				head:'',
+				info:{},
+				salt:Math.random().toString(36).substr(2, 6)
+			};
+			let ua = UAformater.setUA(data.header['user-agent']).getResult();
+		    user.info.mobiletype=ua.os.name?ua.os.name:'null';
+	    	user.info.version=ua.os.version?ua.os.version:'null';
+	    	user.info.useragent=ua?ua:'null';
+	    	if (data.params.mobile) {
+	    		user.mobile=data.params.mobile;
+	    	}
+	    	if (data.params.clienId) {
+	    		user.info.clienId=data.params.clienId;
+	    	}
+            let res = await this.dao.get('user').createSimpleUser(user);
+            res.utoken=data.auth.sign(Calculation.signParams(res.id));
+            return res;
+	}
+
+	@NoAuth
+	async login_simpleAction(data){
+            let user = {
+				username:data.params.username,
+				nickname:'',
+				head:'',
+				info:{},
+				salt:Math.random().toString(36).substr(2, 6)
+			};
+			let ua = UAformater.setUA(data.header['user-agent']).getResult();
+		    user.info.mobiletype=ua.os.name?ua.os.name:'null';
+	    	user.info.version=ua.os.version?ua.os.version:'null';
+	    	user.info.useragent=ua?ua:'null';
+	    	if (data.params.mobile) {
+	    		user.mobile=data.params.mobile;
+	    	}
+	    	if (data.params.clienId) {
+	    		user.info.clienId=data.params.clienId;
+	    	}
+            let res = await this.dao.get('user').createSimpleUser(user);
+            res.utoken=data.auth.sign(Calculation.signParams(res.id));
+            return res;
+	}
+
+	@NoAuth
+	async thirdLoginAction(data){
+		let type=data.params.type;
+		let userParams={};
+		if (type=='WX') {
+			userParams=await this.auth.WXAuth.wxLogin(data);
+			if (userParams.errcode) {
+				this.error(userParams.errmsg,userParams.errcode)
+		    }
+		    userParams.info={};
+		}else if (type=='QQ') {
+			let head=data.params.data.figureurl?data.params.data.figureurl:data.params.data.figureurl_qq_1;
+			userParams={
+				username:data.params.data.openId,
+				nickname:data.params.data.nickname,
+				head:head.substring(0,head.lastIndexOf("/")),
+				info:{
+					gender:data.params.data.gender,
+					city:data.params.data.city
+				}
+			}
+		}
+        let ua = UAformater.setUA(data.header['user-agent']).getResult();
+        userParams.salt=Math.random().toString(36).substr(2, 6);
+	    userParams.info.mobiletype=ua.os.name?ua.os.name:'null';
+    	userParams.info.version=ua.os.version?ua.os.version:'null';
+	    userParams.info.useragent=ua?ua:'null';
+	    if (data.params.clienId) {
+    		userParams.info.clienId=data.params.clienId;
+    	}
+		let newUser = await this.dao.get("user").createWXUser(userParams);
+	    newUser.utoken = data.auth.sign(Calculation.signParams(newUser.id));
+	    return newUser;
+	}
+
+	// 清除用户数据,cid 登出 http://116.62.143.3:10080/iot-v2/iot-cloud-app/issues/1
+	async logoutAction(data){
+		let update={
+			user_id:data.user.uid,
+			key:['clienId']
+		}
+		let res = await this.public.core.logout(update);
+		if (res) {
+			return {success:true}
+		}
+		return {msg:'update failed'}
+	}
+
+	@NoAuth
+	async getUserLogAction(data){
+		let res=await this.dao.get("user").getUserLog(data.params);
+		return res;
+	}
+}
+module.exports = UserController;
\ No newline at end of file

core/controller/WXController.js

+const ControllerBase = require('iot-cloud-core').BASE.ControllerBase;
+const NoAuth = require('iot-cloud-core').BASE.ControllerDecorator.NoAuth;
+const ComponentManager = require('iot-cloud-core').BASE.ComponentManager;
+const UAformater = require('ua-format-js').UAFormat();
+const WXSDK = require('../Util/WXSDK');
+const Calculation = require('./public/Calculation');
+/**
+ * @class
+ */ 
+class WXController extends ControllerBase{
+	/**
+	* login 微信登录
+	* @example
+	let params = {
+		code:"adsfaseipojqienm,lznjbibpijoewkqnmgnklskd",
+		url:"https://iot.u-gen.net/aj2017/view/"
+	 }
+	* @param {string} product_id - 微信code
+	* @param {string} start_id - 授权地址url
+	*/
+	@NoAuth
+	async loginAction(data){
+		let user = await this.public.core.wxLogin(data);
+		if (user.errcode) {
+			this.error(user.errmsg,user.errcode)
+	    }
+	    return user;
+	}
+	/**
+	* getSign 获取微信签名
+	* @example
+	let params = {
+		url:"https://iot.u-gen.net/aj2017/view/"
+	 }
+	* @param {string} start_id - 授权地址url
+	*/
+	@NoAuth
+	async getSignAction(data){
+		let params = {
+			url:data.params.url
+		}
+		let sign = this.public.core.getSign(params);
+		return sign;
+	}
+}
+
+WXController.OPTIONS = {
+	"WX_CONFIG":"wx_config"
+}
+module.exports = WXController;
\ No newline at end of file

core/controller/alisignSDK.js

+const request = require('request');
+const crypto = require('crypto');
+const moment = require('moment');
+const config = require('./Aliconfig');
+// const url='https://iot.aliyuncs.com/?';
+const url = 'https://iot.cn-shanghai.aliyuncs.com/?';
+class alisignSDK{
+    constructor(data) {
+        this.AccessKeySecret = data.key+"&";
+        this.sign=config.sign;
+    }
+
+    getsign(data){
+        var that=this;
+        this.sign.Timestamp=moment().toISOString();//请求时间戳
+        this.sign.SignatureNonce=parseInt(Math.random()*10000000000000);//唯一随机数
+        this.sign.TopicFullName=data.TopicFullName;//消息发送目的topic名字
+        this.sign.MessageContent=data.MessageContent;//发送的消息
+        let promise = new Promise(function(resolve, reject) {
+            try{
+                let keys = Object.keys(that.sign);//将参数转换为数组
+                keys = keys.sort();//按字典顺序排序
+                let newArgs = {};
+                keys.forEach(function (key) {//遍历数组 把参数内的字符串作为URI 组件进行编码其中的某些字符将被十六进制的转义序列进行替换
+                    newArgs[encodeURIComponent(key)] = encodeURIComponent(that.sign[key]);//参考https://help.aliyun.com/document_detail/30128.html
+                });
+                let string = '';
+                for (let k in newArgs) {//将数组拼接为字符串参数之间用&号隔开参数名和值之间用=
+                    string +='&' + k + '=' + newArgs[k];
+                }
+                string = string.substr(1);//去掉第一位的符号 从下标为1的地方开始截取字符串
+                let StringToSign= "GET" +"&"+ encodeURIComponent("/") + "&" + encodeURIComponent(string);//使用上一步构造的规范化字符串按照规则构造用于计算签名的字符串
+                let sign=crypto.createHmac('sha1', that.AccessKeySecret).update(StringToSign).digest().toString('base64');//计算签名HMAC值 计算方法是SHA1
+                let context=string+"&Signature="+encodeURIComponent(sign);//按照Base64编码规则把上面的HMAC值编码成字符串，即得到签名值(Signature)
+                request(url+context, function (error, res, body) {//request发送请求
+                    if(error){
+                        reject({status:0,msg:error.message});
+                    }else if(res.statusCode >= 200 && res.statusCode < 300){             
+                        resolve(body);
+                    }else{
+                        reject({status:res.statusCode,msg:body});
+                    }
+
+                })
+            }catch(e){
+                console.log(e)
+                reject(e)
+            }
+        })
+        return promise;
+    }
+
+ 
+    // getSend(v) {
+    //     return this.send({json:v});
+    //     //return this.send({json:v,type: 'get'});
+    // }
+
+    // postSend(v) {
+    //     return this.send({json:v,type: 'post'});
+    // }
+
+    // send(params) {
+    //     // let promise = new Promise(function(resolve, reject) {
+    //     //     request(url+params, function (error, response, body) {   
+    //     //      if (error){    
+    //     //         console.log(error)
+    //     //         reject(error);
+    //     //      }
+    //     //         resolve(body); 
+    //     //     })
+    //     // })
+    //     // return promise;
+    // }   
+}
+
+
+module.exports = alisignSDK;
\ No newline at end of file

core/controller/public/Calculation.js

+const crypto = require('crypto');
+class Calculation{
+	static signParams(id){
+		return {
+			uid:id
+		}
+	}
+	
+	static getSalt(){
+		return Math.random().toString(36).substr(2, 6);
+	}
+
+	static generatePassword(password, salt) {
+	    var md5 = crypto.createHash('md5');
+	    md5.update(password + salt);
+	    return md5.digest('hex');
+	}
+}
+module.exports = Calculation;
\ No newline at end of file

core/controller/public/ThirdAuth.js

+class ThirdAuth{
+
+	async Auth(data){
+		return 'undefined';
+	}
+
+	async getUserInfo(data){
+		return 'undefined';
+	}
+}
+module.exports = ThirdAuth;
\ No newline at end of file

core/controller/public/WXAuth.js

+const ThirdAuth=require('./ThirdAuth');
+const Calculation = require('./Calculation');
+const LOG = require('iot-cloud-core').LOG;
+const WXSDK = require('../../Util/WXSDK');
+const UAformater = require('ua-format-js').UAFormat();
+class WxAuth extends ThirdAuth{
+
+	constructor(data) {
+		super()
+		this.WXSDK = new WXSDK({appid:data.appId});
+	}
+
+	async wxLogin(data){
+		let wxParams = {
+			code:data.params.code,
+			appid:data.appid
+		}
+		let auth=await this.WXSDK.auth(wxParams);
+		if (auth.errcode) {
+	    	LOG.error(auth)
+	        return auth;
+	    }
+	    let uParams = {
+	    	appid:data.appid,
+	        access_token:auth.access_token,
+	        openid:auth.openid
+	    };
+	    let wxUserInfo =await this.WXSDK.getUserinfo(uParams);
+	    let userParams = {
+	        username: auth.openid,
+	        nickname: wxUserInfo.nickname,
+	        head: wxUserInfo.headimgurl,
+	        salt:Math.random().toString(36).substr(2, 6)
+	    }
+	    return userParams;
+	}
+}
+
+module.exports = WxAuth;
\ No newline at end of file

core/dao/DeviceDao.js

+/**
+ * DeviceDao.js
+ * Version: 0.1
+ * User: zym
+ * Date: 2017-06-30
+ * Copyright(c)  2017. U-GEN Tech.Co,Ltd. All Rights Reserved.
+ */
+const mongoose = require('mongoose');
+const sequelize = require('sequelize');
+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+const moment = require('moment');
+class DeviceDao extends DaoBase {
+    //获取设备列表
+    async findList(data) {
+        this.checkKeyExists(data, "user_id");
+        let update = {
+            attributes: ['device.id', 'device.device_id', 'device.product_id', 'device.mac',
+                'device.parent_id', 'device.device_name', 'nickname', 'device.device_state', 
+                'role','status',['info', 'user_device_info'], ['id', 'user_device_id']
+            ],
+            where: {
+                user_id: data.user_id,
+                id: { $gt: 0 },//默认从0开始
+                status: [1,2]
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                where:{},
+                order: [['user_device_id DESC']],
+                attributes: []
+            }]
+        };
+
+        if (data.device_id) {
+            update.include[0].where.device_id = data.device_id;
+        }
+        if (data.product_id) {
+            update.include[0].where.product_id = data.product_id;
+        }
+        if (data.parent_id >= 0) {
+            update.include[0].where.parent_id = data.parent_id;
+        }
+        if (data.start_id && data.start_id != '') {
+            update.include[0].where.id = { $lt: data.start_id };
+        }
+        if (data.number) {
+            update.limit = data.number;
+        }
+        let device = await this.models.mysql.user_device.findAll(update);
+        if (device.length > 0) {
+            for (let i = 0; i < device.length; i++) {
+                device[i].user_device_info = JSON.parse(device[i].user_device_info);
+            }
+        }        
+        return device;
+    }
+    //获取网关和子设备列表
+    async findDeviceListWithParent(data) {
+        this.checkKeyExists(data, "user_id", "parent_id");
+        let update = {
+            attributes: ['device.id', 'device.device_id', 'device.product_id', 'device.parent_id', 'device.device_name', 'nickname', 'role', 'device.device_state', ['info', 'user_device_info'],
+                ['id', 'user_device_id']
+            ],
+            where: {
+                user_id: data.user_id,
+                id: { $gt: 0 },
+                status: 1
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                where: {
+                    '$or': [{
+                            parent_id: data.parent_id
+                        },
+                        {
+                            id: data.parent_id
+                        }
+                    ]
+                },
+                order: [['user_device_id DESC']],
+                attributes: []
+            }], //表对象
+        }
+        if (data.start_id && data.start_id != '') {
+            update.where.id = { $lt: data.start_id };
+        }
+        if (data.product_id) {
+            update.where.product_id = data.product_id;
+        }
+        if (data.number && data.number != '') {
+            update.limit = data.number;
+        }
+        let device = await this.models.mysql.user_device.findAll(update)
+        if (device.length > 0) {
+            for (let i = 0; i < device.length; i++) {
+                device[i].user_device_info = JSON.parse(device[i].user_device_info);
+            }
+        }        
+        return device;
+    }
+    //获取用户所有子设备
+    async findAllDevice(data){
+        this.checkKeyExists(data,"user_id","default_lock_id")
+        let user_device_table=this.models.mysql.user_device.getTableName();
+        let device_table=this.models.mysql.device.getTableName();
+        let device=await this.models.mysql.db.query(`
+            SELECT * FROM (SELECT
+                device.id,
+                user_device.id as user_device_id,
+                user_device.nickname,
+                device.device_name,
+                device.device_id,
+                device.parent_id,
+                device.mac,
+                user_device.status,
+                device.product_id,
+                user_device.user_id,
+            IF (user_device.device_id = $default_id, 1, 2) AS sort
+            FROM
+                ${user_device_table} AS user_device
+            LEFT JOIN ${device_table} AS device ON user_device.device_id = device.id
+            WHERE user_device.status=1 and user_device.user_id=$user_id and device.parent_id>0
+            ORDER BY
+                sort,user_device_id) as res WHERE  IF ($start_id>0, res.user_device_id>$start_id and id!=$default_id, res.user_device_id>$start_id)
+            LIMIT $page_size
+            `,
+            {
+                type: sequelize.QueryTypes.SELECT,
+                bind: {
+                    user_id:data.user_id,
+                    start_id:data.start_id?data.start_id:0,
+                    default_id: data.default_lock_id,
+                    page_size:data.number?data.number:10,
+                }
+            })  
+        return device;
+    }
+    //查询用户所有的网关
+    async findParentList(data){
+        this.checkKeyExists(data,"user_id")
+        let update = {
+            attributes: ['device.id', 'device.device_id', 'device.product_id', 'device.mac',
+                'device.parent_id', 'device.device_name', 'nickname','role', 'device.device_state', 
+                ['info', 'user_device_info'], ['id', 'user_device_id']
+            ],
+            where: {
+                user_id: data.user_id,
+                status: 1
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                where: { 
+                    parent_id:0
+                }, 
+                order: [['user_device_id DESC']],
+                attributes: []
+            }]
+        };
+        let device = await this.models.mysql.user_device.findAll(update);
+        if (device.length > 0) {
+            for (let i = 0; i < device.length; i++) {
+                device[i].user_device_info = JSON.parse(device[i].user_device_info);
+            }
+        }        
+        return device;
+    }
+
+    //同时获取管理员以及普通用户该父设备下所有绑定的设备
+    async findUserDevice(data) {
+        this.checkKeyExists(data,"admin_id", "user_id", "parent_id");
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let device_table = this.models.mysql.device.getTableName();
+        //将普通用户的设备和管理员的设备查询结果left join
+        let device_result = await this.models.mysql.db.query(`SELECT
+        user_device.id,admin_device.id as admin_device_id,admin_device.device_name,admin_device.device_id  FROM
+        (SELECT user_device.id,user_device.device_id,device.device_name,user_device.role FROM ${user_device_table} as user_device LEFT OUTER JOIN ${device_table} as device ON user_device.device_id = device.id WHERE  user_device.user_id = $admin_id AND (device.parent_id = $parent_id OR device.id=$parent_id)) admin_device
+        LEFT JOIN 
+        (SELECT user_device.id,user_device.device_id,device.device_name,user_device.role  FROM ${user_device_table} as user_device LEFT OUTER JOIN ${device_table} as device ON user_device.device_id = device.id WHERE  user_device.user_id = $user_id AND (device.parent_id = $parent_id OR device.id=$parent_id)) user_device
+        ON user_device.device_id = admin_device.device_id`, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                admin_id: data.admin_id,
+                user_id: data.user_id,
+                parent_id: data.parent_id
+            }
+        });
+
+        return device_result;
+    }
+    //查找用户下特定父设备下所有子设备
+    async findDeviceByUserIdAndParentId(data){
+        this.checkKeyExists(data,"user_id","parent_id")
+        let update={
+            attributes: ["id"],
+            where:{
+                user_id:data.user_id,
+                status:1
+            },
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: [],
+                where: {
+                    parent_id: data.parent_id,
+                }
+            }],
+            raw:true
+        };
+        let user_device_result=await this.models.mysql.user_device.findAll(update);
+        return user_device_result;
+    }
+
+    //批量插入设备或更新
+    async createOrUpdateDevice(data) {
+        this.checkKeyExists(data, "role", "status", "user_id", "info")
+        let update = "";
+        for (let i = 0; i < data.info.length; i++) {
+            if (i >= 1) {
+                update += ',';
+            }
+            update += `(${data.info[i].id},"${data.info[i].device_name}","${data.role}",${data.status},"{}","${moment().format('YYYY-MM-DD HH:mm:ss')}","${moment().format('YYYY-MM-DD HH:mm:ss')}",${data.info[i].device_id},${data.user_id})`;
+        }
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let user_device_result = await this.models.mysql.db.query(`INSERT INTO ${user_device_table} (id,nickname, role ,status,info,create_time,update_time,device_id,user_id) VALUES ${update} ON DUPLICATE KEY UPDATE nickname=VALUES(nickname),role=VALUES(role),info=VALUES(info),update_time=VALUES(update_time),status=VALUES(status)`, {
+            type: sequelize.QueryTypes.UPSERT,
+        })
+        if (user_device_result> 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    //获取用户设备信息
+    async findInfo(data) {
+        this.checkKeyExists(data, "user_id", "device_id");
+        let update = {
+            attributes: ['id', 'device_id', [sequelize.col('device.device_id'),'deviceId'], 'device.product_id', 'device.device_name', 'nickname', 'status', ['info', 'user_device_info'],
+                [sequelize.col('device.info'), 'device_info']
+            ],
+            where: {
+                user_id: data.user_id,
+                device_id: data.device_id
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: []
+            }]
+        }
+        if (data.status >= 0) {
+            update.where.status = data.status;
+        }
+        let user_device_result = await this.models.mysql.user_device.findOne(update);
+        if (user_device_result) {
+            user_device_result.device_info = JSON.parse(user_device_result.device_info);
+            user_device_result.user_device_info = JSON.parse(user_device_result.user_device_info);
+        } 
+        return user_device_result;
+    }
+    //同时查找设备表和设备关系表中的设备及关系
+    async findDeviceInfoByDeviceIdAndUserId(data){
+        this.checkKeyExists(data,"device_id","user_id")
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let device_table = this.models.mysql.device.getTableName();
+        let device_result = await this.models.mysql.db.query(`SELECT
+            device.id,
+            user_device.id AS user_device_id,
+            device.device_name,
+            user_device.nickname,
+            user_device.status
+            FROM
+             (SELECT id,device_name FROM ${device_table} WHERE id=$id) as device
+             LEFT OUTER JOIN
+             (SELECT id,user_id,status,device_id,nickname FROM ${user_device_table} WHERE user_id=$user_id AND device_id=$id) as user_device
+             ON
+             user_device.device_id = device.id`,
+            {
+                type: sequelize.QueryTypes.SELECT,
+                bind: {
+                    id: data.device_id,
+                    user_id:data.user_id
+                },
+                plain:true
+            }
+        );
+        return device_result;
+    }
+    //获取设备绑定的用户信息
+    async findUsers(data) {
+        this.checkKeyExists(data, "device_id");
+        let update = {
+            attributes: ['user_id', 'user.nickname', 'user.head', 'role', ['info', 'user_device_info']],
+            where: {
+                device_id: data.device_id,
+                status: 1
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.user,
+                as: 'user',
+                attributes: []
+            }]
+        };
+        let user_device_result = await this.models.mysql.user_device.findAll(update);
+        if (user_device_result.length > 0) {
+            for (let i = 0; i < user_device_result.length; i++) {
+                user_device_result[i].user_device_info = JSON.parse(user_device_result[i].user_device_info);
+            }
+        }        
+        return user_device_result;
+    }
+    //修改device表name
+    async updateName(data) {
+        this.checkKeyExists(data, "device_id", "device_name");
+        let value = {
+            device_name: data.device_name
+        };
+        let condition = {
+            where: {
+                id: data.device_id
+            }
+        }
+        let res = await this.models.mysql.device.update(value, condition);
+        if (res[0] == 0) {
+            return false;
+        } else { return true; }
+    }
+    //修改user_device表nickname
+    async updateNickname(data) {
+        this.checkKeyExists(data, "user_id", "device_id", "nickname");
+        let value = {
+            nickname: data.nickname
+        };
+        let condition = {
+            where: {
+                user_id: data.user_id,
+                device_id: data.device_id
+            }
+        }
+        let res = await this.models.mysql.user_device.update(value, condition);
+        console.log(res)
+        if (res[0] == 0) {
+            return false;
+        } else { return true }
+    }
+    //根据 id mac device_id 查找设备
+    async findDevice(data) {
+        if (!data.id && !data.mac && !data.device_id) {
+            return false;
+        }
+        let update = {
+            attributes: ['id', 'device_id', 'mac', 'device_name', 'status', 'parent_id'],
+            where: {},
+            raw: true
+        };
+        if (data.id) {
+            update.where.id = data.id;
+        }
+        if (data.mac) {
+            update.where.mac = data.mac;
+        }
+        if (data.device_id) {
+            update.where.device_id = data.device_id;
+        }
+
+        let res = await this.models.mysql.device.findOne(update);
+        return res;
+    }
+    //根据device_id或者mac或者id查找设备
+    async findDeviceById(data) {
+        this.checkKeyExists(data, 'id');
+        let update = {
+            attributes: ['id', 'device_id', 'mac', 'device_name', 'status', 'parent_id'],
+            where: {
+                id: data.id
+            },
+            raw: true
+        };
+        let res = await this.models.mysql.device.findOne(update);
+        return res;
+    }
+    //根据device_id或者mac或者id查找设备
+    async findDeviceByMac(data) {
+        this.checkKeyExists(data, 'mac');
+        let update = {
+            attributes: ['id', 'device_id', 'mac', 'device_name', 'status', 'parent_id'],
+            where: {
+                mac: data.mac
+            },
+            raw: true
+        };
+        let res = await this.models.mysql.device.findOne(update);
+        return res;
+    }
+    //根据device_id或者mac或者id查找设备
+    async findDeviceByDeviceId(data) {
+        this.checkKeyExists(data, 'device_id');
+        let update = {
+            attributes: ['id', 'device_id', 'mac', 'device_name', 'status', 'parent_id'],
+            where: {
+                device_id: data.device_id
+            },
+            raw: true
+        };
+        let res = await this.models.mysql.device.findOne(update);
+        return res;
+    }
+    //查询绑定的设备
+    async findBindInfo(data) {
+        this.checkKeyExists(data, 'user_id', 'device_id');
+        let update = {
+            where: {
+                user_id: data.user_id,
+                device_id: data.device_id
+            },
+            raw: true
+        }
+        if (data.status) {
+            update.where.status = data.status;
+        }
+        let res = await this.models.mysql.user_device.find(update);
+        return res;
+    }
+
+    //根据权限查找绑定关系
+    async findBindUserByDeviceId(data) {
+        this.checkKeyExists(data, 'device_id')
+        let update = {
+            attributes: [
+            'id',
+            'user_id',
+            'status', 
+            'user.username',
+            'user.nickname',
+            'user.mobile',
+            'role',
+            ['info','user_device_info']],
+            raw: true,
+            include: [{
+                model: this.models.mysql.user,
+                as: 'user',
+                attributes: []
+            }]
+        };
+        if (data.Key) {
+            for (let i = 0; i < data.Key.length; i++) {
+                update.attributes.push(sequelize.literal("user.info->'$." + data.Key[i] + "' as " + data.Key[i]));
+            }
+            delete data.Key
+        }
+        update.where=data;
+        let res = await this.models.mysql.user_device.findAll(update);
+        return res;
+    }
+    //根据deviceid来解绑
+    async delBindByDeviceId(data) {
+        this.checkKeyExists(data, 'device_id')
+        let res = await this.models.mysql.user_device.update({
+            status: data.status?data.status:0
+        }, {
+            where: {
+                device_id: data.device_id
+            }
+        });
+        if (res[0] == 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+    //根据userid来解绑
+    async delBindByUserId(data) {
+        this.checkKeyExists(data, 'user_id')
+        let res = await this.models.mysql.user_device.update({
+            status: data.status?data.status:0
+        }, {
+            where: {
+                user_id: data.user_id
+            }
+        });
+        if (res[0] == 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+    //根据parentid来解绑父设备以及所有子设备
+    async delBindByParentId(data) {
+        this.checkKeyExists(data, 'parent_id')
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let device_table = this.models.mysql.device.getTableName();
+        let res = await this.models.mysql.db.query(`UPDATE ${user_device_table} as user_device,${device_table} as device SET user_device.status=0 WHERE (device.parent_id=$parent_id OR device.id=$parent_id) AND user_device.device_id=device.id`, {
+            type: sequelize.QueryTypes.UPSERT,
+            bind: {
+                parent_id: data.parent_id
+            }
+        });
+        return res;
+    }
+    //同时用user_id,device_id解绑
+    async delBind(data) {
+        this.checkKeyExists(data, 'user_id', 'device_id')
+        let res = await this.models.mysql.user_device.update({
+            status: 0
+        }, {
+            where: {
+                device_id: data.device_id,
+                user_id: data.user_id
+            }
+        });
+        if (res[0] == 0) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+    //重置device表中的设备
+    async delDeviceById(data) {
+        this.checkKeyExists(data, "device_id");
+        let condition = {
+            where: {
+                id: data.device_id
+            }
+        };
+        let res = await this.models.mysql.device.update({
+            info: {},
+            parent_id: null,
+            device_name: null
+        }, condition);
+        return res;
+    }
+    //重置device表中某网关下多个设备
+    async delDeviceByParent(data) {
+        this.checkKeyExists(data, "parent_id");
+        let condition = {
+            where: {
+                parent_id: data.parent_id
+            }
+        };
+        let res = await this.models.mysql.device.update({
+            info: {},
+            parent_id: null,
+            device_name: null
+        }, condition);
+        return res;
+    }
+    //查找device 根据info字段内容
+    async findDeviceByInfo(data) {
+        let condition = 'status=1';
+        for (let key in data) {
+            condition += ` AND info->'$.${key}'=${data[key]}`;
+        }
+        let device_table = this.models.mysql.device.getTableName();
+        let device_result = await this.models.mysql.db.query(`SELECT id,device_name from ${device_table} WHERE ${condition}`, {
+            type: sequelize.QueryTypes.SELECT
+        });
+        return device_result;
+    }
+
+    //查询用户绑定设备
+    async findDeviceByUserId(data) {
+        this.checkKeyExists(data, "user_id")
+        let update = {
+            attributes: ['device_id'],
+            where: {
+                user_id: data.user_id,
+                status: 1
+            },
+            raw: true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: [],
+                where: {
+                    parent_id: { $gt: 0 },
+                }
+            }]
+        }
+        return await this.models.mysql.user_device.findAll(update);
+    }
+    //查找用户与设备的权限
+    async findRoleByUserId(data) {
+        this.checkKeyExists(data, "user_id","device_id")
+        let res = await this.models.mysql.user_device.find({
+            attributes: ['role'],
+            raw: true,
+            where: {
+                status:1,
+                user_id: data.user_id,
+                device_id: data.device_id
+            }
+        });
+        if (!res) {
+            return false;
+        }
+        return res.role
+    }
+    //根据user_id获取info字段
+    async findUserInfo(data) {
+        this.checkKeyExists(data, "user_id", "Key")
+        let update = '';
+        for (let i = 0; i < data.Key.length; i++) {
+            if (i > 0) { update += ','; }
+            update += "info->'$." + data.Key[i] + "' as " + data.Key[i];
+        }
+        let user_table = this.models.mysql.user.getTableName();
+        let user_result = await this.models.mysql.db.query(`SELECT ${update} from ${user_table} where id=$user_id`, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                user_id: data.user_id
+            }
+        });
+        if (user_result[0]) {
+            for (let i = 0; i < data.Key.length; i++) {
+                user_result[0][data.Key[i]]=JSON.parse(user_result[0][data.Key[i]]);
+            }
+        }        
+		return user_result;
+    }
+
+    //查找设备信息和父设备id
+    async findDeviceAndParent(data) {
+        this.checkKeyExists(data, "device_id","default_id", "user_id")
+        let update = '';
+        if (data.Key) {
+            for (let i = 0; i < data.Key.length; i++) {
+                update += ",device.info->'$." + data.Key[i] + "' as " + data.Key[i];
+            }
+        }
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let device_table = this.models.mysql.device.getTableName();
+        let user_device_result = await this.models.mysql.db.query(`SELECT device.id,device.device_name, device.parent_id,user_device.role${update} 
+            FROM ${user_device_table} as user_device 
+            LEFT OUTER JOIN 
+            ${device_table} AS device ON user_device.device_id = device.id 
+            WHERE 
+            user_device.device_id in ($device_id,$default_id) AND 
+            user_device.user_id = $user_id AND 
+            user_device.status = 1`, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                user_id: data.user_id,
+                device_id: data.device_id,
+                default_id: data.default_id
+            }
+        });
+        return user_device_result;
+    }
+    //根据用户和时间查找最新一条设备信息和父设备id
+    async findDeviceAndParentByTime(data) {
+        this.checkKeyExists(data, "user_id")
+        let update = '';
+        if (data.Key) {
+            for (let i = 0; i < data.Key.length; i++) {
+                update += ",device.info->'$." + data.Key[i] + "' as " + data.Key[i];
+            }
+        }
+        let user_device_table = this.models.mysql.user_device.getTableName();
+        let device_table = this.models.mysql.device.getTableName();
+        let user_device_result = await this.models.mysql.db.query(`SELECT device.id,device.device_name, device.parent_id,user_device.role${update} FROM ${user_device_table} as user_device LEFT OUTER JOIN ${device_table} AS device ON user_device.device_id = device.id WHERE user_device.user_id = $user_id AND user_device.status = 1 AND device.parent_id>0 ORDER BY user_device.update_time DESC LIMIT 1 `, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                user_id: data.user_id,
+                role: data.role
+            }
+        });
+        return user_device_result;
+    }
+    //查找设备info信息
+    async findDeviceInfoById(data) {
+        this.checkKeyExists(data, "device_id", "Key")
+        let update = '';
+        for (let i = 0; i < data.Key.length; i++) {
+            if (i > 0) { update += ','; }
+            update += "info->'$." + data.Key[i] + "' as " + data.Key[i];
+        }
+        let device_table = this.models.mysql.device.getTableName();
+        let device_result = await this.models.mysql.db.query(`SELECT parent_id,${update} from ${device_table} where id=$device_id`, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                device_id: data.device_id,
+            }
+        });
+        return device_result;
+    }
+    //根据parent_id获取所有设备info信息
+    async findDeviceInfoByPid(data) {
+        this.checkKeyExists(data, "parent_id", "Key")
+        let update = '';
+        for (let i = 0; i < data.Key.length; i++) {
+            update += ",info->'$." + data.Key[i] + "' as " + data.Key[i];
+        }
+        let device_table = this.models.mysql.device.getTableName();
+        let device_result = await this.models.mysql.db.query(`SELECT mac as parent_mac${update} from ${device_table} where parent_id=$parent_id OR id=$parent_id`, {
+            type: sequelize.QueryTypes.SELECT,
+            bind: {
+                parent_id: data.parent_id
+            }
+        });
+        return device_result;
+    }
+    //根据device_id和mac搜索父设备
+    async findDeviceByDeviceIdAndMac(data){
+        this.checkKeyExists(data, "device_id", "mac");
+        let update = {
+            attributes:['id','parent_id','status','device_name'],
+            raw:true,
+            where:{
+                $or:[
+                  { device_id: data.device_id },
+                  { mac: data.mac }
+                ]
+            }
+        };
+        let device_result=await this.models.mysql.device.findAll(update);
+        return device_result;
+
+    }
+    //根据device_id查询该设备所有用户
+    async findDeviceUserByDeviceId(data){
+        this.checkKeyExists(data,"device_id","status")
+        let update={
+            attributes:['device.id','device.info','device.device_name','role','user_id'],
+            where:{
+                status:data.status
+            },
+            raw:true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: [],
+                where: {
+                    device_id:data.device_id
+                }
+            }]
+        }
+        let user_device_result=await this.models.mysql.user_device.findAll(update);
+        if (user_device_result.length > 0) {
+            for (let i = 0; i < user_device_result.length; i++) {
+                user_device_result[i].info = JSON.parse(user_device_result[i].info);
+            }
+        }   
+        return user_device_result;
+    }
+
+    //注册设备
+    async createDevice(data) {
+        this.checkKeyExists(data, "device_id", "device_name", "parent_id", "info");
+        let update = {};
+        if (!data.id) {
+            update = data;
+            data.id = null;
+        } else {
+            update = {
+                product_id: data.product_id,
+                device_name: data.device_name,
+                parent_id: data.parent_id,
+                info: data.info
+            }
+        }
+        var that = this;
+        return await this.models.mysql.device.findOrCreate({ where: { id: data.id }, defaults: update }).spread(function(row, created) {
+            if (created) {
+                return row;
+            } else {
+                return that.models.mysql.device.update(update, { where: { id: data.id } }).then(function(updated) {
+                    return { id: row.id,device_name:update.device_name, update: updated[0] };
+                    // return updated;
+                });
+            }
+        });
+    }
+
+    //根据自增id设置用户权限
+    async setRoleById(data) {
+        this.checkKeyExists(data, "id", "role");
+        let res = await this.models.mysql.user_device.update({
+            role: data.role
+        }, { where: { id: data.id } });
+        return res;
+    }
+
+    //设置权限
+    async setRole(data) {
+        this.checkKeyExists(data, "user_id", "device_id", "role");
+        let where = {};
+        where.user_id = data.user_id;
+        where.device_id = data.device_id;
+        let res = await this.models.mysql.user_device.update({
+            role: data.role
+        }, {
+            where: where
+        })
+        return res;
+    }
+    //设置user info字段内容
+    async setUserInfo(data) {
+        this.checkKeyExists(data, "id")
+        var update = '';
+        for (let Key in data) {
+            if (Key != 'id') {
+                update += ",'$." + Key + "','" + data[Key] + "'";
+            }
+        }
+        let table = this.models.mysql.user.getTableName();
+        let res = await this.models.mysql.db.query(`UPDATE ${table} set info=json_set(info ${update}) WHERE id=$id`, {
+            type: sequelize.QueryTypes.BULKUPDATE,
+            bind: {
+                id: data.id
+            }
+        });
+        return res;
+    }
+    
+    //设置device info字段内容
+    async setDeviceInfo(data) {
+        this.checkKeyExists(data, "id")
+        var update = '';
+        for (let Key in data) {
+            if (Key != 'id') {
+                // if (typeof(data[Key])=='object') {
+                    update += ",'$." + Key + "',CAST('" + data[Key] + "' AS JSON)"; //json_array()将数组存入
+                // }else{
+                //     update += ",'$." + Key + "','" + data[Key]+"'";
+                // }
+            }
+        }
+        let table = this.models.mysql.device.getTableName();
+        let res = await this.models.mysql.db.query(`UPDATE ${table} set info=json_set(info${update}) WHERE id=$id`, {
+            type: sequelize.QueryTypes.BULKUPDATE,
+            bind: {
+                id: data.id
+            }
+        });
+        return res;
+    }
+    //设置deviceinfo(覆盖)
+    async setDeviceInfoCover(data){
+        this.checkKeyExists(data, "id","info")
+        let value = {
+            info: data.info
+        };
+        let condition = {
+            where: {
+                id: data.id
+            }
+        };
+        let res = await this.models.mysql.device.update(value,condition);
+        return res;
+    }
+    //根据id查找设备是否被绑定过
+    async findUserDeviceByDeviceId(data) {
+        this.checkKeyExists(data, 'device_id')
+        let update = {
+            attributes: ["id", "status"],
+            raw: true,
+            where: {
+                device_id: data.device_id,
+            }
+        };
+        let device = await this.models.mysql.user_device.find(update);
+        return device;
+    }
+    //修改user_device表info字段（覆盖）
+    async setUserDeviceInfoCover(data){
+        this.checkKeyExists(data,"user_id","device_id","info")
+        let value = {
+            info: data.info
+        };
+        let condition = {
+            where: {
+                user_id: data.user_id,
+                device_id:data.device_id
+            }
+        };
+        let res = await this.models.mysql.user_device.update(value,condition);
+        return res;
+    }
+    //查找user_device表info字段
+    async findUserDeviceInfo(data){
+        this.checkKeyExists(data, "user_id","device_id")
+        let update = {
+            attributes:['info'],
+            where: {
+                user_id: data.user_id,
+                device_id:data.device_id
+            }
+        };
+        let res = await this.models.mysql.user_device.find(update);
+        return res;
+    }
+
+    async countDeviceUser(data){
+        this.checkKeyExists(data, "mac","status")
+        let update={
+            where:{
+                status:data.status
+            },
+            raw:true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: [],
+                where: {
+                    device_id:data.mac
+                }
+            }]
+        }
+        return await this.models.mysql.user_device.count(update);
+    }
+
+    async findDeviceUserByMac(data){
+        this.checkKeyExists(data,"mac","status")
+        let update={
+            attributes:['user_id','user.nickname','role','update_time'],
+            where:{
+                status:data.status
+            },
+            raw:true,
+            include: [{
+                model: this.models.mysql.device,
+                as: 'device',
+                attributes: [],
+                where: {
+                    mac:data.mac
+                }
+            },{
+                model: this.models.mysql.user,
+                as: 'user',
+                attributes: []
+            }],
+        }
+        if (data.order) {
+            update.order=data.order
+        }
+        if (data.limit) {
+            update.limit=data.limit
+        }
+        if (data.offset) {
+            update.offset=data.offset
+        }
+        let user_device_result=await this.models.mysql.user_device.findAll(update);
+        return user_device_result;
+    }
+
+
+
+
+    async create() {
+        // let test = await this.models.mysql.testinfo.findAll({
+        //      include :[{model:this.models.mysql.test}]
+        // });
+        let test = await this.models.mongo.system_option.create({ testid: '1' });
+        // let test = await this.models.mysql.testinfo.create({
+        //     content:"2222",
+        //  time: new Date(),
+        //  AD_test: {//外键名
+        //      content:"111111",
+        //      time: new Date(),
+        //    }
+        //  }, {
+        //    include :[{model:this.models.mysql.test}]//表对象
+        //  });
+        console.log(test)
+        return test;
+    }
+}
+module.exports = DeviceDao;
\ No newline at end of file

core/dao/UserDao.js

+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+const sequelize = require('sequelize');
+const moment = require('moment')
+class UserDao extends DaoBase{
+	async createUser(params){
+		this.checkKeyExists(params,"username","pwd","salt");
+		let newUser = {
+			username:params.username,
+			password:params.pwd,
+			info:params.info,
+			salt:params.salt,
+			loginTime:new Date()
+		};
+		let res = await this.models.mysql.user.create(newUser);
+		return res.get({
+			plain:true
+		});
+	}
+
+	async createWXUser(params){
+		this.checkKeyExists(params,"username","salt");
+		let newUser = {
+			where:{
+				username:params.username
+			},
+			defaults:{
+				loginTime:new Date(),
+				password:"",
+				nickname:params.nickname,
+				head:params.head,
+				info:params.info?params.info:{},
+				salt:params.salt
+			}
+		};
+		let info = {
+			loginTime:moment().format('YYYY-MM-DD HH:mm:ss'),
+			nickname:params.nickname,
+			head:params.head,
+			mobiletype:params.info.mobiletype,
+			version:params.info.version,
+			useragent:params.info.useragent,
+			username:params.username
+		};
+        let clienId='';
+		if (params.info.clienId) {
+			clienId=",'$.clienId','"+params.info.clienId+"'";
+		}
+		let update = {
+			attributes:['id','username','nickname','head'],
+			raw:true,
+			where:{
+				username:params.username
+			}
+		};
+		var that=this;//从不同方法过来的参数用不同的方法
+		let res = await this.models.mysql.user.findOrCreate(newUser).spread(function(row, created) {
+            if (created||params.condition) {
+                return row.get({
+					plain:true
+				});
+            } else {
+                let user_table = that.models.mysql.user.getTableName();
+	        	return that.models.mysql.db.query(`UPDATE ${user_table} SET nickname=$nickname,head=$head,loginTime=$loginTime,info=json_set(info,'$.mobiletype',$mobiletype,'$.version',$version,'$.useragent',$useragent${clienId}) WHERE username=$username`, {
+	            	type: sequelize.QueryTypes.UPDATE,
+	            	bind: {
+	            		nickname:info.nickname,
+	            		head:info.head,
+	                	username:info.username,
+	                	mobiletype:info.mobiletype,
+	                	version:info.version,
+	                	useragent:JSON.stringify(info.useragent),
+	                	loginTime:info.loginTime
+	            	}
+	        	}).then(function(updated) {
+                    return that.models.mysql.user.find(update);
+                });
+            }
+        });
+		return res;
+	}
+
+	async createSimpleUser(params){
+		this.checkKeyExists(params,"username","salt");
+		let newUser = {
+			where:{
+				username:params.username
+			},
+			defaults:{
+				loginTime:new Date(),
+				password:"",
+				nickname:params.nickname,
+				head:params.head,
+				info:params.info?params.info:{},
+				salt:params.salt
+			}
+		};
+		let info = {
+			loginTime:moment().format('YYYY-MM-DD HH:mm:ss'),
+			mobiletype:params.info.mobiletype,
+			version:params.info.version,
+			useragent:params.info.useragent,
+			username:params.username
+		};
+        let clienId='';
+		if (params.info.clienId) {
+			clienId=",'$.clienId','"+params.info.clienId+"'";
+		}
+		let update = {
+			attributes:['id','username','nickname','head'],
+			raw:true,
+			where:{
+				username:params.username
+			}
+		};
+		var that=this;//从不同方法过来的参数用不同的方法
+		let res = await this.models.mysql.user.findOrCreate(newUser).spread(function(row, created) {
+            if (created||params.condition) {
+                return row.get({
+					plain:true
+				});
+            } else {
+                let user_table = that.models.mysql.user.getTableName();
+	        	return that.models.mysql.db.query(`UPDATE ${user_table} SET loginTime=$loginTime,info=json_set(info,'$.mobiletype',$mobiletype,'$.version',$version,'$.useragent',$useragent${clienId}) WHERE username=$username`, {
+	            	type: sequelize.QueryTypes.UPDATE,
+	            	bind: {
+	                	username:info.username,
+	                	mobiletype:info.mobiletype,
+	                	version:info.version,
+	                	useragent:JSON.stringify(info.useragent),
+	                	loginTime:info.loginTime
+	            	}
+	        	}).then(function(updated) {
+                    return that.models.mysql.user.find(update);
+                });
+            }
+        });
+		return res;
+	}
+
+	async searchByName(params){
+		this.checkKeyExists(params,"username");
+		let search = {
+			where:{
+				username:params.username
+			},
+			attributes:['id','username','nickname','head','salt','loginTime','password']
+		};
+		let res = await this.models.mysql.user.findOne(search);
+		if(res == null)
+			return null;
+		return res.get({
+			plain:true
+		});
+	}
+
+	async updateUserInfoId(params){
+		this.checkKeyExists(params,"id");
+		let update = {
+			id:params.id,
+        	mobiletype:params.mobiletype,
+        	version:params.version,
+        	useragent:JSON.stringify(params.useragent),
+        	loginTime:moment().format('YYYY-MM-DD HH:mm:ss')
+		};
+		let clienId='';
+		if (params.clienId) {
+			clienId=",'$.clienId','"+params.clienId+"'";
+		}
+		let user_table = this.models.mysql.user.getTableName();
+    	let res =this.models.mysql.db.query(`UPDATE ${user_table} SET loginTime=$loginTime,info=json_set(info,'$.mobiletype',$mobiletype,'$.version',$version,'$.useragent',$useragent${clienId}) WHERE id=$id`, {
+        	type: sequelize.QueryTypes.UPDATE,
+        	bind: update
+    	})
+		// let res = this.models.mysql.user.update(update,options);
+		return res;
+	}
+
+	async updateCidById(params){
+		this.checkKeyExists(params,"user_id","clienId");
+		let clienId=",'$.clienId','"+params.clienId+"'";
+		let update={
+			info:sequelize.literal(`json_set(info${clienId})`)
+		}
+		let condition={
+			where:{
+				id:params.user_id
+			}
+		}
+		let res = await this.models.mysql.user.update(update,condition)
+		if (res[0]>0) {
+			return true;
+		}
+		return false;
+	}
+
+	async findUserById(params){
+		this.checkKeyExists(params,"uid");
+		let search = {
+			where:{
+				id:params.uid
+			},
+			attributes:["id","username","password","nickname","head","salt","loginTime"]
+		};
+		let res = await this.models.mysql.user.findOne(search);
+		if(res == null){
+			return false;
+		}
+		return res.get({
+			plain:true
+		});
+	}
+
+	async findUserInfoById(data){
+		this.checkKeyExists(data,"id");
+		let update = {
+			attributes:["id","nickname","info"],
+			where:{
+				id:data.id
+			},
+			raw:true
+		}
+		let res = await this.models.mysql.user.findAll(update);
+		if (res.length > 0) {
+            for (let i = 0; i < res.length; i++) {
+                res[i].info = JSON.parse(res[i].info);
+            }
+        }   
+		return res;
+	}
+
+	//设置user 昵称 头像 info字段内容
+    async setUserNameAndHeadAndInfo(data) {
+        this.checkKeyExists(data, "user_id")
+        let condition={
+        	where:{
+	            id:data.user_id
+	        }
+        };
+        let value={};
+        if (data.head) {
+        	value.head=data.head;
+        }
+        if (data.nickname) {
+        	value.nickname=data.nickname;
+        }
+        if (data.info) {
+        	value.info=data.info;
+        }
+        let res = await this.models.mysql.user.update(value,condition);
+        return res;
+    }
+
+	async updatePwdById(params){
+		this.checkKeyExists(params,"id","pwd");
+		let info = {
+			password:params.pwd
+		};
+		let condition = {
+			where:{
+				id:params.id
+			}
+		};
+		let res = await this.models.mysql.user.update(info,condition);
+		if(res[0] == 0)
+			return false;
+		else
+			return true;
+	}
+
+	async getUserLog(data){
+		this.checkKeyExists(data,'start_time','end_time')
+		let user_table = this.models.mysql.user.getTableName();
+		let update={
+            attributes:[
+                sequelize.literal(`COUNT(IF (loginTime >= '${data.start_time}' AND loginTime <'${data.end_time}',1,null)) AS active`),
+                sequelize.literal(`COUNT(IF (create_time >= '${data.start_time}' AND create_time <'${data.end_time}',1,null)) AS new`)
+            ],
+            where:{
+                $or:[
+                    {loginTime:{$gte:data.start_time,$lt:data.end_time}},
+                    {create_time:{$gte:data.start_time,$lt:data.end_time}}
+                ]
+            },
+            raw:true
+        };
+        let user=await this.models.mysql.user.find(update);
+		return user;
+	}
+	async logout(data){
+		this.checkKeyExists(data,"key","user_id");
+		let params='';
+		for (let i = 0; i < data.key.length; i++) {
+            params += ",'$." + data.key[i]+"'";
+        }
+		let update={
+			info:sequelize.literal(`JSON_REMOVE(info${params})`)
+		}
+		let condition={
+			where:{
+				id:data.user_id
+			}
+		}
+		let res = await this.models.mysql.user.update(update,condition)
+		if (res[0]>0) {
+			return true;
+		}
+		return false;
+	}
+}
+module.exports = UserDao;
\ No newline at end of file

core/model/mysql/Device.js

+const MysqlBase = require('iot-cloud-core').DB.MysqlBase;
+const Sequelize = require('sequelize');
+class Device extends MysqlBase {
+    init() {
+        let model = this.createTable("device", {
+            device_id: {
+                type: Sequelize.CHAR(100),
+                allowNull: false,
+                unique:true
+            },
+            product_id: {
+                type: Sequelize.CHAR(50),
+                allowNull: false
+            },
+            device_name: {
+                type: Sequelize.CHAR(45)
+            },
+            mac: {
+                type: Sequelize.CHAR(45)
+            },
+            parent_id: {
+                type: Sequelize.INTEGER()
+            },
+            device_state: {
+                type: Sequelize.BOOLEAN(2)
+            },
+            status: {
+                type: Sequelize.BOOLEAN(2)
+            },
+            login_time: {
+                type: Sequelize.DATE()
+            },
+            info: {
+                type: Sequelize.JSON()
+            }
+        },{
+            timestamps: true,
+            createdAt: 'create_time',
+            updatedAt: 'update_time',
+            hooks: {
+                afterFind: function(device, options) {
+                    if(device&&device.info)
+                        device.info = JSON.parse(device.info)
+                }
+            },
+            freezeTableName: true
+        });
+        return model;
+    }
+
+}
+module.exports = Device;
\ No newline at end of file

core/model/mysql/User.js

+const MysqlBase = require('iot-cloud-core').DB.MysqlBase;
+const Sequelize = require('sequelize');
+class Log extends MysqlBase{
+	init(){
+        let model = this.createTable("user",{
+			username:{
+				type:Sequelize.CHAR(45),
+				allowNull: false,
+				unique:"uk_name"
+			},
+			password:{
+				type:Sequelize.CHAR(45),
+				allowNull: false
+			},
+			nickname:{
+				type:Sequelize.CHAR(45),
+				allowNull: false,
+				defaultValue:""
+			},
+			head:{
+				type:Sequelize.CHAR(255),
+				allowNull: false,
+				defaultValue:""
+			},
+			mobile:{
+				type:Sequelize.CHAR(20)
+			},
+			email:{
+				type:Sequelize.CHAR(100)
+			},
+			loginTime:{
+				type:Sequelize.DATE()
+			},
+			info:{
+				type:Sequelize.JSON(),
+				allowNull: false
+			},
+			salt:{
+				type:Sequelize.CHAR(10),
+				allowNull:false
+			}
+		},
+		{
+			timestamps: true,
+			createdAt:'create_time',
+			updatedAt:'update_time',
+			hooks: {
+				afterFind: function(user, options) {
+					if(user && user.info)
+						user.info = JSON.parse(user.info)
+				}
+			},
+			freezeTableName: true
+		});
+		return model;
+	}
+}
+module.exports = Log;
\ No newline at end of file

core/model/mysql/User_device.js

+const MysqlBase = require('iot-cloud-core').DB.MysqlBase;
+const Sequelize = require('sequelize');
+class User_device extends MysqlBase {
+    init() {
+        let model = this.createTable("user_device", {
+            nickname: {
+                type: Sequelize.CHAR(45)
+            },
+            role: {
+                type: Sequelize.CHAR(10)
+            },
+            status: {
+                type: Sequelize.BOOLEAN(2)
+            },
+            info: {
+                type: Sequelize.JSON
+            }
+        }, {
+            timestamps: true,
+            createdAt: 'create_time',
+            updatedAt: 'update_time',
+            freezeTableName: true
+        });
+        return model;
+    }
+    createRelationShip(models) {
+        models.user_device.belongsTo(models.device, { foreignKey: { name: 'device_id', allowNull: false }, as: 'device' });
+        models.user_device.belongsTo(models.user, { foreignKey: { name: 'user_id', allowNull: false }, as: 'user' });
+    }
+}
+module.exports = User_device;
\ No newline at end of file

core/public/Public.js

+/**
+* Public.js
+* Version: 0.2
+* User: zym
+* Date: 2017-09-05
+* Copyright(c)  2017. U-GEN Tech.Co,Ltd. All Rights Reserved.
+* public
+*/
+const PublicFunBase = require('iot-cloud-core').BASE.PublicFunBase;
+const Role = require('../Util/Role');
+// const SDSSDK = require('../Util/SDSTopSDK');
+const ServiceManager = require('iot-cloud-fs');
+const LOG = require('iot-cloud-core').LOG;
+const UAformater = require('ua-format-js').UAFormat();
+const Calculation = require('../controller/public/Calculation');
+const WXSDK = require('../Util/WXSDK');
+class Public extends PublicFunBase{
+
+	/*
+	*	设置系统参数
+	*/
+
+	constructor(){
+		super();
+		this.role = new Role();
+	}
+
+	async afterInit(){
+		// this.SDSSDK= new SDSSDK();
+    	this.role.setDao(this.dao);
+    	//实例微信sdk
+		this.WXSDK = new WXSDK({appid:this.getConfig().wxAppId});
+    }
+
+	addRole(action,...roles){
+		this.role.addRole(action,...roles);
+	}
+
+	checkRole(role,...action){
+		return this.role.checkRole(role,action);
+	}
+
+	async sendModel(data){
+		ServiceManager.execute("wxpush","push_wx", {appid:this.getConfig().wxAppId,msg:data.data});
+	}
+
+	//获取版本号
+	async getVersion(data){
+		let res = await ServiceManager.execute("version","getVersion", {appid:this.getConfig().wxAppId,type:data.type});
+		if (res) {
+			return res.value;
+		}
+		return false
+	}
+	//修改版本号
+	async setVersion(data){
+		return await ServiceManager.execute("version","setVersion", {key:data.key,msg:data});
+	}
+
+	//绑定设备
+	async bind(data){
+		let params=[{}];
+		let update={};
+		if (data.id&&data.device_name&&data.role) {
+			update={
+				info:[{
+					id:null,
+					device_name:data.device_name,//设备昵称
+					device_id:data.id,//绑定设备id
+				}],
+				user_id:data.user_id,
+				role:data.role,//用户权限
+				status:1
+			};
+			let device_binder=await this.dao.get('device').findBindInfo({//查询绑定设备是否绑定
+				user_id:data.user_id,
+				device_id:data.id
+			});
+			if (device_binder) {//判断绑定设备是否曾经有过关系
+				if (device_binder.status==1) {//已绑定
+					this.error('user is already bind',30803);
+				}
+				if (device_binder.status==0||device_binder.status==2) {//设备绑定过但已逻辑删除
+					update.info[0].id=device_binder.id;//已绑定过但逻辑删除的关系id
+				}
+			}
+			if (data.parent_id){//是否需要绑定父设备
+				let binder=await this.dao.get('device').findDeviceInfoByDeviceIdAndUserId({//查询父设备名称及父设备是否绑定
+						user_id:data.user_id,
+						device_id:data.parent_id
+					});
+				if (binder.id) {
+					if (!binder.user_device_id) {
+						update.info[1]={
+							id:null,
+							device_id:data.parent_id,
+							device_name:binder.device_name//父设备昵称
+						};
+					}
+					if (binder.user_device_id) {//判断父设备是否绑定过 如绑定过但已逻辑删除 则更新
+						update.info[1]={
+							id:binder.user_device_id,
+							device_id:data.parent_id,
+							device_name:binder.status==0?binder.device_name:binder.nickname//父设备昵称
+						};
+					}
+				}else{
+					return false;
+				}
+			}
+			let add = await this.dao.get('device').createOrUpdateDevice(update);//将参数传入 绑定
+			if (add) {
+				return update;
+			}else{
+				return add;
+			}			
+		}else{
+			return false;
+			// this.error('device is undefined',30804);
+		}
+	}
+	//单独绑定一个设备
+	async bindDevice(data,condition){
+        if (!data.device_id&&!data.mac && !data.product_id) {
+            this.error('缺少参数(device_id、mac、product_id)',30805)
+        }
+		let tip=this.getConfig();
+        let product_id = tip[data.product_id]?tip[data.product_id]:data.product_id;
+		let auth;
+		if (condition) {
+			auth = await this.checkOrCreateDeviceAuth({'mac':data.mac?data.mac:data.device_id,'product_id':product_id});
+		}else{
+			auth = await ServiceManager.execute("devices","cloudDeviceAuth", {'mac':data.mac?data.mac:data.device_id,'product_id':product_id});
+		}
+		if (!auth) {
+			this.error('没有权限注册设备',30806);
+		}
+		let res = await this.dao.get('device').findDevice(data);//查询绑定设备是否存在
+		let device_date={
+			device_id:data.device_id?data.device_id:data.mac,
+			product_id:product_id,
+			mac:data.mac?data.mac:data.device_id,
+            device_name: data.nickname?data.nickname:"我的设备",
+            parent_id: 0,
+            status:1,
+            device_state:1,
+            info: data.info?data.info:{}
+		};
+		if (res) {
+			var device_binder=await this.dao.get('device').findBindInfo({//查询用户是否绑定过此设备
+				user_id:data.user.uid,
+				device_id:res.id
+			});
+			if (device_binder) {//判断绑定设备是否曾经有过关系
+				if (device_binder.status==1) {//已绑定
+					this.error('user is already bind',30803);
+				}
+			}
+			device_date.id=res.id;//更新用id
+		}
+		res=await this.dao.get('device').createDevice(device_date);//如果曾经绑定过此设备则更新没有则创建
+		
+		let update={
+			info:[{
+				id:null,
+				device_id:res.id,//绑定设备id
+				device_name:data.nickname?data.nickname:"我的设备"//设备昵称
+			}],
+			user_id:data.user.uid,//用户id
+			role:data.role?data.role:"SA",//是否管理员
+			status:1//将状态设置为绑定
+		};
+		if (device_binder){
+			if(device_binder.status==2||device_binder.status==0) {//设备绑定过但已逻辑删除
+				update.info[0].id=device_binder.id;//已绑定过但逻辑删除的关系id
+			}
+		}
+		let add = await this.dao.get('device').createOrUpdateDevice(update);//将参数传入 绑定
+		if(add){
+			return true;
+		}else{
+			return false;
+		}
+	}
+
+	//批量绑定更新设备
+	async createOrUpdateDevice(data){
+		return await this.dao.get('device').createOrUpdateDevice(data);
+	}
+
+	//sds推送绑定设备
+	// async sdsBind(data){
+	// 	let info={
+	// 		device_id:data.sn,
+	// 	}
+	// }
+
+
+	//查找用户绑定设备
+	async findDeviceByUserId(data){
+		return await this.dao.get('device').findDeviceByUserId(data);
+	}
+
+	async userReg(data,username,pwd,cid) {
+        try{
+            let salt = Calculation.getSalt();
+            let salt_pwd = Calculation.generatePassword(pwd,salt);
+			let ua = UAformater.setUA(data.header['user-agent']).getResult();
+            let user = {
+				username:username,
+				pwd:salt_pwd,
+				salt:salt,
+				info:{
+					mobiletype:ua.os.name?ua.os.name:'null',
+	    			version:ua.os.version?ua.os.version:'null',
+	    			useragent:ua?ua:'null'
+				}
+			};
+			if (cid) {
+				user.info.clienId=cid
+			}
+            let res = await this.dao.get('user').createUser(user);
+            let token = data.auth.sign(Calculation.signParams(res.id));
+            return {
+                "username":res.username,
+                "nickname":res.nickname,
+                "head":res.head,
+                "utoken":token
+            };
+        }catch(e){
+        	console.log(e)
+            this.error("username is exists",20101);
+        }
+    }
+
+	//根据id来查找设备是否绑定过
+	async findUserDeviceByDeviceId(data){
+		return await this.dao.get('device').findUserDeviceByDeviceId(data);
+	}
+	//查询用户某网关下所有设备
+	async findUserDevice(data){
+		return await this.dao.get('device').findUserDevice(data);
+	}
+	//查询子设备
+	async findDeviceListWithParent(data){
+		return await this.dao.get('device').findDeviceListWithParent(data);
+	}
+	//查找用户所有子设备
+	async findAllDevice(data){
+		return await this.dao.get('device').findAllDevice(data);
+	}
+	//查找用户下特定父设备下所有子设备
+	async findDeviceByUserIdAndParentId(data){
+		return await this.dao.get('device').findDeviceByUserIdAndParentId(data);
+	}
+	//根据deviceId查找所有设备用户
+	async findDeviceUserByDeviceId(data){
+		return await this.dao.get('device').findDeviceUserByDeviceId(data);
+	}
+	//查询设备
+	async getList(data){
+		return await this.dao.get('device').findList(data);
+	}
+	//查询用户所有父设备
+	async findParentList(data){
+		return await this.dao.get('device').findParentList(data);
+	}
+	//查询用户已绑定的设备
+	async findBindInfo(data){
+		data.status=1;
+		return await this.dao.get('device').findBindInfo(data);
+	}
+	//根据id查询设备详情
+	async findinfo(data){
+		return await this.dao.get('device').findInfo(data);
+	}
+	//根据deviceid查找绑定关系
+	async findBindUserByDeviceId(data){
+		return await this.dao.get('device').findBindUserByDeviceId(data);
+	}
+	//根据id mac deviceid来查找设备
+	async findDevice(data){
+		return await this.dao.get('device').findDevice(data);
+	}
+	//根据id查找设备
+	async findDeviceById(data){
+		return await this.dao.get('device').findDeviceById(data);
+	}
+	//根据mac查找设备
+	async findDeviceByMac(data){
+		return await this.dao.get('device').findDeviceByMac(data);
+	}
+	//根据DeviceId查找设备
+	async findDeviceByDeviceId(data){
+		return await this.dao.get('device').findDeviceByDeviceId(data);
+	}
+	//根据Info参数查找设备
+	async findDeviceByInfo(data){
+		return await this.dao.get('device').findDeviceByInfo(data);
+	}
+
+
+	//根据设备id查找设备详情
+	async getDevice(data){
+		return await this.dao.get('device').findDeviceAndParent(data);
+	}
+	//根据时间查找最新一条设备详情
+	async getDeviceByTime(data){
+		return await this.dao.get('device').findDeviceAndParentByTime(data);
+	}
+
+	//获取userinfo
+	async findUserInfo(data){
+		return await this.dao.get('device').findUserInfo(data);
+	}
+	//获取多个用户的info信息
+	async findUserInfoById(data){
+		return await this.dao.get('user').findUserInfoById(data);
+	}
+
+	//获取设备info 根据设备id
+	async getDeviceInfoById(data){
+		return await this.dao.get('device').findDeviceInfoById(data);
+	}
+	//获取设备info 根据父设备id
+	async getDeviceInfoByPid(data){
+		return await this.dao.get('device').findDeviceInfoByPid(data);
+	}
+	//删除指定用户的设备
+	async delBindByDeviceIdAndUserId(data){
+		return await this.dao.get('device').delBind(data);
+	}
+	async delBindByParentId(data){
+		return await this.dao.get('device').delBindByParentId(data);
+	}
+	//删除设备关系
+	async delBindByDeviceId(data){
+		return await this.dao.get('device').delBindByDeviceId(data);
+	}
+	//根据id删除设备信息
+	async delDevice(data){
+		return await this.dao.get('device').delDeviceById(data);
+	}
+	//根据父设备id删除设备信息
+	async delDeviceByParent(data){
+		return await this.dao.get('device').delDeviceByParent(data);
+	}
+
+	//根据device_id和mac查找父子设备
+	async findDeviceByDeviceIdAndMac(data){
+		return await this.dao.get('device').findDeviceByDeviceIdAndMac(data);
+	}
+
+	//注册设备
+	async regDevice(data){
+		let tip=this.getConfig();
+        data.product_id = tip[data.product_id]?tip[data.product_id]:data.product_id;
+		return await this.dao.get('device').createDevice(data);
+	}
+	//设置权限
+	async setRole(data){
+		return await this.dao.get('device').setRole(data);
+	}
+	//根据自增id设置权限
+	async setRoleById(data){
+		return await this.dao.get('device').setRoleById(data);
+	}
+	//设置userinfo
+	async setUserInfo(data){
+		return await this.dao.get('device').setUserInfo(data);
+	}
+	//修改个推cid
+	async updateCidById(data){
+		return await this.dao.get('user').updateCidById(data);
+	}
+	async setUserNameAndHeadAndInfo(data){
+		return await this.dao.get('user').setUserNameAndHeadAndInfo(data);
+	}
+	//登出时清楚特定的用户数据
+	async logout(data){
+		return await this.dao.get('user').logout(data);
+	}
+	//设置deviceinfo
+	async setDeviceState(data){
+		return await this.dao.get('device').setDeviceInfo(data);
+	}
+
+	async setUserDeviceInfoCover(data){
+		return await this.dao.get('device').setUserDeviceInfoCover(data)
+	}
+	//根据username查询用户
+	async searchByName(data){
+		return await this.dao.get('user').searchByName(data);
+	}
+	//根据id查询用户
+	async searchById(data){
+		return await this.dao.get('user').findUserById(data);
+	}
+	//获取utoken
+	async getUToken(data){
+		return data.auth.sign({"uid":data.user.id});
+	}
+	//检查设备注册权限
+	async checkDeviceAuth(data){
+		return await ServiceManager.execute("devices","deviceAuth", {'mac':data.mac,'product_id':data.product_id});
+	}
+
+	async checkOrCreateDeviceAuth(data){
+		return await ServiceManager.execute("devices","deviceAuthAndCreate", {'mac':data.mac,'product_id':data.product_id});
+	}
+	
+	async auth(data){
+		return await this.WXSDK.auth(data);
+	}
+	//获取wx用户信息
+	async getUserinfo(data){
+		return this.WXSDK.getUserinfo(data);
+	}
+	//wx解绑设备
+	async wxUnbind(data){
+		return this.WXSDK.unBind(data);
+	}
+	//微信绑定设备
+	async wxBindDevice(data){
+		return this.WXSDK.bindDevice(data);
+	}
+	//微信强制解绑设备
+	async wxCompelUnbind(data){
+		return this.WXSDK.compelUnbind(data)
+	}
+
+	// async sdsFindList(data){
+	// 	return this.SDSSDK.findList();
+	// }
+	//获取签名
+	async getSign(data){
+		return this.WXSDK.getSign(data);
+	}
+	//根据username查找或创建用户
+	async findOrCreateUser(data){
+		let update={
+			username:data.username,
+			info:{},
+			condition:true,
+			salt:Math.random().toString(36).substr(2, 6)
+		}
+		return await this.dao.get("user").createWXUser(update);
+	}
+	//自定义登录
+	async wxLogin(data){
+		let wxParams = {
+			code:data.params.code,
+			appid:data.appid
+		}
+		let auth = await this.WXSDK.auth(wxParams);
+	    if (auth.errcode) {
+	    	LOG.error(auth)
+	        return auth;
+	    }
+	    let uParams = {
+	    	appid:data.appid,
+	        access_token:auth.access_token,
+	        openid:auth.openid
+	    };
+	    let wxUserInfo =await this.WXSDK.getUserinfo(uParams);
+	    let userParams = {
+	        username: auth.openid,
+	        nickname: wxUserInfo.nickname,
+	        head: wxUserInfo.headimgurl,
+	        salt:Math.random().toString(36).substr(2, 6)
+	    }
+
+        	let ua = UAformater.setUA(data.header['user-agent']).getResult();
+			userParams.info = {
+		    	mobiletype:ua.os.name,
+		    	version:ua.os.version,
+		    	useragent:ua
+		    };
+	    //注册新用户，有的话就更新
+	    let newUser = await this.dao.get("user").createWXUser(userParams);
+	    newUser.utoken = data.auth.sign(Calculation.signParams(newUser.id));
+	    return newUser;
+	}
+}
+module.exports = Public;
\ No newline at end of file

data/DataProvider.js

+const Provider = require('iot-cloud-core').BASE.Provider;
+
+const db_dataHistory = require('./model/mongo/DataHistory');
+const db_dataOption = require('./model/mongo/DataOption');
+
+const dao_dataOption = require('./dao/DataOptionDao');
+const dao_dataPublic = require('./dao/DataPublicDao');
+
+const public_class = require('./public/Public');
+
+class DataProvider extends Provider{
+	constructor(dbManager){
+		super("data",dbManager);
+
+		this.registerModel(db_dataHistory);
+		this.registerModel(db_dataOption);
+
+		this.registerDao("dataOption",dao_dataOption);
+		this.registerDao("datapublic",dao_dataPublic);
+
+		this.setPublicClass(public_class);
+	}
+}
+module.exports = DataProvider;
\ No newline at end of file

data/dao/DataOptionDao.js

+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+class DataOptionDao extends DaoBase{
+	async setOption(key,value,expire = null){ 
+        let params = {
+            value:value,
+            updateTime:new Date()
+        };
+        if(expire != null){
+            params.expireAt = expire;
+        }
+        return await this.models.mongo.data_option.findOneAndUpdate({key:key},params,{upsert:true,'new':true}).exec();
+    }
+
+    async setOptions(map,expire = null){
+        for(let key in map){
+            let params = {
+                value:map[key]
+            };
+            if(expire != null){
+                params.expireAt = expire;
+            }
+            await this.models.mongo.data_option.findOneAndUpdate({key:key},params,{upsert:true,'new':true}).exec();
+        }
+    }
+
+    async getOption(key){
+        return await this.models.mongo.data_option.findOne({key:key}).exec();
+    }
+
+    async getOptions(keys){
+        let options = await this.models.mongo.data_option.find({key:{$in:keys}}).exec();
+        let opts = {};
+        for(let index in options){
+            let option = options[index];
+            opts[option.key] = option.value;
+        }
+        return opts;
+    }
+}
+module.exports = DataOptionDao;

data/dao/DataPublicDao.js

+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+const mongoose = require('mongoose');
+class DataPublicDao extends DaoBase{
+
+	//添加历史数据
+	//data接收Public中返回的data数据
+	async addHistory(params){
+		// this.checkKeyExists(data, "action");
+		// this.checkKeyExists(data, "data");
+		// //判断user_id或者device_id是否存在
+		let update={};
+		if(!params.user_id && !params.device_id){
+			return false;
+		}
+		if (!params.arr&&!params.action&&params.action!=0) {
+			return false;
+		}
+		if (params.device_id) {
+			update.device_id=params.device_id;
+		}
+		if (params.user_id) {
+			update.user_id=params.user_id;
+		}
+		if (params.type) {
+			update.type=params.type;
+		}
+		if (params.action>=0) {
+			update.action=params.action;
+		}
+		if (params.data) {
+			update.data=params.data;
+		}
+		if (params.arr) {
+			update=[];
+			for (let i=0;i<params.arr.length;i++) {
+				update[i]=params.arr[i];
+				if (params.device_id) {
+					update[i].device_id=params.device_id;
+				}
+				if (params.user_id) {
+					update[i].user_id=params.user_id;
+				}
+			}
+		}
+		if (params.create_time) {
+			update.create_time=params.create_time;
+		}
+	         //变量接收addHistory
+	    try{
+	    	console.log(update)
+			let addHistory = await this.models.mongo.data_history.create(update);
+			//返回addHistory
+			return addHistory;
+		}catch(e){
+			console.log(e)
+			return false;
+		}
+	}
+	
+
+	//获得历史数据
+	async getHistoryList(data){
+		// param.user_id和param.device_id存在一个或者两个都存在
+		// param.user_id    
+		// param.device_id
+		// param.start_id
+		// param.page_size
+		// param.action
+		// param.start_time
+		// param.end_time
+ 
+
+		//用变量接收一个空的map
+		let HistoryProgram = {};
+		//判断user_id或者device_id是否存在一个
+		//若不存在则返回false
+		if (data.where) {
+			HistoryProgram=data.where;
+		}else{
+			if(! data.user_id && ! data.device_id){
+				return {'false':30000};
+			}
+			if (! data.type) {
+				return false;
+			}
+			HistoryProgram.type=data.type;
+			if(data.user_id){
+				HistoryProgram.user_id = data.user_id;
+			}
+			if(data.device_id){
+				HistoryProgram.device_id = data.device_id;
+			}
+			if (data.action) {
+				HistoryProgram.action = data.action;
+			}
+			if(data.start_id&&data.start_id!=''){
+				HistoryProgram._id = {$lt:mongoose.Types.ObjectId(data.start_id)};
+			}
+			if(data.start_time){
+				HistoryProgram.create_time = {$gt:data.start_time};
+			}
+			if(data.end_time){
+				HistoryProgram.create_time = {$lt:data.end_time};
+			}
+			if(data.start_time && data.end_time){
+				HistoryProgram.create_time = {$gt:data.start_time,$lt:data.end_time}
+			}
+		}
+		if(! data.page_size){
+			data.page_size = 10;
+		}
+
+		if(data.order == 1 ){
+			data.order = parseInt(-1);
+		}
+		else if(data.order == 0){
+			data.order = parseInt(1);
+		}
+		else if(! data.order){
+			data.order = parseInt(-1);
+		}
+		//设置查询 POST需得到的值
+		// get.create_time = {$gt:data.start_time};
+		// get.create_time = {$lt:data.end_time};
+		// get._id = {$gt:data.start_id};
+		// get.action = data.action;
+
+		console.log(HistoryProgram)
+		//变量接收getHistoryList
+		let getHistoryList = await this.models.mongo.data_history.find(HistoryProgram).limit(parseInt(data.page_size)).sort({create_time:data.order});
+		//返回getHistoryList		
+		return getHistoryList;
+		
+		
+}
+	//删除历史数据
+	async delHistory(data){
+		let update={};
+		if (!data.id&&!data.device_id) {
+			return false;
+		}
+		if (data.id) {
+			update={
+				_id:mongoose.Types.ObjectId(data.id)
+			}
+		}
+		if (data.device_id) {
+			update={
+				device_id:data.device_id
+			};
+		}
+		let delHistory = await this.models.mongo.data_history.remove(update);
+		//返回delHistory
+		return {'code':0,'data':delHistory};
+		
+
+	}
+	//设置Option
+	async setOption(data){	
+
+		//设置表的参数
+        
+        // await this.models.mongo.data_option.collection.createIndex({"expire_time":1},{expireAfterSeconds:8});
+       
+
+		let params = {
+            key:data.key,
+            value:data.value
+        }
+        //判断数据是否有存活时间
+        if(data.expire_time != null){
+            	params.expire_time = data.expire_time;
+        }
+        //变量接收setOption
+        let setOption = await this.models.mongo.data_option.findOneAndUpdate({"key":params.key},params,{'new':true,upsert:true});
+        //返回setOpion
+        
+        
+		return {'code':0,'data':setOption};
+
+	}
+
+	async getHistoryByAggregaate(data){
+		let getHistoryList = await this.models.mongo.data_history.aggregate(data);
+		//返回getHistoryList		
+		return getHistoryList;
+	}
+
+
+
+	//获得Option
+	async getOption(data){
+
+		//变量接收getOption
+		let getOption = await this.models.mongo.data_option.findOne({"key":data.key});
+		//返回getOption
+		return {'code':0,'data':getOption};
+	}
+}
+module.exports = DataPublicDao;

data/dao/OptionsDao.js

+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+class OptionsDao extends DaoBase{
+    async setOption(key,value,expire = null){
+        
+        let params = {
+            value:value,
+            updateTime:new Date()
+        };
+        if(expire != null){
+            params.expireAt = expire;
+        }
+        return await this.models.mongo.system_option.findOneAndUpdate({key:key},params,{upsert:true,'new':true}).exec();
+    }
+
+    async setOptions(map,expire = null){
+        for(let key in map){
+            let params = {
+                value:map[key]
+            };
+            if(expire != null){
+                params.expireAt = expire;
+            }
+            await this.models.mongo.system_option.findOneAndUpdate({key:key},params,{upsert:true,'new':true}).exec();
+        }
+    }
+
+    async getOption(key){
+        return await this.models.mongo.system_option.findOne({key:key}).exec();
+    }
+
+    async getOptions(...keys){
+        let options = await this.models.mongo.system_option.find({key:{$in:keys}}).exec();
+        let opts = {};
+        for(let index in options){
+            let option = options[index];
+            opts[option.key] = option.value;
+        }
+        return opts;
+    }
+
+}
+module.exports = OptionsDao;
\ No newline at end of file

data/dao/UserDao.js

+const DaoBase = require('iot-cloud-core').BASE.DaoBase;
+class UserDao extends DaoBase{
+	async add(){
+		let sql = await this.models.mysql.user.create({
+			type: "1",
+			count:1,
+			time: new Date()
+		});
+		return sql;
+	}
+}
+module.exports = UserDao;
\ No newline at end of file

data/model/mongo/DataHistory.js

+const MongoBase = require('iot-cloud-core').DB.MongoBase;
+class DataHistoryModel extends MongoBase {
+    init() {
+        let model = this.createTable('data_history', {
+            user_id: {type:String},
+            device_id:{type:String},
+            type:{type:String},
+            action:{type:Number},
+            data:{},
+            status:{type:Number},
+            create_time:{type:Date,default:Date.now}
+        });     
+          model.index({"type":1,"action":1,"create_time":1,"device_id": 1,"user_id":1});
+        return model;
+    }
+}
+module.exports = DataHistoryModel;
\ No newline at end of file

data/model/mongo/DataOption.js

+const MongoBase = require('iot-cloud-core').DB.MongoBase;
+class DataOptionModel extends MongoBase {
+    init() {
+        let model = this.createTable('data_option', {
+            key: {type: String},
+            value:{},
+            expire_time:{type: Date},
+            create_time:{type: Date,default:Date.now},
+            update_time:{type: Date,default:Date.now}
+        });
+        model.index({"key": 1});
+        model.index({expireAt: 1}, { expireAfterSeconds: 0 });
+        return model;
+    }
+}
+module.exports = DataOptionModel;
\ No newline at end of file

data/model/mongo/Options.js

+const MongoBase = require('iot-cloud-core').DB.MongoBase;
+class OptionsModel extends MongoBase {
+    init() {
+        let model = this.createTable('system_option', {
+            key: {type: String},
+            value: {},
+            expireAt: {type: Date},
+            updateTime:{type: Date}
+        });
+        model.index({expireAt: 1}, { expireAfterSeconds: 0 });
+        return model;
+    }
+}
+module.exports = OptionsModel;
\ No newline at end of file

data/public/Public.js

+const PublicFunBase = require('iot-cloud-core').BASE.PublicFunBase;
+class Public extends PublicFunBase{
+	/*
+	*	设置系统参数
+	*/
+
+
+	//data文件夹下的Public.js调用data文件夹中的OptionsDao.js文件中的方法
+// async setOption(data){
+//   	console.log('PublicsetOption');
+
+//    	await this.dao.get('options').setOption();
+	   	//					   ↑		  ↑
+	   	//					   ↑	OptionsDao.js中的setOption方法
+	   	// 所有的Dao要使用需要在DataProvider中进行注册否则无法调用   
+	    
+	// }
+	//         括号内data接收controller中返回的数据
+
+	//添加历史数据
+	async addHistory(data){
+		let addHistory = await this.dao.get('datapublic').addHistory(data);
+		return addHistory;
+
+	}
+	//获得历史数据
+	async getHistoryList(data){
+		//变量接收getHistoryList
+		let getHistoryList = await this.dao.get('datapublic').getHistoryList(data);
+		//返回getHistoryList
+		return getHistoryList;
+
+	}
+	//获取历史数据（聚合函数）
+	async getHistoryByAggregaate(data){
+		let getHistoryByAggregaate= await this.dao.get('datapublic').getHistoryByAggregaate(data);
+		return getHistoryByAggregaate;
+	}
+
+
+	//删除历史数据
+	async delHistory(data){
+		//变量接收delHistory
+		let delHistory = await this.dao.get('datapublic').delHistory(data);
+		//返回delHistory
+		return delHistory;
+	}
+
+
+
+	//设置Option
+	async setOption(key,value,expire = null){
+		//变量接收setOption
+		let setOption = await this.dao.get('dataOption').setOption(key,value,expire);
+		//返回setOption
+		return setOption;
+		
+	}
+
+	//获得Option
+	async getOption(key){
+		//变量接收getOption
+		let getOption = await this.dao.get('dataOption').getOption(key);
+		//返回getOption
+		return getOption;
+	}
+
+	async getOptions(...keys){
+        let getOptions = await this.dao.get('dataOption').getOption(keys);
+        return getOptions;
+
+    }
+}
+module.exports = Public;
\ No newline at end of file

grpc/WXPRC.js

+var grpc = require('grpc');
+var PROTO_PATH = __dirname + '/wx.proto';
+const LOG = require('iot-cloud-core').LOG;
+class WXRPC{
+	constructor(){
+		this.hello_proto = grpc.load(PROTO_PATH).helloworld;
+		this.client = new this.hello_proto.Greeter('192.168.2.97:20008', grpc.credentials.createInsecure());
+	}
+
+	getInfo(product_id){
+		if(!product_id){
+			LOG.error("WXRPC:product_id is null");
+			return null;
+		}
+		return new Promise((r,j)=>{
+			this.client.getInfo({product_id:"wxcc1ee78ae256be1f"},function(err,response){
+				if(err)
+					j(err)
+				r(response);
+		    });
+		});
+	}
+}
+
+module.exports = new WXRPC();
\ No newline at end of file

grpc/wx.proto

+
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  rpc getInfo(InfoRequest) returns (InfoReply) {}
+}
+
+message InfoRequest{
+    string product_id = 1;
+}
+
+message InfoReply{
+    string component_access_token = 1;
+    string js_ticket = 2;
+    string access_token = 3;
+    string component_appid = 4;
+}
\ No newline at end of file