Coverage

/Users/welefen/Develop/git/thinkjs/lib/Common/common.js

100%

270

0

Line	Hits	Source
1	1	var fs = require('fs');
2	1	var path = require('path');
3	1	var util = require('util');
4	1	var crypto = require('crypto');
5	1	var net = require('net');
6
7		/**
8		* Promise，后续Node.js会默认支持Promise，所以这里加个判断
9		* @type {[type]}
10		*/
11	1	if (!global.Promise) {
12	1	global.Promise = require('es6-promise').Promise;
13		}
14
15		/**
16		* 动态创建一个类
17		* 提供了继承、扩展、调用父级别方法等方法
18		* @return {[type]} [description]
19		*/
20	1	global.Class = function (prop, superCls) {
21	36	'use strict';
22	36	var cls = function () {
23	214	function T(args) {
24	214	for(var name in cls.__prop){
25	702	var val = cls.__prop[name];
26	702	this[name] = isObject(val) ? extend({}, val) : val;
27		}
28		//自动执行init方法
29	214	if(isFunction(this.init)){
30		//获取init返回值，如果返回一个promise，可以让后续执行在then之后
31	214	this.__initReturn = this.init.apply(this, args);
32		}
33	214	return this;
34		}
35	214	T.prototype = cls.prototype;
36	214	T.constructor = cls;
37	214	return new T(arguments);
38		};
39		//类的属性，不放在原型上，实例化的时候调用
40	36	cls.__prop = {};
41	36	cls.extend = function(prop){
42	37	if (isFunction(prop)) {
43	32	prop = prop();
44		}
45	37	if (isObject(prop)) {
46	35	for(var name in prop){
47	334	var val = prop[name];
48	334	if (isFunction(val)) {
49	293	this.prototype[name] = val;
50		}else{
51	41	cls.__prop[name] = isObject(val) ? extend({}, val) : val;
52		}
53		}
54		}
55	37	return this;
56		};
57	36	cls.inherits = function(superCls){
58	25	util.inherits(this, superCls);
59		//将父级的属性复制到当前类上
60	25	extend(cls.__prop, superCls.__prop);
61	25	return this;
62		};
63	36	if (superCls === true && isFunction(prop)) {
64	1	superCls = prop;
65	1	prop = undefined;
66		}
67	36	if (isFunction(superCls)) {
68	25	cls.inherits(superCls);
69		}
70		//调用父级方法
71	36	cls.prototype.super = cls.prototype.super_ = function(name, data){
72		//如果当前类没有这个方法，则直接返回。
73		//用于在a方法调用父级的b方法
74	51	if (!this[name]) {
75	1	return;
76		}
77	50	var super_ = this.constructor.super_;
78		//如果父级没有这个方法，那么直接返回
79	50	if (!isFunction(super_.prototype[name])) {
80	1	return;
81		}
82		//如果参数不是数组，自动转为数组
83	49	if (!isArray(data)) {
84	49	data = [data];
85		}
86	49	while(1){
87	50	if (this[name] === super_.prototype[name] && super_.super_) {
88	1	super_ = super_.super_;
89		}else{
90	49	break;
91		}
92		}
93	49	var method = super_.prototype[name];
94	49	delete super_.prototype[name];
95	49	var ret = method.apply(this, data);
96	49	super_.prototype[name] = method;
97	49	return ret;
98		};
99	36	if (prop) {
100	35	cls.extend(prop);
101		}
102	36	return cls;
103		};
104		/**
105		* extend, from jquery，具有深度复制功能
106		* @return {[type]} [description]
107		*/
108	1	global.extend = function(){
109	1163	'use strict';
110	1163	var args = [].slice.call(arguments);
111	1163	var deep = true;
112	1163	var target = args.shift();
113	1163	if (isBoolean(target)) {
114	511	deep = target;
115	511	target = args.shift();
116		}
117	1163	target = target \|\| {};
118	1163	var length = args.length;
119	1163	var options, name, src, copy, copyAsArray, clone;
120	1163	for(var i = 0; i < length; i++){
121	1538	options = args[i] \|\| {};
122	1538	if (isFunction(options)) {
123	1	options = options();
124		}
125	1538	for(name in options){
126	1988	src = target[name];
127	1988	copy = options[name];
128	1988	if (src === copy) {
129	298	continue;
130		}
131	1690	if (deep && copy && (isObject(copy) \|\| (copyAsArray = isArray(copy) ))) {
132	509	if (copyAsArray) {
133	278	copyAsArray = false;
134	278	clone = src && isArray(src) ? src : [];
135		}else{
136	231	clone = src && isObject(src) ? src : {};
137		}
138	509	target[name] = extend(deep, clone, copy);
139	1181	}else if (copy !== undefined) {
140	1181	target[name] = copy;
141		}
142		}
143		}
144	1163	return target;
145		};
146
147
148		//Object上toString方法
149	1	var toString = Object.prototype.toString;
150
151		/**
152		* 是否是boolean
153		* @param {[type]} obj
154		* @return {Boolean}
155		*/
156	1	global.isBoolean = function(obj){
157	1401	'use strict';
158	1401	return toString.call(obj) === '[object Boolean]';
159		};
160		/**
161		* 是否是数字
162		* @param {[type]} obj [description]
163		* @return {Boolean} [description]
164		*/
165	1	global.isNumber = function(obj){
166	572	'use strict';
167	572	return toString.call(obj) === '[object Number]';
168		};
169		/**
170		* 是否是个对象
171		* @param {[type]} obj [description]
172		* @return {Boolean} [description]
173		*/
174	1	global.isObject = function(obj){
175	3843	'use strict';
176	3843	if (isBuffer(obj)) {
177	2	return false;
178		}
179	3841	return toString.call(obj) === '[object Object]';
180		};
181		/**
182		* 是否是字符串
183		* @param {[type]} obj [description]
184		* @return {Boolean} [description]
185		*/
186	1	global.isString = function(obj){
187	2957	'use strict';
188	2957	return toString.call(obj) === '[object String]';
189		};
190		/**
191		* 是否是个function
192		* @param {[type]} obj [description]
193		* @return {Boolean} [description]
194		*/
195	1	global.isFunction = function(obj){
196	2745	'use strict';
197	2745	return typeof obj === 'function';
198		};
199		/**
200		* 是否是日期
201		* @return {Boolean} [description]
202		*/
203	1	global.isDate = function(obj){
204	5	'use strict';
205	5	return util.isDate(obj);
206		};
207		/**
208		* 是否是正则
209		* @param {[type]} reg [description]
210		* @return {Boolean} [description]
211		*/
212	1	global.isRegexp = function(obj){
213	45	'use strict';
214	45	return util.isRegExp(obj);
215		};
216		/**
217		* 是否是个错误
218		* @param {[type]} obj [description]
219		* @return {Boolean} [description]
220		*/
221	1	global.isError = function(obj){
222	4	'use strict';
223	4	return util.isError(obj);
224		};
225		/**
226		* 判断对象是否为空
227		* @param {[type]} obj
228		* @return {Boolean}
229		*/
230	1	global.isEmpty = function(obj){
231	603	'use strict';
232	603	if (isObject(obj)) {
233	329	var key;
234	329	for(key in obj){
235	278	return false;
236		}
237	51	return true;
238	274	}else if (isArray(obj)) {
239	96	return obj.length === 0;
240	178	}else if (isString(obj)) {
241	2	return obj.length === 0;
242	176	}else if (isNumber(obj)) {
243	4	return obj === 0;
244	172	}else if (obj === null \|\| obj === undefined) {
245	169	return true;
246	3	}else if (isBoolean(obj)) {
247	2	return !obj;
248		}
249	1	return false;
250		};
251		/**
252		* 是否是个标量
253		* @param {[type]} obj [description]
254		* @return {Boolean} [description]
255		*/
256	1	global.isScalar = function(obj){
257	147	'use strict';
258	147	return isBoolean(obj) \|\| isNumber(obj) \|\| isString(obj);
259		};
260		/**
261		* 是否是个数组
262		* @type {Boolean}
263		*/
264	1	global.isArray = Array.isArray;
265		/**
266		* 是否是IP
267		* @type {Boolean}
268		*/
269	1	global.isIP = net.isIP;
270	1	global.isIP4 = net.isIP4;
271	1	global.isIP6 = net.isIP6;
272		/**
273		* 是否是个文件
274		* @param {[type]} p [description]
275		* @return {Boolean} [description]
276		*/
277	1	global.isFile = function(p){
278	122	'use strict';
279	122	if (!fs.existsSync(p)) {
280	77	return false;
281		}
282	45	var stats = fs.statSync(p);
283	45	return stats.isFile();
284		};
285		/**
286		* 是否是个目录
287		* @param {[type]} p [description]
288		* @return {Boolean} [description]
289		*/
290	1	global.isDir = function(p){
291	16	'use strict';
292	16	if (!fs.existsSync(p)) {
293	2	return false;
294		}
295	14	var stats = fs.statSync(p);
296	14	return stats.isDirectory();
297		};
298		/**
299		* 是否是buffer
300		* @type {Boolean}
301		*/
302	1	global.isBuffer = Buffer.isBuffer;
303		/**
304		* 是否是个数字的字符串
305		* @param {[type]} obj [description]
306		* @return {Boolean} [description]
307		*/
308	1	var numberReg = /^((\-?\d\.?\d(?:e[+-]?\d(?:\d?\.?\|\.?\d?)\d)?)\|(0[0-7]+)\|(0x[0-9a-f]+))$/i;
309	1	global.isNumberString = function(obj){
310	14	'use strict';
311	14	return numberReg.test(obj);
312		};
313		/**
314		* 判断是否是个promise
315		* @param {[type]} obj [description]
316		* @return {Boolean} [description]
317		*/
318	1	global.isPromise = function(obj){
319	532	'use strict';
320	532	return !!(obj && typeof obj.then === 'function');
321		};
322
323		/**
324		* 判断一个文件或者目录是否可写
325		* @param {[type]} p [description]
326		* @return {Boolean} [description]
327		*/
328	1	global.isWritable = function(p){
329	3	'use strict';
330	3	if (!fs.existsSync(p)) {
331	1	return false;
332		}
333	2	var stats = fs.statSync(p);
334	2	var mode = stats.mode;
335	2	var uid = process.getuid ? process.getuid() : 0;
336	2	var gid = process.getgid ? process.getgid() : 0;
337	2	var owner = uid === stats.uid;
338	2	var group = gid === stats.gid;
339	2	return !!(owner && (mode & parseInt('00200', 8)) \|\|
340		group && (mode & parseInt('00020', 8)) \|\|
341		(mode & parseInt('00002', 8)));
342		};
343
344		/**
345		* 递归创建目录，同步模式
346		* @param {[type]} p [description]
347		* @param {[type]} mode [description]
348		* @return {[type]} [description]
349		*/
350	1	global.mkdir = function(p, mode){
351	83	'use strict';
352	83	mode = mode \|\| '0777';
353	83	if (fs.existsSync(p)) {
354	75	chmod(p, mode);
355	75	return true;
356		}
357	8	var pp = path.dirname(p);
358	8	if (fs.existsSync(pp)) {
359	7	fs.mkdirSync(p, mode);
360		}else{
361	1	mkdir(pp, mode);
362	1	mkdir(p, mode);
363		}
364	8	return true;
365		};
366		/**
367		* 递归的删除目录，返回promise
368		* @param string p 要删除的目录
369		* @param boolean reserve 是否保留当前目录，只删除子目录
370		* @return Promise
371		*/
372	1	global.rmdir = function(p, reserve){
373	9	'use strict';
374	9	if (!isDir(p)) {
375	1	return getPromise();
376		}
377	8	var deferred = getDefer();
378	8	fs.readdir(p, function(err, files){
379	8	if (err) {
380	1	return deferred.reject(err);
381		}
382	7	var promises = files.map(function(item){
383	2	var filepath = path.normalize(p + '/' + item);
384	2	if (isDir(filepath)) {
385	1	return rmdir(filepath, false);
386		}else{
387	1	var deferred = getDefer();
388	1	fs.unlink(filepath, function(err){
389	1	return err ? deferred.reject(err) : deferred.resolve();
390		})
391	1	return deferred.promise;
392		}
393		})
394	7	var promise = files.length === 0 ? getPromise() : Promise.all(promises);
395	7	return promise.then(function(){
396	7	if (!reserve) {
397	7	var deferred = getDefer();
398	7	fs.rmdir(p, function(err){
399	7	return err ? deferred.reject(err) : deferred.resolve();
400		})
401	7	return deferred.promise;
402		}
403		}).then(function(){
404	6	deferred.resolve();
405		}).catch(function(err){
406	1	deferred.reject(err);
407		})
408		})
409	8	return deferred.promise;
410		}
411		/**
412		* 修改目录或者文件权限
413		* @param {[type]} p [description]
414		* @param {[type]} mode [description]
415		* @return {[type]} [description]
416		*/
417	1	global.chmod = function(p, mode){
418	116	'use strict';
419	116	mode = mode \|\| '0777';
420	116	if (!fs.existsSync(p)) {
421	1	return true;
422		}
423	115	return fs.chmodSync(p, mode);
424		};
425		/**
426		* 获取文件内容
427		* @param {[type]} file [description]
428		* @return {[type]} [description]
429		*/
430	1	global.getFileContent = function(file, encoding){
431	18	'use strict';
432	18	if (!fs.existsSync(file)) {
433	3	return '';
434		}
435	15	return fs.readFileSync(file, encoding \|\| 'utf8');
436		};
437		/**
438		* 设置文件内容
439		* @param {[type]} file [description]
440		* @param {[type]} data [description]
441		* @return {[type]} [description]
442		*/
443	1	global.setFileContent = function(file, data){
444	2	'use strict';
445	2	var filepath = path.dirname(file);
446	2	mkdir(filepath);
447	2	return fs.writeFileSync(file, data);
448		};
449		/**
450		* 大写首字符
451		* @param {[type]} name [description]
452		* @return {[type]} [description]
453		*/
454	1	global.ucfirst = function(name){
455	1849	'use strict';
456	1849	name = (name \|\| '') + '';
457	1849	return name.substr(0,1).toUpperCase() + name.substr(1).toLowerCase();
458		};
459		/**
460		* 获取字符串的md5
461		* @param {[type]} str [description]
462		* @return {[type]} [description]
463		*/
464	1	global.md5 = function(str){
465	77	'use strict';
466	77	var instance = crypto.createHash('md5');
467	77	instance.update(str + '');
468	77	return instance.digest('hex');
469		};
470		/**
471		* 生成一个promise,如果传入的参数是promise则直接返回
472		* @param {[type]} obj [description]
473		* @return {[type]} [description]
474		*/
475	1	global.getPromise = function(obj, reject){
476	527	'use strict';
477	527	if (isPromise(obj)) {
478	10	return obj;
479		}
480	517	if (reject) {
481	24	return Promise.reject(obj);
482		}
483	493	return Promise.resolve(obj);
484		};
485		/**
486		* 生成一个defer对象
487		* @return {[type]} [description]
488		*/
489	1	global.getDefer = function(){
490	86	'use strict';
491	86	var deferred = {};
492	86	deferred.promise = new Promise(function(resolve, reject){
493	86	deferred.resolve = resolve;
494	86	deferred.reject = reject;
495		});
496	86	return deferred;
497		};
498		/**
499		* 快速生成一个object
500		* @param {[type]} key [description]
501		* @param {[type]} value [description]
502		* @return {[type]} [description]
503		*/
504	1	global.getObject = function(key, value){
505	31	'use strict';
506	31	var obj = {};
507	31	if (!isArray(key)) {
508	22	obj[key] = value;
509	22	return obj;
510		}
511	9	key.forEach(function(item, i){
512	17	obj[item] = value[i];
513		});
514	9	return obj;
515		};
516		/**
517		* 将数组变成对象
518		* @param {[type]} arr [description]
519		* @param {[type]} key [description]
520		* @param {[type]} valueKeys [description]
521		* @return {[type]} [description]
522		*/
523	1	global.arrToObj = function(arr, key, valueKey){
524	4	'use strict';
525	4	var result = {};
526	4	var arrResult = [];
527	4	arr.forEach(function(item){
528	8	var keyValue = item[key];
529	8	if (valueKey === null) {
530	4	arrResult.push(keyValue);
531	4	}else if (valueKey) {
532	2	result[keyValue] = item[valueKey];
533		}else{
534	2	result[keyValue] = item;
535		}
536		})
537	4	return valueKey === null ? arrResult : result;
538		}

/Users/welefen/Develop/git/thinkjs/lib/Common/extend.js

100%

13

0

Line	Hits	Source
1		//该文件内容为原生对象的扩展
2
3		/**
4		* 获取对象的值
5		* @param {[type]} obj [description]
6		* @return {[type]} [description]
7		*/
8	1	Object.values = function(obj){
9	173	'use strict';
10	173	var values = [];
11	173	for(var key in obj){
12	1574	if (obj.hasOwnProperty(key)) {
13	1574	values.push(obj[key])
14		}
15		}
16	173	return values;
17		};
18		/**
19		* 数组求和
20		* @return {[type]} [description]
21		*/
22	1	Array.prototype.sum = function(){
23	7	'use strict';
24	7	var count = 0;
25	7	this.forEach(function(item){
26	23	count += parseFloat(item) \|\| 0;
27		});
28	7	return count;
29		};
30

/Users/welefen/Develop/git/thinkjs/lib/Common/function.js

100%

163

0

Line	Hits	Source
1	1	var fs = require('fs');
2	1	var path = require('path');
3
4
5	1	var _alias = {};
6	1	var _autoload_callbacks = [];
7		/**
8		* thinkRequire获取到的路径
9		* @param {[type]} name [description]
10		* @return {[type]} [description]
11		*/
12	1	global.getThinkRequirePath = function(name){
13	365	'use strict';
14	365	if (_alias[name]) {
15	319	return _alias[name];
16		}
17	46	var result = '';
18	46	_autoload_callbacks.some(function(callback){
19	46	result = callback && callback(name);
20	46	if (result) {
21	21	return true;
22		}
23		});
24	46	return result;
25		}
26		/**
27		* 自定义的require, 加入别名功能
28		* @type {[type]}
29		*/
30	1	global.thinkRequire = function(name){
31	314	'use strict';
32		//如果不是字符串则直接返回
33	314	if (!isString(name)) {
34	1	return name;
35		}
36	313	var path = name;
37	313	if (path[0] !== '/') {
38	313	path = getThinkRequirePath(name);
39		}
40	313	if (path) {
41	312	var obj = require(path);
42	312	if (isFunction(obj)) {
43		//修正子类继承的方法获取到正确的文件名
44	282	obj.prototype.__filename = path;
45		}
46	312	return obj;
47		}
48	1	return require(name);
49		};
50		/**
51		* 注册require
52		* @param {Function} callback [description]
53		* @return {[type]} [description]
54		*/
55	1	global.registerAutoload = function(callback){
56	1	'use strict';
57	1	_autoload_callbacks.push(callback);
58		};
59		/**
60		* 别名
61		* @return {[type]} [description]
62		*/
63	1	global.aliasImport = function(alias, classFile){
64	22	'use strict';
65	22	if (isString(alias)) {
66	21	_alias[alias] = classFile;
67		}else{
68	1	_alias = extend(_alias, alias);
69		}
70		};
71
72		//常用类的基类
73	1	['Cache', 'Behavior', 'Controller', 'Session', 'Model', 'Db'].forEach(function(item){
74	6	'use strict';
75	6	global[item] = function(super_, obj){
76	20	if (isString(super_)) {
77	1	return Class(obj, thinkRequire(super_));
78		}
79	19	return Class(super_, thinkRequire(item));
80		};
81		});
82
83
84		/**
85		* 调用一个指定的行为
86		* @param {[type]} name [description]
87		*/
88	1	global.B = function(name, http, data){
89	71	'use strict';
90	71	if (!name) {
91	1	return data;
92		}
93	70	if (typeof name === 'function') {
94	3	return name(http, data);
95		}
96	67	return thinkRequire(name + 'Behavior')(http).run(data);
97		};
98
99		/**
100		* 处理标签扩展
101		* @return {[type]} [description]
102		*/
103	1	global.tag = function(name, http, data){
104	35	'use strict';
105	35	var tags = (C('tag.' + name) \|\| []).slice();
106		//tag处理的数据
107	35	http.tag_data = data;
108	35	if (!tags.length) {
109	15	return getPromise(http.tag_data);
110		}
111	20	var index = 0;
112	20	function runBehavior(){
113	40	var behavior = tags[index++];
114	40	if (!behavior) {
115	20	return getPromise(http.tag_data);
116		}
117	20	var result = B(behavior, http, http.tag_data);
118	20	return getPromise(result).then(function(data){
119		//如果返回值不是undefined，那么认为有返回值
120	20	if (data !== undefined) {
121	18	http.tag_data = data;
122		}
123	20	return runBehavior();
124		})
125		}
126	20	return runBehavior();
127		};
128		/**
129		* 配置读取和写入
130		*/
131	1	var _config = {};
132	1	global.C = function(name, value){
133	792	'use strict';
134		//获取所有的配置
135	792	if (arguments.length === 0) {
136	28	return _config;
137		}
138		//清除所有的配置
139	764	if (name === null) {
140	2	_config = {};
141	2	return;
142		}
143	762	if (isString(name)) {
144	758	name = name.toLowerCase();
145		//name里不含. 一级
146	758	if (name.indexOf('.') === -1) {
147	720	if (value === undefined) {
148	677	return _config[name];
149		}
150	43	_config[name] = value;
151	43	return;
152		}
153		//name中含有. 二级
154	38	name = name.split('.');
155	38	if (value === undefined) {
156	37	value = _config[name[0]] \|\| {};
157	37	return value[name[1]];
158		}
159	1	if (!_config[name[0]]) {
160	1	_config[name[0]] = {};
161		}
162	1	_config[name[0]][name[1]] = value;
163		}else{
164	4	_config = extend(_config, name);
165		}
166		};
167		/**
168		* 实例化Controller类，可以调用一个具体的Action
169		* A('Home/Index'), A('Admin/Index/test')
170		* @param {[type]} name [description]
171		*/
172	1	global.A = function(name, http, data){
173	11	'use strict';
174		//将/转为:，兼容之前的方式
175	11	name = name.replace(/\//g, ':').split(':');
176	11	http.group = name[0];
177	11	http.controller = name[1];
178	11	var App = thinkRequire('App');
179	11	var instance = App.getBaseController(http);
180	11	if (!instance) {
181	2	return instance;
182		}
183	9	var action = name[2];
184	9	if (!action) {
185	1	return instance;
186		}
187	8	http.action = action;
188	8	return getPromise(instance.__initReturn).then(function(){
189	8	if (data && !isArray(data)) {
190	1	data = [data];
191		}
192	8	return App.execAction(instance, action, data);
193		})
194		};
195
196		/**
197		* 快速文件读取和写入
198		* 默认写入到App/Runtime/Data目录下
199		*/
200	1	global.F = function(name, value, rootPath){
201	9	'use strict';
202	9	rootPath = rootPath \|\| DATA_PATH;
203	9	var filePath = rootPath + '/' + name + '.json';
204	9	if (value !== undefined) {
205	4	mkdir(path.dirname(filePath));
206	4	fs.writeFileSync(filePath, JSON.stringify(value));
207	4	chmod(filePath);
208	4	return;
209		}
210	5	if (isFile(filePath)) {
211	4	var content = getFileContent(filePath);
212	4	if (content) {
213	4	return JSON.parse(content);
214		}
215		}
216	1	return false;
217		};
218		/**
219		* 实例化模型
220		*/
221	1	global.D = function(name, config){
222	39	'use strict';
223	39	if (name === undefined) {
224	1	return thinkRequire('Model')(name, config);
225		}
226	38	name = name.split(':');
227	38	name[0] = name[0][0].toUpperCase() + name[0].slice(1);
228	38	var path = getThinkRequirePath(name[0] + 'Model');
229	38	if (path) {
230	17	return thinkRequire(name[0] + 'Model')(name[1], config);
231		}else{
232	21	return thinkRequire(name[1] === 'AdvModel' ? 'AdvModel' : 'Model')(name[0], config);
233		}
234		};
235		/**
236		* 实例化模型基类
237		* @param {[type]} name [description]
238		* @param {[type]} config [description]
239		*/
240	1	global.M = function(name, config){
241	5	'use strict';
242	5	if (name === undefined) {
243	1	return thinkRequire('Model')(name, config);
244		}
245	4	name = name.split(':');
246	4	var model = name[1] === 'AdvModel' ? 'AdvModel' : 'Model';
247	4	return thinkRequire(model)(name[0], config)
248		}
249		/**
250		* 缓存的设置和读取
251		* 获取返回的是一个promise
252		*/
253	1	global.S = function(name, value, options){
254	29	'use strict';
255	29	if (isNumber(options)) {
256	4	options = {timeout: options};
257	25	}else if (options === true) {
258	9	options = {type: true}
259		}
260	29	options = options \|\| {};
261	29	var type = options.type === undefined ? C('cache_type') : options.type;
262	29	var cls = (type === true ? '' : ucfirst(type)) + 'Cache';
263	29	var instance = thinkRequire(cls)(options);
264	29	if (value === undefined) {//获取缓存
265	12	return instance.get(name);
266	17	}else if (value === null) {
267	3	return instance.rm(name); //删除缓存
268	14	}else if (isFunction(value)) { //获取缓存，如果不存在，则自动从回调里获取
269	1	var fromCache = false;
270	1	var cacheData = null;
271	1	return instance.get(name).then(function(data){
272	1	fromCache = !isEmpty(data);
273	1	return fromCache ? data : value();
274		}).then(function(data){
275	1	cacheData = data;
276	1	return fromCache ? data : S(name, data, options);
277		}).then(function(){
278	1	return cacheData;
279		})
280		}else{
281	13	return instance.set(name, value, options.timeout);
282		}
283		};
284		/**
285		* 语言
286		* @param {[type]} name [description]
287		*/
288	1	global.L = function(name){
289	2	'use strict';
290	2	return name;
291		};

/Users/welefen/Develop/git/thinkjs/lib/Conf/alias.js

100%

1

0

Line	Hits	Source
1		/**
2		* 模块别名，模块名到具体的路径，模块名不能有重复
3		* 使用thinkRequire加载模块时有效
4		* @type {Object}
5		*/
6	1	module.exports = {
7		Controller: THINK_LIB_PATH + '/Core/Controller.js',
8		App: THINK_LIB_PATH + '/Core/App.js',
9		Behavior: THINK_LIB_PATH + '/Util/Behavior.js',
10		Cache: THINK_LIB_PATH + '/Util/Cache.js',
11		Db: THINK_LIB_PATH + '/Core/Db.js',
12		Dispatcher: THINK_LIB_PATH + '/Core/Dispatcher.js',
13		Filter: THINK_LIB_PATH + '/Util/Filter.js',
14		Http: THINK_LIB_PATH + '/Core/Http.js',
15		Log: THINK_LIB_PATH + '/Util/Log.js',
16		Model: THINK_LIB_PATH + '/Core/Model.js',
17		Session: THINK_LIB_PATH + '/Util/Session.js',
18		Think: THINK_LIB_PATH + '/Core/Think.js',
19		Valid: THINK_LIB_PATH + '/Util/Valid.js',
20		View: THINK_LIB_PATH + '/Core/View.js',
21		Cookie: THINK_LIB_PATH + '/Util/Cookie.js',
22		WebSocket: THINK_LIB_PATH + '/Util/WebSocket.js',
23		Auth: THINK_LIB_PATH + '/Util/Auth.js'
24		};

/Users/welefen/Develop/git/thinkjs/lib/Conf/config.js

100%

1

0

Line	Hits	Source
1		/**
2		* 框架默认配置
3		* 可以在App/Conf/config.js里修改下面的配置值
4		* @type {Object}
5		*/
6	1	module.exports = {
7		port: 8360, //监听端口
8		use_proxy: false, //是否使用代理访问，如：nginx。开启后不能通过ip+端口直接访问
9		encoding: 'utf8', //输出数据的编码
10		url_pathname_prefix: '', //不解析的pathname前缀
11		url_pathname_suffix: '.html', //不解析的pathname后缀，这样利于seo
12		app_tag_on: true, //是否支持标签功能
13		url_resource_on: true, //是否监听静态资源类请求
14		url_resource_reg: /^(resource\/\|static\/\|favicon\.ico)/, //判断是否是静态资源的正则
15		url_route_on: true, //是否开启自定义路由功能
16
17		post_json_content_type: ['application/json'], //post数据为json时的content-type
18		post_max_file_size: 1024 * 1024 * 1024, //上传文件大小限制，默认1G
19		post_max_fields: 100, //最大表单数，默认为100
20		post_max_fields_size: 2 * 1024 * 1024, //单个表单长度最大值，默认为2MB
21
22		app_group_list: ['Home', 'Admin', 'Restful'], //分组列表
23		default_group: 'Home', //默认分组
24		default_controller: 'Index', //默认模块
25		default_action: 'index', //默认Action
26		call_controller: 'Home:Index:_404', //controller不存在时执行方法，此配置表示调用Home分组下IndexController的_404Action方法
27		call_method: '__call', //当找不到方法时调用什么方法，这个方法存在时才有效
28		before_action: '__before', //调用一个action前调用的方法，会将action名传递进去
29		after_action: '__after', //调用一个action之后调用的方法，会将action名传递进去
30		url_params_bind: true, //方法参数绑定,将URL参数值绑定到action的参数上
31		action_suffix: 'Action', //action后缀
32		url_callback_name: 'callback', //jsonp格式的callback名字
33		json_content_type: 'application/json', //发送json时的content-type
34		auto_send_content_type: true, //是否自动发送Content-Type,默认值为`tpl_content_type`配置值
35		log_process_pid: true, //记录进程的id,方便其他脚本处理。
36		use_cluster: false, //是否使用cluster，默认不使用，0：为cpu的数量，可以自定义值
37		autoload_path: {}, //autoload查找的path，用于thinkRequire加载自定义库的时候查找
38		create_server_fn: '', //自定义create server全局函数名，可以在Common/common.js里实现
39
40		restful_group: 'Restful', //RESTFUL API默认分组
41
42		load_ext_config: [], //加载额外的配置文件 CONF_PATH
43		load_ext_file: [], //加载额外的文件 COMMON_PATH
44
45		use_websocket: false, //是否使用websocket
46		websocket_allow_origin: '', //允许从那里发送过来的websocket，可以是字符串、数组、回调函数，为空表示不检测
47		websocket_sub_protocal: '', //websocket子协议，可以是个字符串也可以是回调函数
48		websocket_message_handle: undefined, //websocket消息处理函数
49
50		error_tpl_path: THINK_PATH + '/View/error.html', //错误页模版
51		error_no_key: 'errno', //错误number的key
52		error_no_default_value: 1000, //错误号默认值
53		error_msg_key: 'errmsg', //错误消息的key
54
55		cookie_domain: '', //cookie有效域名
56		cookie_path: '/', //cookie路径
57		cookie_timeout: 0, //cookie失效时间，0为浏览器关闭，单位：秒
58
59		session_name: 'thinkjs', //session对应的cookie名称
60		session_type: 'File', //session存储类型, 空为内存，还可以为File
61		session_path: '', //File类型下文件存储位置，默认为系统的tmp目录
62		session_options: {}, //session对应的cookie选项
63		session_sign: '', //session对应的cookie使用签名
64		session_timeout: 24 * 3600, //服务器上session失效时间，单位：秒
65
66		db_type: 'mysql', // 数据库类型
67		db_host: '127.0.0.1', // 服务器地址
68		db_port: '', // 端口
69		db_name: '', // 数据库名
70		db_user: 'root', // 用户名
71		db_pwd: '', // 密码
72		db_prefix: 'think_', // 数据库表前缀
73		db_fieldtype_check: false, // 是否进行字段类型检查
74		db_fields_cache: true, // 启用字段缓存
75		db_charset: 'utf8', // 数据库编码默认采用utf8
76		db_nums_per_page: 20, //默认每页显示的条数
77		db_like_fields: [], //自动进行模糊查询,\|连接，如: ['title', 'content']
78		db_cache_on: true, //是否启用查询缓存，如果关闭那么cache方法则无效
79		db_cache_type: '', //缓存类型，默认为内存缓存
80		db_cache_path: CACHE_PATH + '/db', //缓存路径，File类型下有效
81		db_cache_timeout: 3600, //缓存时间，默认为1个小时
82		db_log_sql: false, //是否打印sql语句
83
84		tpl_content_type: 'text/html', //模版输出类型
85		tpl_file_suffix: '.html', //模版文件名后缀
86		tpl_file_depr: '_', //controller和action之间的分隔符
87		tpl_engine_type: 'ejs', //模版引擎名称
88		tpl_engine_config: {},
89
90		log_record: false, //是否记录日志，开启后会重写console.log等系列方法
91		log_file_path: LOG_PATH, //日志文件存在路径
92		log_console_type: ['error'], //默认只接管console.error日志
93
94		cache_type: 'File', //数据缓存类型
95		cache_timeout: 6 * 3600, //数据缓存有效期，单位: 秒
96		cache_path: CACHE_PATH, //缓存路径设置 (File缓存方式有效)
97		cache_file_suffix: '.json', //File缓存方式下文件后缀名
98		cache_gc_hour: [4], //缓存清除的时间点，数据为小时
99
100		html_cache_on: false, //HTML静态缓存
101		html_cache_timeout: 3600, //缓存时间，单位为秒
102		html_cache_rules: {}, //缓存规则
103		html_cache_path: CACHE_PATH + '/html',
104		html_cache_file_callback: undefined, //生成缓存文件的回调函数
105		html_cache_file_suffix: '.html', //缓存文件后缀名
106
107		memcache_host: '127.0.0.1', //memcache host
108		memcache_port: 11211, //memecache端口
109		};

/Users/welefen/Develop/git/thinkjs/lib/Conf/mode.js

100%

1

0

Line	Hits	Source
1		/**
2		* 不同模式下的配置文件
3		* 由于每个模式下的配置可能都比较少，所以放在一个文件里
4		* @type {Object}
5		*/
6	1	module.exports = {
7		cli: {
8		use_cluster: false, //使用cluster
9		html_cache_on: false,
10		log_process_pid: false,
11		clear_require_cache: false,
12		auto_close_db: false //自动关闭数据库连接
13		},
14		cli_debug: {
15		clear_require_cache: false
16		}
17		};

/Users/welefen/Develop/git/thinkjs/lib/Conf/tag.js

75%

12

9

3

Line	Hits	Source
1		/**
2		* 系统标签配置
3		* 可以在App/Conf/tag.js里进行修改
4		* @type {Object}
5		*/
6
7		/**
8		* 命令行模式下执行后自动关闭数据库连接
9		* @return {[type]} [description]
10		*/
11	1	var closeDbConnect = function(){
12	1	'use strict';
13	1	if(C('auto_close_db') && APP_MODE === 'cli'){
14	0	thinkRequire('Model').close();
15		}
16		}
17		/**
18		* 解析提交的json数据
19		* @param {[type]} http [description]
20		* @return {[type]} [description]
21		*/
22	1	var jsonParse = function(http){
23	1	'use strict';
24	1	var jsonConentType = C('post_json_content_type');
25	1	if (!isArray(jsonConentType)) {
26	0	jsonConentType = [jsonConentType];
27		}
28	1	if (jsonConentType.indexOf(http.contentType) > -1) {
29	0	http.post = JSON.parse(http.payload) \|\| {};
30		}
31		}
32
33	1	module.exports = {
34		//应用初始化
35		app_init: [],
36		//表单数据解析
37		form_parse: [jsonParse],
38		//pathinfo解析
39		path_info: [],
40		//静态资源请求检测
41		resource_check: ['CheckResource'],
42		//路由检测
43		route_check: ['CheckRoute'],
44		//应用开始
45		app_begin: ['ReadHtmlCache'],
46		//action执行初始化
47		action_init: [],
48		//模版解析初始化
49		view_init: [],
50		//定位模版文件
51		view_template: ['LocationTemplate'],
52		//模版解析
53		view_parse: ['ParseTemplate'],
54		//模版内容过滤
55		view_filter: [],
56		//模版解析结束
57		view_end: ['WriteHtmlCache'],
58		//action结束
59		action_end: [],
60		//应用结束
61		app_end: [closeDbConnect]
62		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/CheckResourceBehavior.js

100%

25

0

Line	Hits	Source
1	1	var fs = require('fs');
2	1	var mime = require('mime');
3		/**
4		* 静态资源请求
5		* @return {[type]} [description]
6		*/
7	1	module.exports = Behavior(function(){
8	1	'use strict';
9	1	return {
10		options: {
11		'url_resource_on': false
12		},
13		run: function(){
14	5	if (!RESOURCE_PATH \|\| !this.options.url_resource_on \|\| !this.http.pathname) {
15	1	return false;
16		}
17	4	var pathname = this.http.pathname;
18	4	if (pathname.indexOf('/') === 0) {
19	1	pathname = pathname.substr(1);
20		}
21	4	var reg = C('url_resource_reg');
22		//通过正则判断是否是静态资源请求
23	4	if (!reg.test(pathname)) {
24	1	return false;
25		}
26
27	3	var file = RESOURCE_PATH + '/' + pathname;
28	3	var res = this.http.res;
29	3	if (fs.existsSync(file)) {
30	2	var contentType = mime.lookup(file);
31	2	var fileStream = fs.createReadStream(file);
32	2	res.setHeader('Content-Type', contentType + '; charset=' + C('encoding'));
33	2	fileStream.pipe(res);
34	2	fileStream.on('end', function(){
35	2	res.end();
36		});
37		}else{
38	1	res.statusCode = 404;
39	1	res.end();
40		}
41		//返回一个pendding promise, 不让后续执行
42	2	return getDefer().promise;
43		}
44		};
45		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/CheckRouteBehavior.js

100%

108

0

Line	Hits	Source
1		/**
2		* 检测路由行为
3		* 通过自定义路由识别到对应的URL上
4		* @return {[type]} [description]
5		*/
6	1	var url = require('url');
7	1	var Dispatcher = thinkRequire('Dispatcher');
8
9	1	module.exports = Behavior(function(){
10	1	'use strict';
11	1	return {
12		options: {
13		'url_route_on': false, //是否开启自定义URL路由
14		'url_route_rules': [] //自定义URL路由规则
15		},
16		run: function(){
17	40	if (!this.options.url_route_on) {
18	1	return false;
19		}
20	39	var routes = this.options.url_route_rules;
21	39	var length = routes.length;
22	39	if (length === 0) {
23	1	return false;
24		}
25	38	var pathname = this.http.pathname;
26	38	var match;
27	38	for(var i = 0; i < length; i++){
28	38	var route = routes[i];
29	38	var rule = route[0];
30		//正则路由
31	38	if (isRegexp(rule)) {
32	28	match = pathname.match(rule);
33	28	if (match) {
34	26	var result = this.parseRegExp(match, route[1], pathname);
35	26	if (result) {
36	25	return result;
37		}
38		}
39		}else{
40		//字符串路由
41	10	match = this.checkUrlMatch(pathname, rule);
42	10	if (match) {
43	6	return this.parseRule(rule, route[1], pathname);
44		}
45		}
46		}
47	7	return false;
48		},
49		/**
50		* 分割pathname
51		* @param {[type]} pathname [description]
52		* @return {[type]} [description]
53		*/
54		split: function(pathname){
55	85	var ret = [];
56	85	var j = 0;
57	85	pathname = pathname.split('/');
58	85	for(var i = 0, length = pathname.length, item; i < length; i++){
59	178	item = pathname[i].trim();
60	178	if (item) {
61	153	ret[j++] = item;
62		}
63		}
64	85	return ret;
65		},
66		/**
67		* 解析字符串路由
68		* @param {[type]} rule [description]
69		* @param {[type]} route [description]
70		* @param {[type]} pathname [description]
71		* @return {[type]} [description]
72		*/
73		parseRule: function(rule, route, pathname){
74	6	route = this.getRoute(route);
75	6	if (!route) {
76	1	return false;
77		}
78	5	pathname = this.split(pathname);
79	5	rule = this.split(rule);
80	5	var matches = [];
81	5	var self = this;
82	5	rule.forEach(function(item){
83	10	var pathitem = pathname.shift();
84	10	if (item.indexOf(':') === 0) {
85	4	if (item.indexOf('\\') === -1) {
86	2	self.http.get[item.substr(1)] = pathitem;
87		}else{
88	2	matches.push(pathitem);
89		}
90		}
91		});
92		//将剩余的pathname分割为querystring
93	5	if (pathname.length) {
94	2	for(var i = 0,length = Math.ceil(pathname.length)/2; i < length; i++){
95	2	this.http.get[pathname[i * 2]] = pathname[i * 2 + 1] \|\| '';
96		}
97		}
98	5	route = route.replace(/:(\d+)/g, function(a, b){
99	2	return matches[b - 1] \|\| '';
100		});
101	5	this.parseUrl(route);
102	5	return true;
103		},
104		/**
105		* 检测URL是否匹配
106		* @param {[type]} pathname [description]
107		* @param {[type]} rule [description]
108		* @return {[type]} [description]
109		*/
110		checkUrlMatch: function(pathname, rule){
111	10	pathname = this.split(pathname);
112	10	rule = this.split(rule);
113	10	return rule.every(function(item, i){
114	19	if (item.indexOf(':') === 0) {
115	7	if (item.indexOf('\\') > -1) {
116	5	var type = item.substr(-1);
117	5	var reg;
118	5	switch(type){
119		case 'd':
120	2	reg = /^\d+$/;
121	2	break;
122		case 'w':
123	3	reg = /^\w+$/
124	3	break;
125		}
126	5	if (reg && !reg.test(pathname[i])) {
127	2	return false;
128		}
129		}
130		}else{
131	12	var pitem = pathname[i] \|\| '';
132	12	if (pitem.toLowerCase() !== item.toLowerCase()) {
133	2	return false;
134		}
135		}
136	15	return true;
137		});
138		},
139		/**
140		* 解析转化后的url
141		* @param {[type]} urlInfo [description]
142		* @return {[type]} [description]
143		*/
144		parseUrl: function(urlInfo){
145	30	urlInfo = url.parse(urlInfo, true);
146	30	if (urlInfo.query) {
147	30	for(var key in urlInfo.query){
148	48	if (urlInfo.query[key] \|\| !(key in this.http.get)) {
149	45	this.http.get[key] = urlInfo.query[key];
150		}
151		}
152		}
153	30	var pathname = urlInfo.pathname \|\| '';
154		// 过滤调用pathname最后有/的情况
155	30	pathname = this.split(pathname);
156	30	this.http.action = Dispatcher.getAction(pathname.pop());
157	30	this.http.controller = Dispatcher.getController(pathname.pop());
158	30	this.http.group = Dispatcher.getGroup(pathname.pop());
159		},
160		/**
161		* 获取route
162		* @param {[type]} route [description]
163		* @return {[type]} [description]
164		*/
165		getRoute: function(route, matches){
166	32	if (isObject(route)) {
167		//对应的请求类型
168	3	for(var method in route){
169		//由于请求类型没有包含关系，这里可以直接用indexOf判断
170	3	if (method.toUpperCase().indexOf(this.http.method) > -1) {
171	1	return route[method];
172		}
173		}
174	2	return;
175		}
176	29	var routeUpper = route.toUpperCase();
177		//RESTFUL API
178	29	if (routeUpper === 'RESTFUL' \|\| routeUpper.indexOf('RESTFUL:') === 0) {
179	21	var group = route.split(':')[1] \|\| C('restful_group');
180	21	route = group + '/' + matches[1] + '/' + this.http.method.toLowerCase() + '?resource=' + matches[1];
181	21	if (matches[2]) {
182	13	route += '&id=' + matches[2];
183		}
184		//设置变量到http对象上，方便后续使用
185	21	this.http.isRestful = true;
186	21	return route;
187		}
188	8	return route;
189		},
190		/**
191		* 正则匹配路由
192		* @param {[type]} matches [description]
193		* @param {[type]} route [description]
194		* @param {[type]} pathname [description]
195		* @return {[type]} [description]
196		*/
197		parseRegExp: function(matches, route, pathname){
198	26	route = this.getRoute(route, matches);
199	26	if (!route) {
200	1	return false;
201		}
202		//替换路由字符串里的:1, :2 匹配都的值
203		//如：group/detail?date=:1&groupId=:2&page=:3
204	25	route = route.replace(/:(\d+)/g, function(a, b){
205	12	return matches[b] \|\| '';
206		});
207	25	pathname = pathname.replace(matches[0], '');
208	25	pathname = this.split(pathname);
209		//将剩余的pathname分割为querystring
210	25	if (pathname.length) {
211	1	for(var i = 0,length = Math.ceil(pathname.length)/2; i < length; i++){
212	1	this.http.get[pathname[i * 2]] = pathname[i * 2 + 1] \|\| '';
213		}
214		}
215	25	this.parseUrl(route);
216	25	return true;
217		}
218		};
219		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/DenyIpBehavior.js

93%

15

14

1

Line	Hits	Source
1		/**
2		* 阻止ip来源访问
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Behavior(function(){
6	1	'use strict';
7	1	return {
8		options: {
9		deny_ip: [] //阻止的ip列表
10		},
11		run: function(){
12	2	if (this.options.deny_ip.length === 0) {
13	1	return true;
14		}
15	1	var clientIps = this.http.ip().split('.');
16	1	var flag = this.options.deny_ip.some(function(item){
17	1	return item.split('.').every(function(num, i){
18	4	if (num === '*' \|\| num === clientIps[i]) {
19	4	return true;
20		}
21		});
22		});
23		//如果在阻止的ip在列表里，则返回一个pendding promise，让后面的代码不执行
24	1	if (flag) {
25	1	this.http.res.statusCode = 403;
26	1	this.http.res.end();
27	1	return getDefer().promise;
28		}
29	0	return true;
30		}
31		};
32		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/LocationTemplateBehavior.js

100%

15

0

Line	Hits	Source
1		/**
2		* 定位模版路径
3		* @return {[type]} [description]
4		*/
5
6	1	module.exports = Behavior(function(){
7	1	'use strict';
8	1	return {
9		run: function(templateFile){
10		//templateFile = templateFile \|\| '';
11	6	if (!templateFile) {
12		//根据group, controller, action自动生成
13	1	templateFile = [
14		VIEW_PATH, '/', this.http.group, '/',
15		this.http.controller.toLowerCase(),
16		C('tpl_file_depr'),
17		this.http.action.toLowerCase(),
18		C('tpl_file_suffix')
19		].join('');
20	5	}else if(templateFile.indexOf('/') > -1){
21		//自动追加VIEW_PATH
22	1	if (templateFile.indexOf('/') !== 0) {
23	1	templateFile = VIEW_PATH + '/' + templateFile;
24		}
25	4	}else if(templateFile.indexOf(C('tpl_file_suffix')) === -1){
26	4	var path = templateFile.split(':');
27	4	var action = path.pop();
28	4	var controller = path.pop() \|\| this.http.controller.toLowerCase();
29	4	var group = ucfirst(path.pop()) \|\| this.http.group;
30	4	templateFile = [
31		VIEW_PATH, '/', group, '/',
32		controller,
33		C('tpl_file_depr'),
34		action,
35		C('tpl_file_suffix')
36		].join('');
37		}
38	6	return templateFile;
39		}
40		};
41		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/ParseTemplateBehavior.js

100%

10

0

Line	Hits	Source
1		/**
2		* 调用对应的模版引擎解析模版
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Behavior(function(){
6	1	'use strict';
7	1	return {
8		run: function(data){
9	10	var file = data.file;
10		//将模版文件路径写入到http对象上，供writehtmlcache里使用
11	10	this.http.tpl_file = file;
12	10	var engine = C('tpl_engine_type');
13		//不使用模版引擎，直接返回文件内容
14	10	if (!engine) {
15	2	return getFileContent(file);
16		}
17	8	var engineClass = ucfirst(engine) + 'Template';
18	8	return thinkRequire(engineClass).fetch(file, data.var);
19		}
20		};
21		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/ReadHtmlCacheBehavior.js

10%

64

7

57

Line	Hits	Source
1		//获取模版文件
2	1	var getViewFile = thinkRequire('WriteHtmlCacheBehavior').getViewFile;
3	1	var fs = require('fs');
4		/**
5		* 读取HTML缓存
6		* @return {[type]} [description]
7		*/
8	1	module.exports = Behavior(function(){
9	1	'use strict';
10	1	return {
11		options:{
12		'html_cache_on': false, //是否开启缓存
13		'html_cache_timeout': 3600, //缓存时间
14		'html_cache_rules': {}, //缓存规则
15		'html_cache_path': '',
16		'html_cache_file_callback': undefined, //生成缓存文件的回调函数
17		'html_cache_file_suffix': '.html', //缓存文件扩展名
18		},
19		run: function(){
20	1	if (!this.options.html_cache_on \|\| isEmpty(this.options.html_cache_rules)) {
21	1	return false;
22		}
23	0	var cacheTime = this.getCacheTime();
24	0	if (cacheTime === false) {
25	0	return false;
26		}
27	0	if (this.checkCacheTime(cacheTime)) {
28	0	this.responseCacheContent();
29		//return a pending promise
30	0	return getDefer().promise;
31		}
32	0	return false;
33		},
34		/**
35		* 返回缓存内容
36		* @return {[type]} [description]
37		*/
38		responseCacheContent: function(){
39	0	var http = this.http;
40	0	var fileStream = fs.createReadStream(this.options.html_cache_path + '/' + http.html_filename);
41	0	http.setHeader('Content-Type', 'text/html');
42	0	http.sendTime('Exec-Time');
43	0	http.sendCookie();
44	0	fileStream.pipe(http.res);
45	0	fileStream.on('end', function(){
46	0	http.end();
47		});
48		},
49		/**
50		* 获取缓存时间
51		* @return {[type]} [description]
52		*/
53		getCacheTime: function(){
54		/**
55		* rules数据格式
56		* {
57		* 'index:index': ['index_home', 1800, html_cache_callback]
58		* }
59		* @type {[type]}
60		*/
61	0	var rules = this.options.html_cache_rules;
62	0	var group = this.http.group.toLowerCase();
63	0	var controller = this.http.controller.toLowerCase();
64	0	var action = this.http.action.toLowerCase();
65	0	var list = [
66		group + ':' + controller + ':' + action,
67		controller + ':' + action,
68		action,
69		'*'
70		];
71	0	var html = [];
72	0	list.some(function(item){
73	0	if (item in rules) {
74	0	html = rules[item];
75	0	return true;
76		}
77		});
78	0	if (isEmpty(html)) {
79	0	return false;
80		}
81	0	if (!isArray(html)) {
82	0	html = [html];
83		}
84	0	var rule = html[0];
85		//将cookie变量传递进去
86	0	var cookiePars = {};
87	0	for(var name in this.http.cookie){
88	0	cookiePars['cookie.' + name] = this.http.cookie[name];
89		}
90	0	var pars = extend({}, this.http.get, cookiePars, {
91		':group': group,
92		':controller': controller,
93		':action': action
94		});
95	0	rule = rule.replace(/\{([\w\:]+)\}/g, function(a, name){
96	0	return pars[name] \|\| '';
97		});
98	0	var callback = html[2] \|\| C('html_cache_file_callback') \|\| this.getCacheFilename;
99	0	var filename = callback(rule, this.http) + this.options.html_cache_file_suffix;
100		//静态缓存文件名
101	0	this.http.html_filename = filename;
102	0	var cacheTime = html[1] \|\| this.options.html_cache_timeout;
103	0	return cacheTime;
104		},
105		/**
106		*
107		* @param {[type]} key [description]
108		* @return {[type]} [description]
109		*/
110		getCacheFilename: function(key){
111	0	var value = md5(key);
112	0	return value.substr(0, 1) + '/' + value;
113		},
114		/**
115		* [checkCacheTime description]
116		* @return {[type]} [description]
117		*/
118		checkCacheTime: function(cacheTime){
119	0	var cacheFile = this.options.html_cache_path + '/' + this.http.html_filename;
120	0	if (!isFile(cacheFile)) {
121	0	return false;
122		}
123	0	var cacheFileMtime = fs.statSync(cacheFile).mtime.getTime();
124	0	var tplFile = getViewFile(this.http);
125	0	if (tplFile) {
126	0	if (!isFile(tplFile)) {
127	0	return false;
128		}
129	0	var tplFileMtime = fs.statSync(tplFile).mtime.getTime();
130		//模版文件有更新
131	0	if (tplFileMtime > cacheFileMtime) {
132	0	return false;
133		}
134		}
135	0	if (Date.now() > (cacheFileMtime + cacheTime * 1000)) {
136	0	return false;
137		}
138	0	return true;
139		}
140		};
141		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/WriteHtmlCacheBehavior.js

45%

20

9

11

Line	Hits	Source
1		/**
2		* 模版文件列表
3		* @type {Object}
4		*/
5	1	var path = require('path');
6	1	var fs = require('fs');
7
8	1	var tplFiles = {};
9		/**
10		* 写入html缓存
11		* @return {[type]} [description]
12		*/
13	1	module.exports = Behavior(function(){
14	1	'use strict';
15	1	return {
16		options: {
17		'html_cache_on': false, //是否开启缓存
18		'html_cache_path': ''
19		},
20		run: function(content){
21	3	if (!this.options.html_cache_on \|\| !this.http.html_filename) {
22	3	return content;
23		}
24	0	this.recordViewFile();
25	0	var file = this.options.html_cache_path + '/' + this.http.html_filename;
26	0	mkdir(path.dirname(file));
27		//异步方式写入缓存
28	0	fs.writeFile(file, content);
29	0	return content;
30		},
31		/**
32		* 记录模版文件名
33		* @return {[type]} [description]
34		*/
35		recordViewFile: function(){
36	0	var tplFile = this.http.tpl_file;
37	0	var key = this.http.group + ':' + this.http.controller + ':' + this.http.action;
38	0	tplFiles[key] = tplFile;
39		}
40		};
41		});
42		/**
43		* 获取模版文件
44		* @param {[type]} http [description]
45		* @return {[type]} [description]
46		*/
47	1	module.exports.getViewFile = function(http){
48	0	'use strict';
49	0	var key = http.group + ':' + http.controller + ':' + http.action;
50	0	return tplFiles[key];
51		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/App.js

51%

155

80

75

Line	Hits	Source
1	1	var cluster = require('cluster');
2	1	var fs = require('fs');
3	1	var domain = require('domain');
4
5	1	var thinkHttp = thinkRequire('Http');
6	1	var Dispatcher = thinkRequire('Dispatcher');
7
8
9	1	var App = module.exports = {};
10		/**
11		* 根据http里的group和controller获取对应的controller实例
12		* @param {[type]} http [description]
13		* @return {[type]} [description]
14		*/
15	1	App.getBaseController = function(http){
16	12	'use strict';
17	12	var gc = ucfirst(http.group) + '/' + ucfirst(http.controller) + 'Controller';
18	12	var path = getThinkRequirePath(gc);
19	12	if (path) {
20	10	return require(path)(http);
21		}
22		}
23		/**
24		* controller不存在时调用的默认controller
25		* @return {[type]} [description]
26		*/
27	1	App.getCallController = function(http){
28	0	'use strict';
29		//如果是RESTFUL API，则调用RestController
30	0	if (http.isRestful) {
31	0	return thinkRequire('RestController')(http);
32		}
33	0	var config = C('call_controller');
34	0	if (!config) {
35	0	return;
36		}
37	0	if (isString(config)) {
38	0	config = config.split(':');
39		}
40	0	var action = Dispatcher.getAction(config.pop());
41	0	var controller = Dispatcher.getController(config.pop());
42	0	var group = Dispatcher.getGroup(config.pop());
43	0	var instance = this.getBaseController({
44		group: group,
45		controller: controller
46		})
47	0	if (instance && isFunction(instance[action + C('action_suffix')])) {
48	0	http.group = group;
49	0	http.controller = controller;
50	0	http.action = action;
51		}
52	0	return instance;
53		}
54
55		/**
56		* 执行具体的action，调用前置和后置操作
57		* @return {[type]} [description]
58		*/
59	1	App.execAction = function(controller, action, data, callMethod){
60	9	'use strict';
61		//action操作
62	9	var act = action + C('action_suffix');
63	9	var flag = false;
64		//action不存在时执行魔术方法
65	9	if (callMethod && !isFunction(controller[act])) {
66	0	var call = C('call_method');
67	0	if (call && isFunction(controller[call])) {
68	0	flag = true;
69	0	act = call;
70		}
71		}
72		//action不存在
73	9	if (!isFunction(controller[act])) {
74	0	return getPromise(new Error('action `' + action + '` not found. '), true);
75		}
76	9	var promise = getPromise();
77		//action前置操作
78	9	var before = C('before_action');
79	9	if (before && isFunction(controller[before])) {
80	0	promise = getPromise(controller[before](action));
81		}
82	9	promise = promise.then(function(){
83		//action魔术方法只传递action参数
84	9	if (flag) {
85	0	return controller[act](action);
86		}
87	9	if (data) {
88	5	return controller[act].apply(controller, data);
89		}else{
90	4	return controller[act]();
91		}
92		});
93		//action后置操作
94	9	var after = C('after_action');
95	9	if (after && isFunction(controller[after])) {
96	0	promise = promise.then(function(){
97	0	return controller[after](action);
98		})
99		}
100	9	return promise;
101		}
102
103		/**
104		* 获取action的形参
105		* @return {[type]} [description]
106		*/
107	1	App.getActionParams = function(fn, http){
108	1	'use strict';
109		//注释的正则
110	1	var commentReg = /((\/\/.$)\|(\/\[\s\S]?\\/)\|(\s))/mg;
111		//获取形参的正则
112	1	var parsReg = /^function\s[^$]\(\s([^$])\)/m;
113	1	var toString = fn.toString().replace(commentReg, '');
114	1	var match = toString.match(parsReg)[1].split(/\s,\s/);
115		//匹配到形参
116	1	var params;
117	1	if (match && match.length) {
118	1	params = match.map(function(item){
119	1	return http.post[item] \|\| http.get[item] \|\| '';
120		});
121		}
122	1	return params;
123		}
124		/**
125		* 执行
126		* @param {[type]} http [description]
127		* @return {[type]} [description]
128		*/
129	1	App.exec = function(http){
130	1	'use strict';
131	1	var controller = this.getBaseController(http) \|\| this.getCallController(http);
132		//controller不存在
133	1	if (!controller) {
134	0	var err = new Error('Controller `' + http.controller + '` not found. ' + http.pathname);
135	0	return getPromise(err, true);
136		}
137		//controller类实例
138	1	http.controllerInstance = controller;
139	1	var params;
140	1	var actionFn = controller[http.action + C('action_suffix')];
141		//参数绑定
142	1	if (C('url_params_bind') && isFunction(actionFn)) {
143	1	params = this.getActionParams(actionFn, http);
144		}
145	1	var promise = getPromise(controller.__initReturn);
146	1	var self = this;
147	1	return promise.then(function(){
148	1	return self.execAction(controller, http.action, params, true);
149		})
150		}
151		/**
152		* 发送错误信息
153		* @param {[type]} error [description]
154		* @return {[type]} [description]
155		*/
156	1	App.sendError = function(http, error){
157	0	'use strict';
158	0	if (!error \|\| !http.res) {
159	0	return;
160		}
161	0	var message = isError(error) ? error.stack : error;
162	0	console.error(message);
163	0	http.res.statusCode = 500;
164	0	http.setHeader('Content-Type', 'text/html; charset=' + C('encoding'));
165	0	if (APP_DEBUG) {
166	0	http.res.end(message);
167		}else{
168	0	var readStream = fs.createReadStream(C('error_tpl_path'));
169	0	readStream.pipe(http.res);
170	0	readStream.on('end', function(){
171	0	http.res.end();
172		});
173		}
174		}
175
176		/**
177		* run
178		* @return {[type]} [description]
179		*/
180	1	App.run = function(){
181	1	'use strict';
182	1	if (APP_MODE && App.mode[APP_MODE]) {
183	1	return App.mode[APP_MODE]();
184		}
185	0	return App.mode.http();
186		};
187		/**
188		* 不同模式下的run
189		* @type {Object}
190		*/
191	1	App.mode = {
192		//命令行模式
193		cli: function(){
194	1	'use strict';
195	1	var defaultHttp = thinkHttp.getDefaultHttp(process.argv[2]);
196	1	thinkHttp(defaultHttp.req, defaultHttp.res).run().then(App.listener);
197		},
198		//HTTP模式
199		http: function(){
200	0	'use strict';
201	0	var clusterNums = C('use_cluster');
202		//不使用cluster
203	0	if (!clusterNums) {
204	0	return App.createServer();
205		}
206		//使用cpu的个数
207	0	if (clusterNums === true) {
208	0	clusterNums = require('os').cpus().length;
209		}
210	0	if (cluster.isMaster) {
211	0	for (var i = 0; i < clusterNums; i++) {
212	0	cluster.fork();
213		}
214	0	cluster.on('exit', function(worker) {
215	0	console.error('worker ' + worker.process.pid + ' died');
216	0	process.nextTick(function(){
217	0	cluster.fork();
218		});
219		});
220		}else {
221	0	App.createServer();
222		}
223		}
224		};
225		/**
226		* 创建服务
227		* @return {[type]} [description]
228		*/
229	1	App.createServer = function(){
230	0	'use strict';
231		//自定义创建server
232	0	var createServerFn = C('create_server_fn');
233	0	if (createServerFn) {
234	0	if (isFunction(createServerFn)) {
235	0	return createServerFn(App);
236	0	}else if (isFunction(global[createServerFn])) {
237	0	return global[createServerFn](App);
238		}
239		}
240	0	var server = require('http').createServer(function (req, res) {
241	0	thinkHttp(req, res).run().then(App.listener);
242		});
243	0	thinkRequire('WebSocket')(server, App).run();
244	0	server.listen(C('port'));
245	0	if (APP_DEBUG) {
246	0	console.log('Server running at http://127.0.0.1:' + C('port') + '/');
247		}
248		}
249		/**
250		* 监听回调函数
251		* @param {[type]} http [description]
252		* @return {[type]} [description]
253		*/
254	1	App.listener = function(http){
255	1	'use strict';
256		//自动发送thinkjs和版本的header
257	1	http.setHeader('X-Powered-By', 'thinkjs-' + THINK_VERSION);
258		//禁止远程直接用带端口的访问,websocket下允许
259	1	if (C('use_proxy') && http.host !== http.hostname && !http.websocket) {
260	0	http.res.statusCode = 403;
261	0	http.res.end();
262	0	return getDefer().promise;
263		}
264	1	var domainInstance = domain.create();
265	1	var deferred = getDefer();
266	1	domainInstance.on('error', function(err){
267	0	App.sendError(http, err);
268	0	deferred.reject(err);
269		});
270	1	domainInstance.run(function(){
271	1	return tag('app_init', http).then(function(){
272	1	return Dispatcher(http).run();
273		}).then(function(){
274	1	return tag('app_begin', http);
275		}).then(function(){
276	1	return tag('action_init', http);
277		}).then(function(){
278	1	return App.exec(http);
279		}).then(function(){
280	1	return tag('app_end', http);
281		}).catch(function(err){
282	0	App.sendError(http, err);
283		}).then(function(){
284	1	deferred.resolve();
285		})
286		});
287	1	return deferred.promise;
288		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Controller.js

100%

152

0

Line	Hits	Source
1		/**
2		* Controller 基类
3		* @return {[type]} [description]
4		*/
5	1	var fs = require('fs');
6	1	var path = require('path');
7	1	var url = require('url');
8
9	1	module.exports = Class(function() {
10	1	'use strict';
11
12	1	return {
13		/**
14		* 初始化执行方法
15		* @param {[type]} http [description]
16		* @return {[type]} [description]
17		*/
18		init: function(http) {
19	25	this.http = http;
20	25	this.view = null;
21		//将http数据打到模版里
22	25	this.assign('http', this.http);
23		//将配置信息打到模版里
24	25	this.assign('config', C());
25		//设置变量别名
26	25	this.set = this.assign;
27		//success别名
28	25	this.ok = this.success;
29		//error别名
30	25	this.fail = this.error;
31		},
32		/**
33		* 获取客户端的ip
34		* @return {[type]} [description]
35		*/
36		ip: function() {
37	1	return this.http.ip();
38		},
39		/**
40		* 实例化View类
41		* @return {[type]} [description]
42		*/
43		initView: function() {
44	64	if (!this.view) {
45	25	this.view = thinkRequire('View')(this.http);
46		}
47	64	return this.view;
48		},
49		/**
50		* 是否是GET请求
51		* @return {Boolean} [description]
52		*/
53		isGet: function() {
54	1	return this.http.method === 'GET';
55		},
56		/**
57		* 是否是POST请求
58		* @return {Boolean} [description]
59		*/
60		isPost: function() {
61	1	return this.http.method === 'POST';
62		},
63		/**
64		* 是否是特定METHOD请求
65		* @param {[type]} method [description]
66		* @return {Boolean} [description]
67		*/
68		isMethod: function(method) {
69	2	return this.http.method === method.toUpperCase();
70		},
71		/**
72		* 是否是AJAX请求
73		* @return {Boolean} [description]
74		*/
75		isAjax: function(method) {
76		//请求类型判断
77	6	if (method && this.http.method !== method.toUpperCase()) {
78	2	return false;
79		}
80	4	return this.header('x-requested-with') === 'XMLHttpRequest';
81		},
82		/**
83		* 是否是websocket请求
84		* @return {Boolean} [description]
85		*/
86		isWebSocket: function(){
87	2	return !!this.http.websocket;
88		},
89		/**
90		* 是否是命令行模式
91		* @return {Boolean} [description]
92		*/
93		isCli: function(){
94	2	return APP_MODE === 'cli';
95		},
96		/**
97		* 是否是jsonp接口
98		* @return {Boolean} [description]
99		*/
100		isJsonp: function(name){
101	4	name = name \|\| C('url_callback_name');
102	4	return !!this.get(name);
103		},
104		/**
105		* 获取QUERY参数
106		* @param {[type]} name [description]
107		* @return {[type]} [description]
108		*/
109		get: function(name) {
110	44	if (name === undefined) {
111	2	return this.http.get;
112		}
113	42	return this.http.get[name] \|\| '';
114		},
115		/**
116		* 获取POST参数
117		* @param {[type]} name [description]
118		* @return {[type]} [description]
119		*/
120		post: function(name) {
121	11	var http = this.http;
122	11	return name ? (http.post[name] \|\| '') : http.post;
123		},
124		/**
125		* 获取参数
126		* @param {[type]} name [description]
127		* @return {[type]} [description]
128		*/
129		param: function(name) {
130	4	if (name === undefined) {
131	2	var post = this.post();
132	2	return !isEmpty(post) ? post : this.get();
133		}
134	2	return this.post(name) \|\| this.get(name);
135		},
136		/**
137		* 获取上传的文件
138		* @param {[type]} name [description]
139		* @return {[type]} [description]
140		*/
141		file: function(name) {
142	3	var http = this.http;
143	3	return name ? (http.file[name] \|\| {}) : http.file;
144		},
145		/**
146		* header操作
147		* @param {[type]} name [description]
148		* @param {[type]} value [description]
149		* @return {[type]} [description]
150		*/
151		header: function(name, value) {
152	11	if (name === undefined) {
153	1	return this.http.headers;
154	10	}else if (isObject(name)) {
155	1	for (var key in name) {
156	2	this.header(key, name[key]);
157		}
158	1	return this;
159	9	}else if (value !== undefined) {
160	3	this.http.setHeader(name, value);
161	3	return this;
162		}else{
163	6	return this.http.getHeader(name);
164		}
165		},
166		/**
167		* 获取userAgent
168		* @return {[type]} [description]
169		*/
170		userAgent: function(){
171	1	return this.http.headers['user-agent'] \|\| '';
172		},
173		/**
174		* 获取referrer
175		* @return {[type]} [description]
176		*/
177		referer: function(host){
178	3	var referer = this.http.headers.referer \|\| this.http.headers.referfer \|\| '';
179	3	if (!referer \|\| !host) {
180	2	return referer;
181		}
182	1	var info = url.parse(referer);
183	1	return info.hostname;
184		},
185		/**
186		* cookie操作
187		* @param {[type]} name [description]
188		* @param {[type]} value [description]
189		* @param {[type]} options [description]
190		* @return {[type]} [description]
191		*/
192		cookie: function(name, value, options) {
193	4	if (value !== undefined) {
194	1	this.http.setCookie(name, value, options);
195	1	return this;
196		}
197	3	return name === undefined ? this.http.cookie : (this.http.cookie[name] \|\| '');
198		},
199		/**
200		* session
201		* 如果是get操作，则返回一个promise
202		* @param {[type]} name [description]
203		* @param {[type]} value [description]
204		* @return {[type]} [description]
205		*/
206		session: function(name, value) {
207	11	thinkRequire('Session').start(this.http);
208	11	var instance = this.http.session;
209	11	if (name === undefined) {
210	1	return instance.rm();
211		}
212	10	if (value !== undefined) {
213	5	return instance.set(name, value);
214		}
215	5	return instance.get(name);
216		},
217		/**
218		* 跳转，返回一个pendding promise阻止后面继续执行
219		* @param {[type]} url [description]
220		* @param {[type]} code [description]
221		* @return {[type]} [description]
222		*/
223		redirect: function(url, code) {
224	2	this.http.redirect(url, code);
225	2	return getDefer().promise;
226		},
227		/**
228		* 赋值变量到模版
229		* @param {[type]} name [description]
230		* @param {[type]} value [description]
231		* @return {[type]} [description]
232		*/
233		assign: function(name, value) {
234	57	if (arguments.length <= 1) {
235	6	return this.initView().assign(name);
236		}
237	51	return this.initView().assign(name, value);
238		},
239		/**
240		* 获取解析后的模版内容
241		* @param {[type]} templateFile [description]
242		* @param {[type]} content [description]
243		* @return {[type]} [description]
244		*/
245		fetch: function(templateFile) {
246	3	return this.initView().fetch(templateFile);
247		},
248		/**
249		* 输出模版内容
250		* @param {[type]} templateFile [description]
251		* @param {[type]} charset [description]
252		* @param {[type]} contentType [description]
253		* @param {[type]} content [description]
254		* @return {[type]} [description]
255		*/
256		display: function(templateFile, charset, contentType) {
257	3	return this.initView().display(templateFile, charset, contentType);
258		},
259		/**
260		* 调用另一个controll里的aciton
261		* 可以跨分组
262		* A('Admin/Test/index')
263		* @param {[type]} action [description]
264		* @return {[type]} [description]
265		*/
266		action: function(action, data) {
267		//自动补group
268	3	action = action.replace(/\//g, ':');
269	3	if (action.split(':').length === 2) {
270	3	action = this.http.group + ':' + action;
271		}
272	3	return A(action, this.http, data);
273		},
274		/**
275		* jsonp格式输出
276		* @param {[type]} data [description]
277		* @param {[type]} jsonp [description]
278		* @return {[type]} [description]
279		*/
280		jsonp: function(data) {
281	6	this.type(C('json_content_type'));
282	6	var callback = this.get(C('url_callback_name'));
283		//过滤callback值里的非法字符
284	6	callback = callback.replace(/[^\w\.]/g, '');
285	6	if (callback) {
286	3	data = callback + '(' + (data !== undefined ? JSON.stringify(data) : '') + ')';
287	3	this.end(data);
288		} else {
289	3	this.end(data);
290		}
291		},
292		/**
293		* json格式输出
294		* @param {[type]} data [description]
295		* @return {[type]} [description]
296		*/
297		json: function(data){
298	2	this.type(C('json_content_type'));
299	2	return this.end(data);
300		},
301		/**
302		* 设置http响应状态码
303		* @param {[type]} status [description]
304		* @return {[type]} [description]
305		*/
306		status: function(status) {
307	2	var res = this.http.res;
308	2	if (!res.headersSent) {
309	2	res.statusCode = status \|\| 404;
310		}
311	2	return this;
312		},
313		/**
314		* 阻止访问
315		* @param {[type]} status [description]
316		* @return {[type]} [description]
317		*/
318		deny: function(status){
319	2	var res = this.http.res;
320	2	if (!res.headersSent) {
321	2	res.statusCode = status \|\| 403;
322	2	this.http.end();
323		}
324	2	return getDefer().promise;
325		},
326		/**
327		* 输出内容
328		* 自动JSON.stringify
329		* 自定将数字等转化为字符串
330		* @param {[type]} obj [description]
331		* @return {[type]} [description]
332		*/
333		echo: function(obj, encoding) {
334		//自动发送Content-Type的header
335	21	if (C('auto_send_content_type')) {
336	21	this.type(C('tpl_content_type'));
337		}
338	21	return this.http.echo(obj, encoding);
339		},
340		/**
341		* 结束输出，输出完成时一定要调用这个方法
342		* @param {[type]} obj [description]
343		* @return {[type]} [description]
344		*/
345		end: function(obj, encoding) {
346	18	if (obj !== undefined) {
347	15	this.echo(obj, encoding);
348		}
349	18	this.http.end();
350		},
351		/**
352		* 发送Content-Type
353		* @param {[type]} type [description]
354		* @return {[type]} [description]
355		*/
356		type: function(ext){
357	48	if (this.http.cthIsSend \|\| !ext) {
358	31	return;
359		}
360	17	if (ext.indexOf('/') === -1) {
361	3	ext = require('mime').lookup(ext);
362		}
363	17	if (ext.toLowerCase().indexOf('charset=') === -1) {
364	17	ext += '; charset=' + C('encoding');
365		}
366		//Content-Type Header has been Send
367	17	this.http.cthIsSend = true;
368	17	this.http.setHeader('Content-Type', ext);
369		},
370		/**
371		* 下载文件
372		* @return Promise [description]
373		*/
374		download: function(file, contentType, filename) {
375	5	if (isString(contentType) && contentType.indexOf('.') > -1) {
376	1	filename = contentType;
377	1	contentType = '';
378		}
379	5	if (!contentType \|\| contentType.indexOf('/') === -1) {
380	4	contentType = require('mime').lookup(contentType \|\| file);
381		}
382	5	var http = this.http;
383	5	var fileStream = fs.createReadStream(file);
384	5	var deferred = getDefer();
385	5	this.type(contentType);
386	5	http.setHeader('Content-Disposition', 'attachment; filename="' + (filename \|\| path.basename(file)) + '"');
387	5	fileStream.pipe(http.res);
388	5	fileStream.on('end', function() {
389	5	http.end();
390	5	deferred.resolve();
391		});
392	5	return deferred.promise;
393		},
394		/**
395		* 正常json数据输出
396		* @param {[type]} data [description]
397		* @return {[type]} [description]
398		*/
399		success: function(data){
400	2	var obj = getObject([C('error_no_key'), C('error_msg_key')], [0, '']);
401	2	if (data !== undefined) {
402	1	obj.data = data;
403		}
404	2	this.type(C('json_content_type'));
405	2	this.end(obj);
406	2	return getDefer().promise;
407		},
408		/**
409		* 异常json数据数据
410		* @param {[type]} errno [description]
411		* @param {[type]} errmsg [description]
412		* @param {[type]} extra [description]
413		* @return {[type]} [description]
414		*/
415		error: function(errno, errmsg, data){
416	7	var obj;
417	7	if (isObject(errno)) {
418	3	data = errmsg;
419	3	obj = extend({}, errno);
420		}else{
421	4	if (!isNumber(errno)) {
422	1	data = errmsg;
423	1	errmsg = errno;
424	1	errno = C('error_no_default_value');
425		}
426	4	obj = getObject([C('error_no_key'), C('error_msg_key')], [errno, errmsg \|\| 'error']);
427		}
428	7	if (data !== undefined) {
429	2	obj.data = data;
430		}
431	7	this.type(C('json_content_type'));
432	7	this.end(obj);
433	7	return getDefer().promise;
434		},
435		/**
436		* 关闭数据库连接
437		* @return {[type]} [description]
438		*/
439		closeDb: function(){
440	1	thinkRequire('Model').close();
441		},
442		/**
443		* 发送执行时间
444		* @param {[type]} name [description]
445		* @return {[type]} [description]
446		*/
447		sendTime: function(name){
448	2	return this.http.sendTime(name);
449		},
450		/**
451		* 对数据进行过滤
452		* @param {[type]} data [description]
453		* @param {[type]} type [description]
454		* @return {[type]} [description]
455		*/
456		filter: function() {
457	2	var filter = thinkRequire('Filter').filter;
458	2	return filter.apply(null, arguments);
459		},
460		/**
461		* 校验一个值是否合法
462		* @param {[type]} data [description]
463		* @param {[type]} validType [description]
464		* @return {[type]} [description]
465		*/
466		valid: function(data, validType) {
467		//单个值检测，只返回是否正常
468	3	if (validType !== undefined) {
469	1	data = [{
470		value: data,
471		valid: validType
472		}];
473	1	var result = thinkRequire('Valid')(data);
474	1	return isEmpty(result);
475		}
476	2	return thinkRequire('Valid')(data);
477		}
478		};
479		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Db.js

82%

363

299

64

Line	Hits	Source
1	1	var querystring = require('querystring');
2		/**
3		* 数据库基类
4		* @return {[type]} [description]
5		*/
6	1	var Db = module.exports = Class(function(){
7	1	'use strict';
8		//用于查询的sql语句，所有select语句根据该语句解析
9	1	var selectSql = 'SELECT%DISTINCT% %FIELD% FROM %TABLE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%%COMMENT%';
10		//where条件里的表达式
11	1	var comparison = {
12		'EQ': '=',
13		'NEQ': '!=',
14		'<>': '!=',
15		'GT': '>',
16		'EGT': '>=',
17		'LT': '<',
18		'ELT': '<=',
19		'NOTLIKE': 'NOT LIKE',
20		'LIKE': 'LIKE',
21		'IN': 'IN',
22		'NOTIN': 'NOT IN'
23		};
24		//数据查询缓存
25	1	var dbCacheData = {};
26
27	1	return {
28		// 数据库类型
29		dbType: null,
30		// 当前操作所属的模型名
31		model: 'think',
32		// 当前SQL指令
33		sql: '',
34		// 操作的sql列表
35		modelSql: {},
36		// 当前连接ID
37		linkId: null,
38		// 数据库连接参数配置
39		config: '',
40		/**
41		* 初始化
42		* @return {[type]} [description]
43		*/
44		init: function(){
45
46		},
47		/**
48		* 解析set集合
49		* @param {[type]} data [description]
50		* @return {[type]} [description]
51		*/
52		parseSet: function(data){
53	14	data = data \|\| {};
54	14	var set = [];
55	14	for(var key in data){
56	14	var value = this.parseValue(data[key]);
57	14	if (isScalar(value)) {
58	14	set.push(this.parseKey(key) + '=' + value);
59		}
60		}
61	14	return ' SET ' + set.join(',');
62		},
63		/**
64		* 解析字段名，具体的数据库里实现
65		* @param {[type]} key [description]
66		* @return {[type]} [description]
67		*/
68		parseKey: function(key){
69	0	return key;
70		},
71		/**
72		* value分析
73		* @param {[type]} value [description]
74		* @return {[type]} [description]
75		*/
76		parseValue: function(value){
77	163	if (isString(value)) {
78	67	value = '\'' + this.escapeString(value) + '\'';
79	96	}else if(isArray(value)){
80	17	if ((value[0] + '').toLowerCase() === 'exp') {
81	8	value = this.escapeString(value[1]);
82		}else{
83	9	var self = this;
84	9	value = value.map(function(item){
85	17	return self.parseValue(item);
86		});
87		}
88	79	}else if(isBoolean(value)){
89	0	value = value ? '1' : '0';
90	79	}else if (value === null) {
91	0	value = 'null';
92		}
93	163	return value;
94		},
95		/**
96		* field分析
97		* parseField('name');
98		* parseField('name,email');
99		* parseField({
100		* xx_name: 'name',
101		* xx_email: 'email'
102		* })
103		* @return {[type]} [description]
104		*/
105		parseField: function(fields){
106	157	if (isString(fields) && fields.indexOf(',') > -1) {
107	4	fields = fields.split(',');
108		}
109	157	if (isArray(fields)) {
110	4	var self = this;
111	4	return fields.map(function(item){
112	17	return self.parseKey(item);
113		}).join(',');
114	153	}else if(isObject(fields)){
115	0	var data = [];
116	0	for(var key in fields){
117	0	data.push(this.parseKey(key) + ' AS ' + this.parseKey(fields[key]));
118		}
119	0	return data.join(',');
120	153	}else if(isString(fields) && fields){
121	17	return this.parseKey(fields);
122		}
123	136	return '*';
124		},
125		/**
126		* table别名分析
127		* @param {[type]} tables [description]
128		* @return {[type]} [description]
129		*/
130		parseTable: function(tables){
131	184	if (isString(tables)) {
132	184	tables = tables.split(',');
133		}
134	184	if (isArray(tables)) {
135	184	var self = this;
136	184	return tables.map(function(item){
137	184	return self.parseKey(item);
138		}).join(',');
139	0	}else if (isObject(tables)) {
140	0	var data = [];
141	0	for(var key in tables){
142	0	data.push(this.parseKey(key) + ' AS ' + this.parseKey(tables[key]));
143		}
144	0	return data.join(',');
145		}
146	0	return '';
147		},
148		/**
149		* where条件分析
150		* @param {[type]} where [description]
151		* @return {[type]} [description]
152		*/
153		parseWhere: function(where){
154	177	var whereStr = '';
155	177	var self = this;
156	177	where = where \|\| {};
157	177	if (isString(where)) {
158	0	whereStr = where;
159		}else{
160		// 定义逻辑运算规则例如 OR XOR AND NOT
161	177	var oList = ['AND', 'OR', 'XOR'];
162	177	var operate = (where._logic + '').toUpperCase();
163	177	delete where._logic;
164	177	operate = oList.indexOf(operate) > -1 ? ' ' + operate + ' ' : ' AND ';
165		//key值的安全检测正则
166	177	var keySafeRegExp = /^[\w\\|\&\-\.\,]+$/;
167	177	var multi = where._multi;
168	177	delete where._multi;
169
170	177	var val;
171	177	var fn = function(item, i){
172	8	var v = multi ? val[i] : val;
173	8	return '(' + self.parseWhereItem(self.parseKey(item), v) + ')';
174		};
175	177	for(var key in where){
176	105	key = key.trim();
177	105	val = where[key];
178	105	whereStr += '( ';
179	105	if (key.indexOf('_') === 0) {
180		// 解析特殊条件表达式
181	3	whereStr += this.parseThinkWhere(key, val);
182		}else{
183	102	if (!keySafeRegExp.test(key)) {
184	0	console.log(key + ' is not safe');
185	0	continue;
186		}
187	102	var arr;
188		// 支持 name\|title\|nickname 方式定义查询字段
189	102	if (key.indexOf('\|') > -1) {
190	2	arr = key.split('\|');
191	2	whereStr += arr.map(fn).join(' OR ');
192	100	}else if (key.indexOf('&') > -1) {
193	2	arr = key.split('&');
194	2	whereStr += arr.map(fn).join(' AND ');
195		}else{
196	98	whereStr += this.parseWhereItem(this.parseKey(key), val);
197		}
198		}
199	105	whereStr += ' )' + operate;
200		}
201	177	whereStr = whereStr.substr(0, whereStr.length - operate.length);
202		}
203
204	177	return whereStr ? (' WHERE ' + whereStr) : '';
205		},
206		/**
207		* 解析单个查询条件
208		* @param {[type]} key [description]
209		* @param {[type]} val [description]
210		* @return {[type]} [description]
211		*/
212		parseWhereItem: function(key, val){
213	106	if (isObject(val)) { // {id: {'<': 10, '>': 1}}
214	7	var logic = (val._logic \|\| 'AND').toUpperCase();
215	7	delete val._logic;
216	7	var result = [];
217	7	for(var opr in val){
218	14	var nop = opr.toUpperCase();
219	14	nop = comparison[nop] \|\| nop;
220	14	result.push(key + ' ' + nop + ' ' + this.parseValue(val[opr]));
221		}
222	7	return result.join(' ' + logic + ' ');
223	99	}else if (!isArray(val)) {
224		//对字符串类型字段采用模糊匹配
225	36	if (C('db_like_fields').indexOf(key) > -1) {
226	0	return key + ' LIKE ' + this.parseValue('%' + val + '%');
227		}else{
228	36	return key + ' = ' + this.parseValue(val);
229		}
230		}
231	63	var whereStr = '';
232	63	var data;
233	63	if (isString(val[0])) {
234	62	var val0 = val[0].toUpperCase();
235	62	val0 = comparison[val0] \|\| val0;
236	62	if (/^(=\|!=\|>\|>=\|<\|<=)$/.test(val0)) { // 比较运算
237	22	whereStr += key + ' ' + val0 + ' ' + this.parseValue(val[1]);
238	40	}else if (/^(NOT\s+LIKE\|LIKE)$/.test(val0)) { // 模糊查找
239	23	if (isArray(val[1])) { //多个like
240	7	var likeLogic = (val[2] \|\| 'OR').toUpperCase();
241	7	var likesLogic = ['AND','OR','XOR'];
242	7	var self = this;
243	7	if (likesLogic.indexOf(likeLogic) > -1) {
244	7	var like = val[1].map(function(item){
245	13	return key + ' ' + val0 + ' ' + self.parseValue(item);
246		}).join(' ' + likeLogic + ' ');
247	7	whereStr += '(' + like + ')';
248		}
249		}else{
250	16	whereStr += key + ' ' + val0 + ' ' + this.parseValue(val[1]);
251		}
252	17	}else if(val0 === 'EXP'){ // 使用表达式
253	2	whereStr += '(' + key + ' ' + val[1] + ')';
254	15	}else if(val0 === 'IN' \|\| val0 === 'NOT IN'){ // IN 运算
255	12	if (val[2] === 'exp') {
256	3	whereStr += key + ' ' + val0 + ' ' + val[1];
257		}else{
258	9	if (isString(val[1])) {
259	4	val[1] = val[1].split(',');
260		}
261		//如果不是数组，自动转为数组
262	9	if (!isArray(val[1])) {
263	2	val[1] = [val[1]];
264		}
265	9	val[1] = this.parseValue(val[1]);
266		//如果只有一个值，那么变成＝或者!=
267	9	if (val[1].length === 1) {
268	2	whereStr += key + (val0 === 'IN' ? ' = ' : ' != ') + val[1];
269		}else{
270	7	whereStr += key + ' ' + val0 + ' (' + val[1].join(',') + ')';
271		}
272		}
273	3	}else if(val0 === 'BETWEEN'){ // BETWEEN运算
274	3	data = isString(val[1]) ? val[1].split(',') : val[1];
275	3	if (!isArray(data)) {
276	2	data = [val[1], val[2]];
277		}
278	3	whereStr += ' (' + key + ' ' + val0 + ' ' + this.parseValue(data[0]);
279	3	whereStr += ' AND ' + this.parseValue(data[1]) + ')';
280		}else{
281	0	console.log('_EXPRESS_ERROR_', key, val);
282	0	return '';
283		}
284		}else{
285	1	var length = val.length;
286	1	var rule = 'AND';
287	1	if (isString(val[length - 1])) {
288	0	var last = val[length - 1].toUpperCase();
289	0	if (last && ['AND', 'OR', 'XOR'].indexOf(last) > -1) {
290	0	rule = last;
291	0	length--;
292		}
293		}
294	1	for(var i = 0; i < length; i++){
295	3	var isArr = isArray(val[i]);
296	3	data = isArr ? val[i][1] : val[i];
297	3	var exp = ((isArr ? val[i][0] : '') + '').toUpperCase();
298	3	if (exp === 'EXP') {
299	1	whereStr += '(' + key + ' ' + data + ') ' + rule + ' ';
300		}else{
301	2	var op = isArr ? (comparison[val[i][0].toUpperCase()] \|\| val[i][0]) : '=';
302	2	whereStr += '(' + key + ' ' + op + ' ' + this.parseValue(data) + ') ' + rule + ' ';
303		}
304		}
305	1	whereStr = whereStr.substr(0, whereStr.length - 4);
306		}
307	63	return whereStr;
308		},
309		/**
310		* 解析一些特殊的where条件
311		* @param {[type]} key [description]
312		* @param {[type]} val [description]
313		* @return {[type]} [description]
314		*/
315		parseThinkWhere: function(key, val){
316	3	switch(key){
317		// 字符串模式查询条件
318		case '_string':
319	2	return val;
320		// 复合查询条件
321		case '_complex':
322	1	return this.parseWhere(val).substr(6);
323		// 字符串模式查询条件
324		case '_query':
325	0	var where = isString(val) ? querystring.parse(val) : val;
326	0	var op = ' AND ';
327	0	if ('_logic' in where) {
328	0	op = ' ' + where._logic.toUpperCase() + ' ';
329	0	delete where._logic;
330		}
331	0	var arr = [];
332	0	for(var name in where){
333	0	val = where[name];
334	0	val = this.parseKey(name) + ' = ' + this.parseValue(val);
335	0	arr.push(val);
336		}
337	0	return arr.join(op);
338		default:
339	0	return '';
340		}
341	0	return '';
342		},
343		/**
344		* 解析limit，对非法的limit进行过滤
345		* @param {[type]} limit [description]
346		* @return {[type]} [description]
347		*/
348		parseLimit: function(limit){
349	176	if (!limit) {
350	151	return '';
351		}
352	25	limit = (limit + '').split(',');
353	25	var data = [];
354	25	for(var i = 0; i < Math.min(2, limit.length); i++){
355	33	data[i] = limit[i] \| 0;
356		}
357	25	return ' LIMIT ' + data.join(',');
358		},
359		/**
360		* 解析join
361		* @param {[type]} join [description]
362		* @return {[type]} [description]
363		*/
364		parseJoin: function(join, options){
365	157	if (!join) {
366	140	return '';
367		}
368	17	var joinStr = '';
369	17	var defaultJoin = ' LEFT JOIN ';
370	17	if (isArray(join)) {
371	17	var joins = {
372		'left': ' LEFT JOIN ',
373		'right': ' RIGHT JOIN ',
374		'inner': ' INNER JOIN '
375		};
376	17	join.forEach(function(val){
377	19	if (isString(val)) {//字符串，直接拼接
378	6	var hasJoin = val.toLowerCase().indexOf(' join ') > -1;
379	6	joinStr += (hasJoin ? ' ' : defaultJoin) + val;
380	13	}else if (isObject(val)) {
381	13	var ret = [];
382	13	if (!('on' in val)) {
383	7	for(var key in val){
384	15	var v = val[key];
385	15	v.table = key;
386	15	ret.push(v);
387		}
388		}else{
389	6	ret.push(val);
390		}
391	13	ret.forEach(function(item){
392	21	var joinType = joins[item.join] \|\| item.join \|\| defaultJoin;
393	21	var table = options.tablePrefix + item.table;
394	21	joinStr += joinType + '`' + table + '`';
395	21	if (item.as) {
396	12	joinStr += ' AS ' + item.as;
397		}
398		//ON条件
399	21	if (item.on) {
400	21	var mTable = options.alias \|\| options.table;
401	21	var jTable = item.as \|\| table;
402		//多个＝条件
403	21	if (isObject(item.on)) {
404	2	var where = [];
405	2	for(var key in item.on){
406	4	where.push(mTable + '.`' + key + '`' + '=' + jTable + '.`' + item.on[key] + '`');
407		}
408	2	joinStr += ' ON (' + where.join(' AND ') + ')';
409		}else{
410	19	if (isString(item.on)) {
411	3	item.on = item.on.split(/\s,\s/);
412		}
413	19	joinStr += ' ON ' + mTable + '.`' + item.on[0] + '`';
414	19	joinStr += '=' + jTable + '.`' + item.on[1] + '`';
415		}
416		}
417		})
418		}
419		});
420		}else{
421	0	joinStr += defaultJoin + join;
422		}
423	17	return joinStr;
424		},
425		/**
426		* 解析order
427		* @param {[type]} order [description]
428		* @return {[type]} [description]
429		*/
430		parseOrder: function(order){
431	176	var self = this;
432	176	if (isArray(order)) {
433	2	order = order.map(function(item){
434	3	return self.parseKey(item);
435		}).join(',');
436	174	}else if (isObject(order)) {
437	2	var arr = [];
438	2	for(var key in order){
439	3	var val = order[key];
440	3	val = this.parseKey(key) + ' ' + val;
441	3	arr.push(val);
442		}
443	2	order = arr.join(',');
444		}
445	176	return order ? (' ORDER BY ' + order) : '';
446		},
447		/**
448		* 解析group
449		* @param {[type]} group [description]
450		* @return {[type]} [description]
451		*/
452		parseGroup: function(group){
453	157	return group ? (' GROUP BY `' + group + '`' ) : '';
454		},
455		/**
456		* 解析having
457		* @param {[type]} having [description]
458		* @return {[type]} [description]
459		*/
460		parseHaving: function(having){
461	157	return having ? (' HAVING ' + having) : '';
462		},
463		/**
464		* 解析注释，一般情况下用不到
465		* @param {[type]} comment [description]
466		* @return {[type]} [description]
467		*/
468		parseComment: function(comment){
469	180	return comment ? (' /* ' + comment + '*/') : '';
470		},
471		/**
472		* 解析Distinct
473		* @param {[type]} distinct [description]
474		* @return {[type]} [description]
475		*/
476		parseDistinct: function(distinct){
477	157	return distinct ? ' Distinct ' : '';
478		},
479		/**
480		* 解析Union
481		* @param {[type]} union [description]
482		* @return {[type]} [description]
483		*/
484		parseUnion: function(union){
485	157	if (!union) {
486	153	return '';
487		}
488	4	if (isArray(union)) {
489	4	var self = this;
490	4	var sql = '';
491	4	union.forEach(function(item){
492	5	sql += item.all ? 'UNION ALL ' : 'UNION ';
493	5	sql += '(' + (isObject(item.union) ? self.buildSelectSql(item.union).trim() : item.union) + ') ';
494		})
495	4	return sql;
496		}else{
497	0	return 'UNION (' + (isObject(union) ? this.buildSelectSql(union).trim() : union) + ') ';
498		}
499		},
500		/**
501		* 解析Lock
502		* @param {[type]} lock [description]
503		* @return {[type]} [description]
504		*/
505		parseLock: function(lock){
506	180	if (!lock) {
507	179	return '';
508		}
509	1	return ' FOR UPDATE ';
510		},
511		/**
512		* 将page转化为sql里的limit
513		* @return {[type]} [description]
514		*/
515		pageToLimit: function(options){
516	157	options = options \|\| {};
517		//根据page生成limit
518	157	if ('page' in options) {
519	6	var page = options.page + '';
520	6	var listRows = 0;
521	6	if (page.indexOf(',') > -1) {
522	3	page = page.split(',');
523	3	listRows = page[1] \| 0;
524	3	page = page[0];
525		}
526	6	page = parseInt(page, 10) \|\| 1;
527	6	if (!listRows) {
528	4	listRows = isNumberString(options.limit) ? options.limit : C('db_nums_per_page');
529		}
530	6	var offset = listRows * (page - 1);
531	6	options.limit = offset + ',' + listRows;
532		}
533	157	return options;
534		},
535		/**
536		* 拼接select查询语句
537		* @param {[type]} options [description]
538		* @return {[type]} [description]
539		*/
540		buildSelectSql: function(options){
541	157	options = this.pageToLimit(options);
542	157	var sql = this.parseSql(selectSql, options);
543	157	sql += this.parseLock(options.lock);
544	157	return sql;
545		},
546		/**
547		* 解析sql语句
548		* @param {[type]} sql [description]
549		* @param {[type]} options [description]
550		* @return {[type]} [description]
551		*/
552		parseSql: function(sql, options){
553	157	options = options \|\| {};
554	157	var self = this;
555	157	return sql.replace(/\%([A-Z]+)\%/g, function(a, type){
556	1727	type = type.toLowerCase();
557	1727	return self['parse' + ucfirst(type)](options[type] \|\| '', options);
558		}).replace(/__([A-Z_-]+)__/g, function(a, b){
559	0	return '`' + C('db_prefix') + b.toLowerCase() + '`';
560		});
561		},
562		/**
563		* 插入一条记录
564		* @param {[type]} data [description]
565		* @param {[type]} options [description]
566		* @param {[type]} replace [description]
567		* @return {[type]} [description]
568		*/
569		insert: function(data, options, replace){
570	4	data = data \|\| {};
571	4	options = options \|\| {};
572	4	var values = [];
573	4	var fields = [];
574	4	this.model = options.model;
575	4	for(var key in data){
576	5	var val = data[key];
577	5	val = this.parseValue(val);
578	5	if (isScalar(val)) {
579	5	values.push(val);
580	5	fields.push(this.parseKey(key));
581		}
582		}
583	4	var sql = (replace ? 'REPLACE' : 'INSERT') + ' INTO ';
584	4	sql += this.parseTable(options.table) + ' (' + fields.join(',') + ') ';
585	4	sql += 'VALUES(' + values.join(',') + ')';
586	4	sql += this.parseLock(options.lock) + this.parseComment(options.comment);
587	4	return this.execute(sql);
588		},
589		/**
590		* 插入多条记录
591		* @param {[type]} data [description]
592		* @param {[type]} options [description]
593		* @param {[type]} replace [description]
594		* @return {[type]} [description]
595		*/
596		insertAll: function(data, options, replace){
597	4	var fields = Object.keys(data[0]);
598	4	var self = this;
599	4	fields = fields.map(function(item){
600	6	return self.parseKey(item);
601		}).join(',');
602	4	var values = data.map(function(item){
603	6	var value = [];
604	6	for(var key in item){
605	9	var val = item[key];
606	9	val = self.parseValue(val);
607	9	if (isScalar(val)) {
608	9	value.push(val);
609		}
610		}
611	6	return '(' + value.join(',') + ')';
612		}).join(',');
613	4	var sql = replace ? 'REPLACE' : 'INSERT';
614	4	sql += ' INTO ' + this.parseTable(options.table) + '(' + fields + ') VALUES ' + values;
615	4	return this.execute(sql);
616		},
617		/**
618		* 从一个选择条件的结果插入记录
619		* @param {[type]} fields [description]
620		* @param {[type]} table [description]
621		* @param {[type]} options [description]
622		* @return {[type]} [description]
623		*/
624		selectInsert: function(fields, table, options){
625	0	options = options \|\| {};
626	0	this.model = options.model;
627	0	if (isString(fields)) {
628	0	fields = fields.split(',');
629		}
630	0	var self = this;
631	0	fields = fields.map(function(item){
632	0	return self.parseKey(item);
633		});
634	0	var sql = 'INSERT INTO ' + this.parseTable(options.table) + ' (' + fields.join(',') + ')';
635	0	sql += this.buildSelectSql(options);
636	0	return this.execute(sql);
637		},
638		/**
639		* 删除记录
640		* @param {[type]} options [description]
641		* @return {[type]} [description]
642		*/
643		delete: function(options){
644	5	options = options \|\| {};
645	5	this.model = options.model;
646	5	var sql = [
647		'DELETE FROM ',
648		this.parseTable(options.table),
649		this.parseWhere(options.where),
650		this.parseOrder(options.order),
651		this.parseLimit(options.limit),
652		this.parseLock(options.lock),
653		this.parseComment(options.comment)
654		].join('');
655	5	return this.execute(sql);
656		},
657		/**
658		* 更新数据
659		* @param {[type]} data [description]
660		* @param {[type]} options [description]
661		* @return {[type]} [description]
662		*/
663		update: function(data, options){
664	14	options = options \|\| {};
665	14	this.model = options.model;
666	14	var sql = [
667		'UPDATE ',
668		this.parseTable(options.table),
669		this.parseSet(data),
670		this.parseWhere(options.where),
671		this.parseOrder(options.order),
672		this.parseLimit(options.limit),
673		this.parseLock(options.lock),
674		this.parseComment(options.comment)
675		].join('');
676	14	return this.execute(sql);
677		},
678		/**
679		* 数据查询
680		* @todo 返回是个promise，缓存调用需要修改
681		* @param {[type]} options [description]
682		* @return {[type]} [description]
683		*/
684		select: function(options){
685	154	var sql, cache;
686	154	if (isString(options) && options.indexOf('SELECT') > -1) {
687	0	sql = options;
688	0	cache = arguments[1];
689		}else{
690	154	options = options \|\| {};
691	154	this.model = options.model;
692	154	sql = this.buildSelectSql(options);
693	154	cache = options.cache;
694		}
695	154	var self = this;
696	154	if (!isEmpty(cache) && C('db_cache_on')) {
697		//内存缓存
698	0	if (cache.type === '') {
699	0	cache.cacheData = dbCacheData;
700		}
701	0	var key = cache.key \|\| md5(sql);
702	0	return S(key, function(){
703	0	return self.query(sql);
704		}, cache);
705		}
706	154	return this.query(sql);
707		},
708		/**
709		* 转义字符
710		* @param {[type]} str [description]
711		* @return {[type]} [description]
712		*/
713		escapeString: function(str){
714	75	if (!str) {
715	0	return '';
716		}
717	75	return str.replace(/[\0\n\r\b\t\\\'\"\x1a]/g, function(s) {
718	6	switch(s) {
719		case '\0':
720	0	return '\\0';
721		case '\n':
722	3	return '\\n';
723		case '\r':
724	0	return '\\r';
725		case '\b':
726	0	return '\\b';
727		case '\t':
728	0	return '\\t';
729		case '\x1a':
730	0	return '\\Z';
731		default:
732	3	return '\\'+s;
733		}
734		});
735		},
736		/**
737		* 获取上次的sql语句
738		* @param {[type]} model [description]
739		* @return {[type]} [description]
740		*/
741		getLastSql: function(model){
742	174	return model ? this.modelSql[model] : this.sql;
743		},
744		/**
745		* 设置当前操作的sql
746		* @param {[type]} sql [description]
747		*/
748		setSql: function(sql){
749	183	this.sql = sql;
750	183	this.modelSql[this.model] = sql;
751		},
752		/**
753		* 设置模型
754		* @param {[type]} model [description]
755		*/
756		setModel: function(model){
757	0	this.model = model;
758	0	return this;
759		}
760		};
761		});
762		/**
763		* 解析配置
764		* @param {[type]} config [description]
765		* @return {[type]} [description]
766		*/
767	1	Db.parseConfig = function(config){
768	1	'use strict';
769	1	config = config \|\| {};
770	1	return {
771		type: config.db_type \|\| C('db_type') \|\| 'mysql',
772		username: config.db_user \|\| C('db_user'),
773		password: config.db_pwd \|\| C('db_pwd'),
774		hostname: config.db_host \|\| C('db_host'),
775		port: config.db_port \|\| C('db_port'),
776		database: config.db_name \|\| C('db_name'),
777		charset: config.db_charset \|\| C('db_charset')
778		};
779		};
780		/**
781		* 根据配置获取对应的数据库实例
782		* @param {[type]} config [description]
783		* @return {[type]} [description]
784		*/
785	1	Db.getInstance = function(config){
786	1	'use strict';
787	1	config = this.parseConfig(config);
788	1	var instance = thinkRequire(ucfirst(config.type) + 'Db')(config);
789	1	instance.dbType = config.type.toUpperCase();
790	1	return instance;
791		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Dispatcher.js

88%

50

44

6

Line	Hits	Source
1		/**
2		* 路由识别
3		* @type {Object}
4		*/
5	1	var Dispatcher = module.exports = Class(function(){
6	1	'use strict';
7	1	return {
8		/**
9		* 初始化
10		* @param {[type]} http [description]
11		* @return {[type]} [description]
12		*/
13		init: function(http){
14	1	this.http = http;
15		},
16		/**
17		* 准备pathanem
18		* @return {[type]} [description]
19		*/
20		preparePathName: function(){
21	1	var pathname = this.http.pathname.split('/').filter(function(item){
22	2	return item.trim();
23		}).join('/');
24		//去除pathname前缀
25	1	var prefix = C('url_pathname_prefix');
26	1	if (prefix && pathname.indexOf(prefix) === 0) {
27	0	pathname = pathname.substr(prefix.length);
28		}
29		//判断URL后缀
30	1	var suffix = C('url_pathname_suffix');
31	1	if (suffix && pathname.substr(0 - suffix.length) === suffix) {
32	0	pathname = pathname.substr(0, pathname.length - suffix.length);
33		}
34	1	this.http.pathname = pathname;
35		},
36		/**
37		* 解析pathname
38		* @return {[type]} [description]
39		*/
40		parsePathName: function(){
41	1	if (this.http.group) {
42	0	return true;
43		}
44	1	var paths = this.http.pathname.split('/');
45		//将group list变为小写
46	1	var groupList = C('app_group_list').map(function(item){
47	3	return item.toLowerCase();
48		});
49	1	var group = '';
50	1	if (groupList.length && paths[0] && groupList.indexOf(paths[0].toLowerCase()) > -1) {
51	0	group = paths.shift();
52		}
53	1	var controller = paths.shift();
54	1	var action = paths.shift();
55		//解析剩余path的参数
56	1	if (paths.length) {
57	0	for(var i = 0,length = Math.ceil(paths.length) / 2; i < length; i++){
58	0	this.http.get[paths[i * 2]] = paths[i * 2 + 1] \|\| '';
59		}
60		}
61	1	this.http.group = Dispatcher.getGroup(group);
62	1	this.http.controller = Dispatcher.getController(controller);
63	1	this.http.action = Dispatcher.getAction(action);
64		},
65		/**
66		* run
67		* @return {[type]} [description]
68		*/
69		run: function(){
70	1	var self = this;
71	1	return tag('resource_check', this.http).then(function(){
72	1	return self.preparePathName();
73		}).then(function(){
74	1	return tag('path_info', self.http);
75		}).then(function(){
76	1	return tag('route_check', self.http);
77		}).then(function(){
78	1	return self.parsePathName();
79		});
80		}
81		};
82		});
83		/**
84		* 获取group
85		* @param {[type]} group [description]
86		* @return {[type]} [description]
87		*/
88	1	Dispatcher.getGroup = function(group){
89	31	'use strict';
90	31	group = group \|\| C('default_group');
91	31	return ucfirst(group);
92		};
93
94		/**
95		* 检测Controller和Action是否合法的正则
96		* @type {RegExp}
97		*/
98	1	var nameReg = /^[A-Za-z\_](\w)*$/;
99		/**
100		* 获取controller
101		* @param {[type]} controller [description]
102		* @return {[type]} [description]
103		*/
104	1	Dispatcher.getController = function(controller){
105	31	'use strict';
106	31	if (!controller \|\| !nameReg.test(controller)) {
107	1	return ucfirst(C('default_controller'));
108		}
109	30	return ucfirst(controller);
110		};
111		/**
112		* 获取action
113		* @param {[type]} action [description]
114		* @return {[type]} [description]
115		*/
116	1	Dispatcher.getAction = function(action){
117	31	'use strict';
118	31	if (!action \|\| !nameReg.test(action)) {
119	1	return C('default_action');
120		}
121	30	return action;
122		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Http.js

59%

142

84

58

Line	Hits	Source
1		/**
2		* 对HttpRequest和HttpResponse 2个对象重新包装
3		* @type {Object}
4		*/
5	1	var querystring = require('querystring');
6	1	var url = require('url');
7	1	var cookie = thinkRequire('Cookie');
8	1	var EventEmitter = require('events').EventEmitter;
9	1	var multiparty = require('multiparty');
10
11	1	var localIp = '127.0.0.1';
12	1	module.exports = Class(function(){
13	1	'use strict';
14	1	return {
15		init: function(req, res){
16	10	this.req = req;
17	10	this.res = res;
18		//http对象为EventEmitter的实例
19	10	this.http = new EventEmitter();
20		//记录当前请求的开始时间
21	10	this.http.startTime = Date.now();
22		},
23		/**
24		* 执行
25		* @param {Function} callback [description]
26		* @return Promise [description]
27		*/
28		run: function(){
29	10	this._request();
30	10	this._response();
31		//数组的indexOf要比字符串的indexOf略快
32	10	var methods = ['POST', 'PUT', 'PATCH'];
33	10	if (methods.indexOf(this.req.method) > -1) {
34	0	return this.getPostData();
35		}
36	10	return getPromise(this.http);
37		},
38		/**
39		* 检测是否含有post数据
40		* @return {Boolean} [description]
41		*/
42		hasPostData: function(){
43	0	if ('transfer-encoding' in this.req.headers) {
44	0	return true;
45		}
46	0	var contentLength = this.req.headers['content-length'] \| 0;
47	0	return contentLength > 0;
48		},
49		/**
50		* 含有文件的表单上传
51		* @return {[type]} [description]
52		*/
53		_filePost: function(){
54	0	var deferred = getDefer();
55	0	var self = this;
56	0	var form = new multiparty.Form({
57		maxFieldsSize: C('post_max_fields_size'),
58		maxFields: C('post_max_fields'),
59		maxFilesSize: C('post_max_file_size')
60		});
61	0	form.on('file', function(name, value){
62	0	self.http.file[name] = value;
63		});
64	0	form.on('field', function(name, value){
65	0	self.http.post[name] = value;
66		});
67	0	form.on('close', function(){
68	0	deferred.resolve(self.http);
69		});
70		//有错误后直接拒绝当前请求
71	0	form.on('error', function(){
72	0	self.res.statusCode = 413;
73	0	self.res.end();
74		});
75	0	form.parse(this.req);
76	0	return deferred.promise;
77		},
78		/**
79		* 普通的表单上传
80		* @return {[type]} [description]
81		*/
82		_commonPost: function(){
83	0	var buffers = [];
84	0	var length = 0;
85	0	var self = this;
86	0	var deferred = getDefer();
87	0	this.req.on('data', function(chunk){
88	0	buffers.push(chunk);
89	0	length += chunk.length;
90		});
91	0	this.req.on('end', function(){
92	0	self.http.payload = Buffer.concat(buffers).toString();
93	0	tag('form_parse', self.http).then(function(){
94		//默认使用querystring.parse解析
95	0	if (isEmpty(self.http.post) && self.http.payload) {
96	0	self.http.post = querystring.parse(self.http.payload) \|\| {}
97		}
98	0	var post = self.http.post;
99	0	var length = Object.keys(post);
100		//最大表单数超过限制
101	0	if (length > C('post_max_fields')) {
102	0	self.res.statusCode = 413;
103	0	self.res.end();
104	0	return;
105		}
106	0	for(var name in post){
107		//单个表单值长度超过限制
108	0	if (post[name].length > C('post_max_fields_size')) {
109	0	self.res.statusCode = 413;
110	0	self.res.end();
111	0	return;
112		}
113		}
114	0	deferred.resolve(self.http);
115		})
116		});
117	0	return deferred.promise;
118		},
119		/**
120		* 获取POST过来的数据，包含上传的文件
121		* 依赖multiparty库
122		* @return {[type]} [description]
123		*/
124		getPostData: function(){
125		//没有post数据，直接返回
126	0	if (!this.hasPostData()) {
127	0	return getPromise(this.http);
128		}
129		//上传的数据中是否含有文件的检测正则
130	0	var multiReg = /^multipart\/(form-data\|related);\s*boundary=(?:"([^"]+)"\|([^;]+))$/i;
131	0	if (multiReg.test(this.req.headers['content-type'])) {
132	0	return this._filePost();
133		}else{
134	0	return this._commonPost();
135		}
136		},
137		/**
138		* HttpRequest增强
139		* @return {[type]} [description]
140		*/
141		_request: function(){
142	10	var req = {
143		//http版本号
144		version: this.req.httpVersion,
145		//请求方法
146		method: this.req.method,
147		//请求头
148		headers: this.req.headers,
149		getHeader: function(name){
150	9	return this.headers[name] \|\| '';
151		},
152		//请求的Content-Type
153		contentType: (this.req.headers['content-type'] \|\| '').split(';')[0].trim(),
154		//post信息
155		post: {},
156		//上传的文件信息
157		file: {},
158		//请求用户的ip
159		ip: function(){
160	2	var connection = this.req.connection;
161	2	var socket = this.req.socket;
162	2	var ip = (connection && connection.remoteAddress) \|\| (socket && socket.remoteAddress);
163	2	if (ip && ip !== localIp) {
164	0	return ip;
165		}
166	2	return this.headers['x-forwarded-for'] \|\| this.headers['x-real-ip'] \|\| localIp;
167		},
168		//请求的cookie
169		cookie: cookie.parse(this.req.headers.cookie \|\| '')
170		};
171	10	extend(this.http, req);
172
173		//解析url中的参数
174	10	var urlInfo = url.parse('//' + req.headers.host + this.req.url, true, true);
175	10	this.http.pathname = urlInfo.pathname;
176		//query只记录?后面的参数
177	10	this.http.query = urlInfo.query;
178		//get包含路由解析追加的参数
179	10	this.http.get = extend({}, urlInfo.query);
180		//主机名，带端口
181	10	this.http.host = urlInfo.host;
182		//主机名，不带端口
183	10	this.http.hostname = urlInfo.hostname;
184		//将原生的request对象放在http上，方便后续在controller等地方使用
185	10	this.http.req = this.req;
186		},
187		/**
188		* HttpResponse增强
189		* @return {[type]} [description]
190		*/
191		_response: function(){
192	10	var res = {
193		/**
194		* 一次请求下，可能会发送多个Cookie，所以这里不能立即发送
195		* 需要临时存起来，到输出内容前统一发送
196		* @type {Object}
197		*/
198		_cookie: {},
199		/**
200		* 发送header
201		* @param {[type]} name [description]
202		* @param {[type]} value [description]
203		*/
204		setHeader: function(name, value){
205	85	if (!this.res.headersSent) {
206	62	this.res.setHeader(name, value);
207		}
208		},
209		/**
210		* 设置cookie
211		* @param {[type]} name [description]
212		* @param {[type]} value [description]
213		* @param {[type]} options [description]
214		*/
215		setCookie: function(name, value, options){
216	5	options = options \|\| {};
217	5	if (typeof options === 'number') {
218	0	options = {timeout: options};
219		}
220	5	var timeout = options.timeout;
221	5	if (timeout === undefined) {
222	5	timeout = C('cookie_timeout');
223		}
224	5	delete options.timeout;
225		//if value is null, remove cookie
226	5	if (value === null) {
227	0	timeout = -1000;
228		}
229	5	var defaultOptions = {
230		path: C('cookie_path'),
231		domain: C('cookie_domain'),
232		expires: new Date (Date.now() + timeout * 1000)
233		};
234	5	if (timeout === 0) {
235	5	delete defaultOptions.expires;
236		}
237	5	for(var key in options){
238	0	defaultOptions[key.toLowerCase()] = options[key];
239		}
240	5	defaultOptions.name = name;
241	5	defaultOptions.value = encodeURIComponent(value + '');
242	5	this._cookie[name] = defaultOptions;
243		},
244		/**
245		* 将队列中的cookie发送出去
246		* @return {[type]} [description]
247		*/
248		sendCookie: function(){
249	54	var cookies = Object.values(this._cookie).map(function(item){
250	52	return cookie.stringify(item.name, item.value, item);
251		});
252	54	if (cookies.length) {
253	52	this.setHeader('Set-Cookie', cookies);
254		//发送Cookie后不清除_cookie内容，websocket里需要读取
255		//this._cookie = {};
256		}
257		},
258		/**
259		* url跳转
260		* @param {[type]} url [description]
261		* @param {[type]} code [description]
262		* @return {[type]} [description]
263		*/
264		redirect: function(url, code){
265	2	this.res.statusCode = code \|\| 302;
266	2	this.setHeader('Location', url \|\| '/');
267	2	this.end();
268		},
269		/**
270		* 发送执行时间
271		* @param {[type]} name [description]
272		* @return {[type]} [description]
273		*/
274		sendTime: function(name){
275	2	var time = Date.now() - this.startTime;
276	2	this.setHeader('X-' + (name \|\| 'EXEC-TIME'), time + 'ms');
277		},
278		/**
279		* 输出内容
280		* @param {[type]} obj [description]
281		* @param {[type]} encoding [description]
282		* @return {[type]} [description]
283		*/
284		echo: function(obj, encoding){
285	24	this.sendCookie();
286	24	if (obj === undefined) {
287	2	return;
288		}
289	22	if (isArray(obj) \|\| isObject(obj)) {
290	14	obj = JSON.stringify(obj);
291		}
292	22	if (!isString(obj) && !(obj instanceof Buffer)) {
293	0	obj += '';
294		}
295	22	this.res.write(obj, encoding \|\| C('encoding'));
296		},
297		/**
298		* 结束URL
299		* @return {[type]} [description]
300		*/
301		end: function(){
302	30	this.emit('beforeEnd', this);
303	30	this.sendCookie();
304	30	this.res.end();
305	30	this.emit('afterEnd', this);
306		}
307		};
308	10	extend(this.http, res);
309		//将原生的response对象放在http上，方便后续controller等地方使用
310	10	this.http.res = this.res;
311		}
312		};
313		});
314		/**
315		* 获取默认的http信息
316		* @param {[type]} data [description]
317		* @return {[type]} [description]
318		*/
319	1	module.exports.getDefaultHttp = function(data){
320	4	'use strict';
321	4	data = data \|\| {};
322	4	if (isString(data)) {
323	4	if (data[0] === '{') {
324	0	data = JSON.parse(data);
325	4	}else if (/^[\w]+\=/.test(data)) {
326	0	data = querystring.parse(data);
327		}else{
328	4	data = {url: data};
329		}
330		}
331	4	var fn = function(){
332	4	return '';
333		};
334	4	var url = data.url \|\| '';
335	4	if (url.indexOf('/') !== 0) {
336	0	url = '/' + url;
337		}
338	4	return {
339		req: {
340		httpVersion: '1.1',
341		method: data.method \|\| 'GET',
342		url: url,
343		headers: extend({
344		host: data.host \|\| localIp
345		}, data.headers \|\| {}),
346		connection: {
347		remoteAddress: data.ip \|\| localIp
348		}
349		},
350		res: {
351		end: data.end \|\| data.close \|\| fn,
352		write: data.write \|\| data.send \|\| fn,
353		setHeader: fn
354		}
355		};
356		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Model.js

68%

429

295

134

Line	Hits	Source
1	1	var util = require('util');
2	1	var querystring = require('querystring');
3	1	var Db = thinkRequire('Db');
4
5		//数据库实例化对象
6	1	var dbInstances = {};
7		//数据表的字段信息
8	1	var tableFields = {};
9
10		/**
11		* Model类
12		* @type {[type]}
13		*/
14	1	var Model = module.exports = Class(function(){
15	1	'use strict';
16		//解析page参数
17	1	var parsePage = function(options){
18	0	if ('page' in options) {
19	0	var page = options.page + '';
20	0	var num = 0;
21	0	if (page.indexOf(',') > -1) {
22	0	page = page.split(',');
23	0	num = parseInt(page[1], 10);
24	0	page = page[0];
25		}
26	0	num = num \|\| C('db_nums_per_page');
27	0	page = parseInt(page, 10) \|\| 1;
28	0	return {
29		page: page,
30		num: num
31		};
32		}
33	0	return {
34		page: 1,
35		num: C('db_nums_per_page')
36		};
37		};
38		/**
39		* 字符串命名风格转换
40		* @param {[type]} name [description]
41		* @param {[type]} type [description]
42		* @return {[type]} [description]
43		*/
44	1	var parseName = function(name, type){
45	28	name = (name + '').trim();
46	28	if (type) {
47	0	name = name.replace(/_([a-zA-Z])/g, function(a, b){
48	0	return b.toUpperCase();
49		});
50	0	return name.substr(0, 1).toUpperCase() + name.substr(1);
51		} else {
52		//首字母如果是大写，不转义为_x
53	28	if (name.length >= 1) {
54	28	name = name.substr(0, 1).toLowerCase() + name.substr(1);
55		}
56	28	return name.replace(/[A-Z]/g, function(a){
57	0	return '_' + a;
58		}).toLowerCase();
59		}
60		};
61
62	1	return {
63		// 当前数据库操作对象
64		db: null,
65		// 主键名称
66		pk: 'id',
67		// 数据库配置信息
68		config: null,
69		// 配置信息key
70		configKey: '',
71		// 模型名称
72		name: '',
73		// 数据表前缀
74		tablePrefix: '',
75		// 数据表名（不包含表前缀）
76		tableName: '',
77		// 实际数据表名（包含表前缀）
78		trueTableName: '',
79		// 数据表字段信息
80		fields: {},
81		// 数据信息
82		_data: {},
83		// 参数
84		_options: {},
85		/**
86		* 初始化
87		* @access public
88		* @param string $name 模型名称
89		* @param mixed config 数据库连接信息
90		*/
91		init: function(name, config){
92		// 获取模型名称
93	44	if (name) {
94	26	this.name = name;
95		}
96	44	if (isString(config)) {
97	0	config = {db_prefix: config};
98		}
99	44	this.config = config \|\| '';
100		//数据表前缀
101	44	if (this.config.db_prefix) {
102	0	this.tablePrefix = this.config.db_prefix;
103	44	}else if(!this.tablePrefix) {
104	44	this.tablePrefix = C('db_prefix');
105		}
106		},
107		/**
108		* 初始化数据库连接
109		* @return {[type]} [description]
110		*/
111		initDb: function(){
112	376	if (this.db) {
113	348	return this.db;
114		}
115	28	var config = this.config;
116	28	var configKey = md5(JSON.stringify(config));
117	28	if (!dbInstances[configKey]) {
118	1	dbInstances[configKey] = Db.getInstance(config);
119		}
120	28	this.db = dbInstances[configKey];
121	28	this.configKey = configKey;
122	28	return this.db;
123		},
124		/**
125		* 获取模型名
126		* @access public
127		* @return string
128		*/
129		getModelName: function(){
130	214	if (this.name) {
131	203	return this.name;
132		}
133	11	var filename = this.__filename \|\| __filename;
134	11	var last = filename.lastIndexOf('/');
135	11	this.name = filename.substr(last + 1, filename.length - last - 9);
136	11	return this.name;
137		},
138		/**
139		* 获取表名
140		* @return {[type]} [description]
141		*/
142		getTableName: function(){
143	195	if (!this.trueTableName) {
144	28	var tableName = this.tablePrefix \|\| '';
145	28	tableName += this.tableName \|\| parseName(this.getModelName());
146	28	this.trueTableName = tableName.toLowerCase();
147		}
148	195	return this.trueTableName;
149		},
150		/**
151		* 获取数据表信息
152		* @access protected
153		* @return Promise
154		*/
155		getTableFields: function(table, all){
156	196	this.initDb();
157	196	if (table === true) {
158	0	table = undefined;
159	0	all = true;
160		}
161	196	if (!isEmpty(this.fields)) {
162	168	return getPromise(all ? this.fields : this.fields._field);
163		}
164	28	var tableName = table \|\| this.getTableName();
165	28	var fields = tableFields[tableName];
166	28	if (!isEmpty(fields)) {
167	24	this.fields = fields;
168	24	return getPromise(all ? fields : fields._field);
169		}
170	4	var self = this;
171		//从数据表里查询字段信息
172	4	return this.flushFields(tableName).then(function(fields){
173	4	self.fields = fields;
174	4	if (C('db_fields_cache')) {
175	4	tableFields[tableName] = fields;
176		}
177	4	return getPromise(all ? fields : fields._field);
178		});
179		},
180		/**
181		* 获取数据表信息
182		* @param {[type]} table [description]
183		* @return Promise [description]
184		*/
185		flushFields: function(table){
186	5	table = table \|\| this.getTableName();
187	5	return this.initDb().getFields(table).then(function(data){
188	5	var fields = {
189		'_field': Object.keys(data \|\| {}),
190		'_autoinc': false,
191		'_unique': []
192		};
193	5	var types = {};
194	5	for(var key in data){
195	65	var val = data[key];
196	65	types[key] = val.type;
197	65	if (val.primary) {
198	5	fields._pk = key;
199	5	if (val.autoinc) {
200	5	fields._autoinc = true;
201		}
202	60	}else if (val.unique) {
203	5	fields._unique.push(key);
204		}
205		}
206	5	fields._type = types;
207	5	return fields;
208		})
209		},
210		/**
211		* 获取类型为唯一的字段
212		* @return {[type]} [description]
213		*/
214		// getUniqueField: function(data){
215		// var unqiueFileds = this.fields._unique;
216		// var unqiue = '';
217		// unqiueFileds.some(function(item){
218		// if (!data \|\| data[item]) {
219		// unqiue = item;
220		// return unqiue;
221		// }
222		// });
223		// return unqiue;
224		// },
225		/**
226		* 获取上一次操作的sql
227		* @return {[type]} [description]
228		*/
229		getLastSql: function(){
230	174	return this.initDb().getLastSql();
231		},
232		/**
233		* 获取主键名称
234		* @access public
235		* @return string
236		*/
237		getPk: function(){
238		//如果fields为空，那么异步去获取
239	35	if (isEmpty(this.fields)) {
240	9	var self = this;
241	9	return this.getTableFields().then(function(){
242	9	return self.fields_pk \|\| self.pk;
243		})
244		}
245	26	return this.fields._pk \|\| this.pk;
246		},
247		/**
248		* 缓存
249		* @param {[type]} key [description]
250		* @param {[type]} expire [description]
251		* @param {[type]} type [description]
252		* @return {[type]} [description]
253		*/
254		cache: function(key, timeout){
255	0	if (key === undefined) {
256	0	return this;
257		}
258	0	var options = this._getCacheOptions(key, timeout);
259	0	this._options.cache = options;
260	0	return this;
261		},
262		/**
263		* 获取缓存的选项
264		* @param {[type]} key [description]
265		* @param {[type]} timeout [description]
266		* @return {[type]} [description]
267		*/
268		_getCacheOptions: function(key, timeout, type){
269	0	if (isObject(key)) {
270	0	return key;
271		}
272	0	if (isNumber(key)) {
273	0	timeout = key;
274	0	key = '';
275		}
276	0	var cacheType = type === undefined ? C('db_cache_type') : type;
277	0	var options = {
278		key: key,
279		timeout: timeout \|\| C('db_cache_timeout'),
280		type: cacheType,
281		gcType: 'dbCache'
282		}
283	0	if (cacheType === 'File') {
284	0	options.cache_path = C('db_cache_path');
285		}
286	0	return options;
287		},
288		/**
289		* 指定查询数量
290		* @param {[type]} offset [description]
291		* @param {[type]} length [description]
292		* @return {[type]} [description]
293		*/
294		limit: function(offset, length){
295	4	this._options.limit = length === undefined ? offset : offset + ',' + length;
296	4	return this;
297		},
298		/**
299		* 指定分页
300		* @return {[type]} [description]
301		*/
302		page: function(page, listRows){
303	7	this._options.page = listRows === undefined ? page : page + ',' + listRows;
304	7	return this;
305		},
306		/**
307		* where条件
308		* @return {[type]} [description]
309		*/
310		where: function(where){
311	96	if (!where) {
312	2	return this;
313		}
314	94	if (isString(where)) {
315	3	where = {_string: where};
316		}
317	94	this._options.where = extend(this._options.where \|\| {}, where);
318	94	return this;
319		},
320		/**
321		* 要查询的字段
322		* @param {[type]} field [description]
323		* @param {[type]} reverse [description]
324		* @return {[type]} [description]
325		*/
326		field: function(field, reverse){
327	5	if (isArray(field)) {
328	2	field = field.join(',');
329	3	}else if (!field) {
330	1	field = '*';
331		}
332	5	this._options.field = field;
333	5	this._options.fieldReverse = reverse;
334	5	return this;
335		},
336		/**
337		* 设置表名
338		* @param {[type]} table [description]
339		* @return {[type]} [description]
340		*/
341		table: function(table, prefix){
342	2	if (!table) {
343	0	return this;
344		}
345	2	this._options.table = prefix ? table : this.tablePrefix + table;
346	2	return this;
347		},
348		/**
349		* 联合查询
350		* @return {[type]} [description]
351		*/
352		union: function(union, all){
353	5	if (!this._options.union) {
354	4	this._options.union = [];
355		}
356	5	this._options.union.push({
357		union: union,
358		all: all
359		});
360	5	return this;
361		},
362		/**
363		* .join({
364		* 'xxx': {
365		* join: 'left',
366		* as: 'c',
367		* on: ['id', 'cid']
368		* }
369		* })
370		* 联合查询
371		* @param {[type]} join [description]
372		* @return {[type]} [description]
373		*/
374		join: function(join){
375	18	if (!this._options.join) {
376	17	this._options.join = [];
377		}
378	18	if (isArray(join)) {
379	1	this._options.join = this._options.join.concat(join);
380		}else{
381	17	this._options.join.push(join);
382		}
383	18	return this;
384		},
385		/**
386		* 生成查询SQL 可用于子查询
387		* @param {[type]} options [description]
388		* @return {[type]} [description]
389		*/
390		buildSql: function(options){
391	1	var self = this;
392	1	return this.parseOptions(options).then(function(options){
393	1	return '( ' + self.db.buildSelectSql(options) + ' )';
394		});
395		},
396		/**
397		* 解析参数
398		* @param {[type]} options [description]
399		* @return promise [description]
400		*/
401		parseOptions: function(options, extraOptions){
402	185	options = extend({}, this._options, this.parseWhereOptions(options), extraOptions);
403		// 查询过后清空sql表达式组装避免影响下次查询
404	185	this._options = {};
405	185	options.table = options.table \|\| this.getTableName();
406		//表前缀，Db里会使用
407	185	options.tablePrefix = this.tablePrefix;
408	185	options.model = this.getModelName();
409	185	var promise = this.getTableFields(options.table);
410		//数据表别名
411	185	if (options.alias) {
412	6	options.table += ' AS ' + options.alias;
413		}
414	185	var self = this;
415	185	return promise.then(function(fields){
416		// 字段类型验证
417	185	if (isObject(options.where) && !isEmpty(fields)) {
418	95	var keyReg = /[\.\\|\&]/;
419		// 对数组查询条件进行字段类型检查
420	95	for(var key in options.where){
421	108	var val = options.where[key];
422	108	key = key.trim();
423	108	if (fields.indexOf(key) > -1) {
424	94	if (isScalar(val)) {
425	29	options.where[key] = self.parseType(options.where, key)[key];
426		}
427	14	}else if(key[0] !== '_' && !keyReg.test(key)){
428	1	delete options.where[key];
429		}
430		}
431		}
432		//field反选
433	185	if (options.field && options.fieldReverse) {
434	1	var optionsField = options.field.split(',');
435	1	options.field = fields.filter(function(item){
436	13	if (optionsField.indexOf(item) > -1) {
437	2	return;
438		}
439	11	return item;
440		}).join(',');
441		}
442	185	return self._optionsFilter(options, fields);
443		});
444		},
445		/**
446		* 选项过滤器
447		* 具体的Model类里进行实现
448		* @param {[type]} options [description]
449		* @return {[type]} [description]
450		*/
451		_optionsFilter: function(options){
452	185	return options;
453		},
454		/**
455		* 数据类型检测
456		* @param {[type]} data [description]
457		* @param {[type]} key [description]
458		* @return {[type]} [description]
459		*/
460		parseType: function(data, key){
461	45	var fieldType = this.fields._type[key] \|\| '';
462	45	if (fieldType.indexOf('bigint') === -1 && fieldType.indexOf('int') > -1) {
463	24	data[key] = parseInt(data[key], 10) \|\| 0;
464	21	}else if(fieldType.indexOf('double') > -1 \|\| fieldType.indexOf('float') > -1){
465	0	data[key] = parseFloat(data[key]) \|\| 0.0;
466	21	}else if(fieldType.indexOf('bool') > -1){
467	0	data[key] = !! data[key];
468		}
469	45	return data;
470		},
471		/**
472		* 对插入到数据库中的数据进行处理，要在parseOptions后执行
473		* @param {[type]} data [description]
474		* @return {[type]} [description]
475		*/
476		parseData: function(data){
477	21	data = extend({}, data);
478	21	var key;
479	21	if (!isEmpty(this.fields)) {
480	21	for(key in data){
481	25	var val = data[key];
482	25	if (this.fields._field.indexOf(key) === -1) {
483	1	delete data[key];
484	24	}else if(isScalar(val)){
485	16	data = this.parseType(data, key);
486		}
487		}
488		}
489		//安全过滤
490	21	if (typeof this._options.filter === 'function') {
491	0	for(key in data){
492	0	data[key] = this._options.filter.call(this, key, data[key]);
493		}
494	0	delete this._options.filter;
495		}
496	21	data = this._dataFilter(data);
497	21	return data;
498		},
499		/**
500		* 数据过滤器
501		* 具体的Model类里进行实现
502		* @param {[type]} data [description]
503		* @return {[type]} [description]
504		*/
505		_dataFilter: function(data){
506	21	return data;
507		},
508		/**
509		* 数据插入之前操作，可以返回一个promise
510		* @param {[type]} data [description]
511		* @param {[type]} options [description]
512		* @return {[type]} [description]
513		*/
514		_beforeAdd: function(data){
515	4	return data;
516		},
517		/**
518		* 数据插入之后操作，可以返回一个promise
519		* @param {[type]} data [description]
520		* @param {[type]} options [description]
521		* @return {[type]} [description]
522		*/
523		_afterAdd: function(data){
524	4	return data;
525		},
526		/**
527		* 添加一条数据
528		* @param {[type]} data [description]
529		* @param {[type]} options [description]
530		* @param int 返回插入的id
531		*/
532		add: function(data, options, replace){
533		//copy data
534	5	data = extend({}, this._data, data);
535	5	this._data = {};
536	5	if (isEmpty(data)) {
537	1	return getPromise(new Error('_DATA_TYPE_INVALID_'), true);
538		}
539	4	var self = this;
540		//解析后的选项
541	4	var parsedOptions = {};
542		//解析后的数据
543	4	var parsedData = {};
544	4	return this.parseOptions(options).then(function(options){
545	4	parsedOptions = options;
546	4	return self._beforeAdd(data, parsedOptions);
547		}).then(function(data){
548	4	parsedData = data;
549	4	data = self.parseData(data);
550	4	return self.db.insert(data, parsedOptions, replace);
551		}).then(function(){
552	4	parsedData[self.getPk()] = self.db.getLastInsertId();
553	4	return self._afterAdd(parsedData, parsedOptions);
554		}).then(function(){
555	4	return parsedData[self.getPk()];
556		});
557		},
558		/**
559		* 如果当前条件的数据不存在，才添加
560		* @param {[type]} data 要插入的数据
561		* @param {[type]} where where条件
562		* @param boolean returnType 返回值是否包含type
563		* @return {[type]} promise
564		*/
565		thenAdd: function(data, where, returnType){
566	0	if (where === true) {
567	0	returnType = true;
568	0	where = '';
569		}
570	0	var self = this;
571	0	return this.where(where).find().then(function(findData){
572	0	if (!isEmpty(findData)) {
573	0	var idValue = findData[self.getPk()];
574	0	return returnType ? {id: idValue, type: 'exist'} : idValue;
575		}
576	0	return self.add(data).then(function(insertId){
577	0	return returnType ? {id: insertId, type: 'add'} : insertId;
578		});
579		});
580		},
581		/**
582		* 插入多条数据
583		* @param {[type]} data [description]
584		* @param {[type]} options [description]
585		* @param {[type]} replace [description]
586		*/
587		addAll: function(data, options, replace){
588	6	if (!isArray(data) \|\| !isObject(data[0])) {
589	2	return getPromise(new Error('_DATA_TYPE_INVALID_'), true);
590		}
591	4	var self = this;
592	4	return this.parseOptions(options).then(function(options){
593	4	return self.db.insertAll(data, options, replace);
594		}).then(function(){
595	4	return self.db.getLastInsertId();
596		});
597		},
598		/**
599		* 删除后续操作
600		* @return {[type]} [description]
601		*/
602		_afterDelete: function(data){
603	4	return data;
604		},
605		/**
606		* 删除数据
607		* @return {[type]} [description]
608		*/
609		delete: function(options){
610	5	var self = this;
611	5	var parsedOptions = {};
612	5	var affectedRows = 0;
613	5	return this.parseOptions(options).then(function(options){
614	5	parsedOptions = options;
615	5	return self.db.delete(options);
616		}).then(function(rows){
617	4	affectedRows = rows;
618	4	return self._afterDelete(parsedOptions.where \|\| {}, parsedOptions);
619		}).then(function(){
620	4	return affectedRows;
621		})
622		},
623		/**
624		* 更新前置操作
625		* @param {[type]} data [description]
626		* @param {[type]} options [description]
627		* @return {[type]} [description]
628		*/
629		_beforeUpdate: function(data){
630	17	return data;
631		},
632		/**
633		* 更新后置操作
634		* @param {[type]} data [description]
635		* @param {[type]} options [description]
636		* @return {[type]} [description]
637		*/
638		_afterUpdate: function(data){
639	14	return data;
640		},
641		/**
642		* 更新数据
643		* @return {[type]} [description]
644		*/
645		update: function(data, options){
646	18	data = extend({}, data);
647	18	if (isEmpty(data)) {
648	1	if (!isEmpty(this._data)) {
649	0	data = this._data;
650	0	this._data = {};
651		}else{
652	1	return getPromise(new Error('_DATA_TYPE_INVALID_'), true);
653		}
654		}
655	17	var self = this;
656	17	var parsedOptions = {};
657	17	var parsedData = {};
658	17	var affectedRows = 0;
659	17	return this.parseOptions(options).then(function(options){
660	17	parsedOptions = options;
661	17	return self._beforeUpdate(data, options);
662		}).then(function(data){
663	17	var pk = self.getPk();
664	17	parsedData = data;
665	17	data = self.parseData(data);
666	17	if (isEmpty(parsedOptions.where)) {
667		// 如果存在主键数据则自动作为更新条件
668	5	if (!isEmpty(data[pk])) {
669	2	parsedOptions.where = getObject(pk, data[pk]);
670	2	delete data[pk];
671		}else{
672	3	return getPromise(new Error('_OPERATION_WRONG_'), true);
673		}
674		}else{
675	12	parsedData[pk] = parsedOptions.where[pk];
676		}
677	14	return self.db.update(data, parsedOptions);
678		}).then(function(rows){
679	14	affectedRows = rows;
680	14	return self._afterUpdate(parsedData, parsedOptions);
681		}).then(function(){
682	14	return affectedRows;
683		});
684		},
685		/**
686		* 更新多个数据，自动用主键作为查询条件
687		* @param {[type]} dataList [description]
688		* @return {[type]} [description]
689		*/
690		updateAll: function(dataList){
691	4	if (!isArray(dataList) \|\| !isObject(dataList[0])) {
692	2	return getPromise(new Error('_DATA_TYPE_INVALID_'), true);
693		}
694	2	var self = this;
695	2	var promises = dataList.map(function(data){
696	3	return self.update(data);
697		});
698	2	return Promise.all(promises);
699		},
700		/**
701		* 更新某个字段的值
702		* @param {[type]} field [description]
703		* @param {[type]} value [description]
704		* @return {[type]} [description]
705		*/
706		updateField: function(field, value){
707	10	var data = {};
708	10	if (isObject(field)) {
709	0	data = field;
710		}else{
711	10	data[field] = value;
712		}
713	10	return this.update(data);
714		},
715		/**
716		* 字段值增长
717		* @return {[type]} [description]
718		*/
719		updateInc: function(field, step){
720	4	step = parseInt(step, 10) \|\| 1;
721	4	return this.updateField(field, ['exp', field + '+' + step]);
722		},
723		/**
724		* 字段值减少
725		* @return {[type]} [description]
726		*/
727		updateDec: function(field, step){
728	4	step = parseInt(step, 10) \|\| 1;
729	4	return this.updateField(field, ['exp', field + '-' + step]);
730		},
731		/**
732		* 解析options中简洁的where条件
733		* @return {[type]} [description]
734		*/
735		parseWhereOptions: function(options){
736	185	if (isNumber(options) \|\| isString(options)) {
737	0	var pk = this.getPk();
738	0	options += '';
739	0	var where = {};
740	0	if (options.indexOf(',') > -1) {
741	0	where[pk] = ['IN', options];
742		}else{
743	0	where[pk] = options;
744		}
745	0	options = {
746		where: where
747		};
748		}
749	185	return options \|\| {};
750		},
751		/**
752		* find查询后置操作
753		* @return {[type]} [description]
754		*/
755		_afterFind: function(result){
756	2	return result;
757		},
758		/**
759		* 查询一条数据
760		* @return 返回一个promise
761		*/
762		find: function(options){
763	3	var self = this;
764	3	var parsedOptions = {};
765	3	return this.parseOptions(options, {
766		limit: 1
767		}).then(function(options){
768	3	parsedOptions = options;
769	3	return self.db.select(options);
770		}).then(function(data){
771	2	return self._afterFind(data[0] \|\| {}, parsedOptions);
772		});
773		},
774		/**
775		* 查询后置操作
776		* @param {[type]} result [description]
777		* @param {[type]} options [description]
778		* @return {[type]} [description]
779		*/
780		_afterSelect: function(result){
781	136	return result;
782		},
783		/**
784		* 查询数据
785		* @return 返回一个promise
786		*/
787		select: function(options){
788	137	var self = this;
789	137	var parsedOptions = {};
790	137	return this.parseOptions(options).then(function(options){
791	137	parsedOptions = options;
792	137	return self.db.select(options);
793		}).then(function(result){
794	136	return self._afterSelect(result, parsedOptions);
795		});
796		},
797		selectAdd: function(fields, table, options){
798	0	var self = this;
799	0	return this.parseOptions(options).then(function(options){
800	0	fields = fields \|\| options.field;
801	0	table = table \|\| self.getTableName();
802	0	return self.db.selectInsert(fields, table, options);
803		});
804		},
805		/**
806		* 返回数据里含有count信息的查询
807		* @param options 查询选项
808		* @param pageFlag 当页面不合法时的处理方式，true为获取第一页，false为获取最后一页，undefined获取为空
809		* @return promise
810		*/
811		countSelect: function(options, pageFlag){
812	0	if (isBoolean(options)) {
813	0	pageFlag = options;
814	0	options = {};
815		}
816	0	var self = this;
817		//解析后的options
818	0	var parsedOptions = {};
819	0	var result = {};
820	0	return this.parseOptions(options).then(function(options){
821	0	delete options.table;
822	0	parsedOptions = options;
823	0	return self.options({
824		where: options.where,
825		cache: options.cache,
826		join: options.join,
827		alias: options.alias
828		}).count((options.alias \|\| self.getTableName()) + '.' + self.getPk());
829		}).then(function(count){
830	0	var pageOptions = parsePage(parsedOptions);
831	0	var totalPage = Math.ceil(count / pageOptions.num);
832	0	if (isBoolean(pageFlag)) {
833	0	if (pageOptions.page > totalPage) {
834	0	pageOptions.page = pageFlag === true ? 1 : totalPage;
835		}
836	0	parsedOptions.page = pageOptions.page + ',' + pageOptions.num;
837		}
838	0	result = extend({count: count, total: totalPage}, pageOptions);
839	0	return self.select(parsedOptions);
840		}).then(function(data){
841	0	result.data = data;
842	0	return result;
843		});
844		},
845		/**
846		* 获取某个字段下的记录
847		* @return {[type]} [description]
848		*/
849		getField: function(field, one){
850	14	var self = this;
851	14	return this.parseOptions({'field': field}).then(function(options){
852	14	if (isNumber(one)) {
853	1	options.limit = one;
854	13	}else if (one === true) {
855	11	options.limit = 1;
856		}
857	14	return self.db.select(options);
858		}).then(function(data){
859	14	var multi = field.indexOf(',') > -1;
860	14	if (multi) {
861	1	var fields = field.split(/\s,\s/);
862	1	var result = {};
863	1	fields.forEach(function(item){
864	2	result[item] = [];
865		})
866	1	data.every(function(item){
867	9	fields.forEach(function(fItem){
868	18	if (one === true) {
869	0	result[fItem] = item[fItem];
870		}else{
871	18	result[fItem].push(item[fItem]);
872		}
873		})
874	9	return one === true ? false : true;
875		})
876	1	return result;
877		}else{
878	13	data = data.map(function(item){
879	117	return Object.values(item)[0];
880		})
881	13	return one === true ? data[0] : data;
882		}
883		});
884		},
885		/**
886		* 根据某个字段值获取一条数据
887		* @param {[type]} name [description]
888		* @param {[type]} value [description]
889		* @return {[type]} [description]
890		*/
891		getBy: function(name, value){
892	0	var where = getObject(name, value);
893	0	return this.where(where).find();
894		},
895		/**
896		* SQL查询
897		* @return {[type]} [description]
898		*/
899		query: function(sql, parse){
900	0	if (parse !== undefined && !isBoolean(parse) && !isArray(parse)) {
901	0	parse = [].slice.call(arguments);
902	0	parse.shift();
903		}
904	0	var self = this;
905	0	return this.parseSql(sql, parse).then(function(sql){
906	0	return self.db.select(sql, self._options.cache);
907		}).then(function(data){
908	0	self._options = {};
909	0	return data;
910		})
911		},
912		/**
913		* 执行SQL语法，非查询类的SQL语句，返回值为影响的行数
914		* @param {[type]} sql [description]
915		* @param {[type]} parse [description]
916		* @return {[type]} [description]
917		*/
918		execute: function(sql, parse){
919	0	if (parse !== undefined && !isBoolean(parse) && !isArray(parse)) {
920	0	parse = [].slice.call(arguments);
921	0	parse.shift();
922		}
923	0	var self = this;
924	0	return this.parseSql(sql, parse).then(function(sql){
925	0	return self.db.execute(sql);
926		});
927		},
928		/**
929		* 解析SQL语句
930		* @return promise [description]
931		*/
932		parseSql: function(sql, parse){
933	0	var promise = null;
934	0	var self = this;
935	0	if (parse === true) {
936	0	promise = this.parseOptions().then(function(options){
937	0	return self.db.parseSql(options);
938		});
939		}else{
940	0	if (parse === undefined) {
941	0	parse = [];
942		}else{
943	0	parse = isArray(parse) ? parse : [parse];
944		}
945	0	parse.unshift(sql);
946	0	sql = util.format.apply(null, parse);
947	0	var map = {
948		'__TABLE__': '`' + this.getTableName() + '`'
949		};
950	0	sql = sql.replace(/__([A-Z]+)__/g, function(a, b){
951	0	return map[a] \|\| ('`' + self.tablePrefix + b.toLowerCase() + '`');
952		});
953	0	promise = getPromise(sql);
954		}
955	0	this.initDb().setModel(self.getModelName());
956	0	return promise;
957		},
958		/**
959		* 设置数据对象值
960		* @return {[type]} [description]
961		*/
962		data: function(data){
963	0	if (data === true) {
964	0	return this._data;
965		}
966	0	if (isString(data)) {
967	0	data = querystring.parse(data);
968		}
969	0	this._data = data;
970	0	return this;
971		},
972		/**
973		* 设置操作选项
974		* @param {[type]} options [description]
975		* @return {[type]} [description]
976		*/
977		options: function(options){
978	0	if (options === true) {
979	0	return this._options;
980		}
981	0	this._options = options;
982	0	return this;
983		},
984		/**
985		* 关闭数据库连接
986		* @return {[type]} [description]
987		*/
988		close: function(){
989	0	delete dbInstances[this.configKey];
990	0	if (this.db) {
991	0	this.db.close();
992	0	this.db = null;
993		}
994		}
995		};
996		}).extend(function(){
997	1	'use strict';
998		//追加的方法
999	1	var methods = {};
1000		// 链操作方法列表
1001	1	var methodNameList = [
1002		'order','alias','having','group',
1003		'lock','auto','filter','validate'
1004		];
1005	1	methodNameList.forEach(function(item){
1006	8	methods[item] = function(data){
1007	20	this._options[item] = data;
1008	20	return this;
1009		};
1010		});
1011	1	methods.distinct = function(data){
1012	2	this._options.distinct = data;
1013		//如果传过来一个字段，则映射到field上
1014	2	if (isString(data)) {
1015	2	this._options.field = data;
1016		}
1017	2	return this;
1018		};
1019	1	['count','sum','min','max','avg'].forEach(function(item){
1020	5	methods[item] = function(field){
1021	10	field = field \|\| this.pk;
1022	10	return this.getField(item.toUpperCase() + '(' + field + ') AS thinkjs_' + item, true);
1023		};
1024		});
1025		//方法别名
1026	1	var aliasMethodMap = {
1027		update: 'save',
1028		updateField: 'setField',
1029		updateInc: 'setInc',
1030		updateDec: 'setDec'
1031		};
1032	1	Object.keys(aliasMethodMap).forEach(function(key){
1033	4	var value = aliasMethodMap[key];
1034	4	methods[value] = function(){
1035	0	return this[key].apply(this, arguments);
1036		};
1037		});
1038	1	return methods;
1039		});
1040		/**
1041		* 关闭所有的数据库连接
1042		* @return {[type]} [description]
1043		*/
1044	1	Model.close = function(){
1045	1	'use strict';
1046	1	for(var key in dbInstances) {
1047	0	dbInstances[key].close();
1048		}
1049	1	dbInstances = {};
1050		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Think.js

54%

174

94

80

Line	Hits	Source
1	1	var fs = require('fs');
2	1	var cluster = require('cluster');
3
4		//自动加载进行识别的路径
5	1	var autoloadPaths = {};
6		/**
7		* [exports description]
8		* @type {Object}
9		*/
10	1	module.exports = {
11		/**
12		* [start description]
13		* @return {[type]} [description]
14		*/
15		start: function(){
16	1	'use strict';
17	1	this.init();
18		//加载文件
19	1	this.loadFiles();
20		//合并自动加载的路径
21	1	this.mergeAutoloadPath();
22		//thinkRequire的autoload
23	1	registerAutoload(this.autoload);
24		//debug模式
25	1	if (APP_DEBUG) {
26	0	this.debug();
27		}else{
28	1	this.processEvent();
29		}
30		//记录进程的id
31	1	this.logPid();
32		//记录日志
33	1	this.log();
34
35	1	thinkRequire('App').run();
36		},
37		/**
38		* 定义一些目录，加载框架的基础文件
39		* @return {[type]} [description]
40		*/
41		init: function(){
42	1	'use strict';
43		//系统路径设置
44	1	global.THINK_LIB_PATH = THINK_PATH + '/Lib';
45	1	global.THINK_EXTEND_PATH = THINK_LIB_PATH + '/Extend';
46		//应用路径设置
47	1	var config = {
48		COMMON_PATH: APP_PATH + '/Common',
49		LIB_PATH: APP_PATH + '/Lib',
50		CONF_PATH: APP_PATH + '/Conf',
51		LANG_PATH: APP_PATH + '/Lang',
52		VIEW_PATH: APP_PATH + '/View',
53		//HTML_PATH: RUNTIME_PATH + '/Html',
54		LOG_PATH: RUNTIME_PATH + '/Log',
55		TEMP_PATH: RUNTIME_PATH + '/Temp',
56		DATA_PATH: RUNTIME_PATH + '/Data',
57		CACHE_PATH: RUNTIME_PATH + '/Cache'
58		};
59	1	for (var name in config) {
60	9	if (global[name] === undefined) {
61	9	global[name] = config[name];
62		}
63		}
64	1	require(THINK_PATH + '/Common/extend.js');
65	1	require(THINK_PATH + '/Common/common.js');
66	1	require(THINK_PATH + '/Common/function.js');
67		//别名导入
68	1	aliasImport(require(THINK_PATH + '/Conf/alias.js'));
69		},
70		/**
71		* 记录日志
72		* @return {[type]} [description]
73		*/
74		log: function(){
75	1	'use strict';
76	1	if (APP_DEBUG \|\| APP_MODE === 'cli' \|\| !C('log_record')) {
77	1	return;
78		}
79	0	thinkRequire('Log')().run();
80		},
81		/**
82		* 安全方式加载文件
83		* @param {[type]} file [description]
84		* @return {[type]} [description]
85		*/
86		safeRequire: function(file){
87	2	'use strict';
88	2	try{
89	2	return require(file);
90		}catch(e){
91	0	console.error(e.stack);
92		}
93	0	return {};
94		},
95		/**
96		* 注册异常处理
97		* @return {[type]} [description]
98		*/
99		processEvent: function(){
100	1	'use strict';
101	1	process.on('uncaughtException', function(err) {
102	0	console.error(isError(err) ? err.stack : err);
103		});
104		},
105		/**
106		* 加载项目下对应的文件
107		* @return {[type]} [description]
108		*/
109		loadFiles: function(){
110	1	'use strict';
111	1	C(null); //移除之前的所有配置
112		//加载系统默认配置
113	1	C(require(THINK_PATH + '/Conf/config.js'));
114		//加载用户配置
115	1	var file = CONF_PATH + '/config.js';
116	1	if (isFile(file)) {
117	1	C(this.safeRequire(file));
118		}
119		//加载模式的配置文件
120	1	if (APP_MODE) {
121	1	var modeFiles = [
122		THINK_PATH + '/Conf/mode.js',
123		CONF_PATH + '/mode.js'
124		];
125	1	var self = this;
126	1	modeFiles.forEach(function(file){
127	2	if (isFile(file)) {
128	1	var conf = self.safeRequire(file);
129	1	if (conf[APP_MODE]) {
130	1	C(conf[APP_MODE]);
131		}
132		}
133		});
134		}
135		//自定义路由
136	1	if (C('url_route_on') && isFile(CONF_PATH + '/route.js')) {
137	0	C('url_route_rules', this.safeRequire(CONF_PATH + '/route.js'));
138		}
139		//别名文件
140	1	if (isFile(CONF_PATH + '/alias.js')) {
141	0	aliasImport(this.safeRequire(CONF_PATH + '/alias.js'));
142		}
143		//common文件
144	1	if (isFile(COMMON_PATH + '/common.js')) {
145	1	require(COMMON_PATH + '/common.js');
146		}
147	1	this.loadTag();
148	1	this.loadExtConfig();
149	1	this.loadExtFiles();
150		},
151		//加载标签行为
152		loadTag: function(){
153	1	'use strict';
154		//系统标签
155	1	var tag = require(THINK_PATH + '/Conf/tag.js');
156		//用户行为标签
157	1	var tagFile = CONF_PATH + '/tag.js';
158	1	if (!C('app_tag_on') \|\| !isFile(tagFile)) {
159	1	C('tag', tag);
160	1	return;
161		}
162	0	var mixTag = extend({}, tag);
163	0	var userTag = extend({}, require(tagFile));
164	0	for(var key in userTag){
165	0	var value = userTag[key];
166	0	if (!value.length) {
167	0	continue;
168		}
169	0	mixTag[key] = mixTag[key] \|\| [];
170	0	if (isBoolean(value[0])) {
171	0	var flag = value.shift();
172	0	if (flag) { //true为替换系统标签
173	0	mixTag[key] = value;
174		}else{ //false为将自定义标签置为系统标签前面
175	0	mixTag[key] = value.concat(mixTag[key]);
176		}
177		}else{// 默认将用户标签置为系统标签后面
178	0	mixTag[key] = mixTag[key].concat(value);
179		}
180		}
181		//行为标签
182	0	C('tag', mixTag);
183		},
184		//加载自定义外部文件
185		loadExtFiles: function(){
186	1	'use strict';
187	1	var files = C('load_ext_file');
188	1	if (files) {
189	1	if (isString(files)) {
190	0	files = files.split(',');
191		}
192	1	files.forEach(function(file){
193	0	file = COMMON_PATH + '/' + file + '.js';
194	0	if (isFile(file)) {
195	0	require(file);
196		}
197		});
198		}
199		},
200		//加载额外的配置
201		loadExtConfig: function(){
202	1	'use strict';
203	1	var files = C('load_ext_config');
204	1	if (files) {
205	1	if (isString(files)) {
206	0	files = files.split(',');
207		}
208	1	files.forEach(function(file){
209	0	file = CONF_PATH + '/' + file + '.js';
210	0	if (isFile(file)) {
211	0	C(require(file));
212		}
213		});
214		}
215		},
216		//加载debug模式配置文件
217		loadDebugFiles: function(){
218	0	'use strict';
219		//加载debug模式下的配置
220	0	C(require(THINK_PATH + '/Conf/debug.js'));
221		//debug下自定义状态的配置
222	0	var status = C('app_status');
223	0	if (status) {
224	0	if (isFile(CONF_PATH + '/' + status + '.js')) {
225	0	C(require(CONF_PATH + '/' + status + '.js'));
226		}
227		}else{
228	0	if (isFile(CONF_PATH + '/debug.js')) {
229	0	C(require(CONF_PATH + '/debug.js'));
230		}
231		}
232	0	if (APP_MODE) {
233	0	var modeFiles = [
234		THINK_PATH + '/Conf/mode.js',
235		CONF_PATH + '/mode.js'
236		];
237	0	modeFiles.forEach(function(file){
238	0	if (isFile(file)) {
239	0	var conf = require(file);
240	0	var key = APP_MODE + '_debug';
241	0	if (conf[key]) {
242	0	C(conf[key]);
243		}
244		}
245		});
246		}
247		},
248		/**
249		* debug模式下一些特殊处理
250		* @return {[type]} [description]
251		*/
252		debug: function(){
253	0	'use strict';
254	0	this.loadDebugFiles();
255		//清除require的缓存
256	0	if (C('clear_require_cache')) {
257		//这些文件不清除缓存
258	0	var retainFiles = C('debug_retain_files');
259	0	var self = this;
260	0	setInterval(function(){
261	0	var fn = function(item){
262		//windows目录定界符为\
263	0	if (process.platform === 'win32') {
264	0	item = item.replace(/\//g, '\\');
265		}
266	0	if (file.indexOf(item) > -1) {
267	0	return true;
268		}
269		};
270	0	for(var file in require.cache){
271	0	var flag = retainFiles.some(fn);
272	0	if (!flag) {
273	0	delete require.cache[file];
274		}
275		}
276	0	self.loadFiles();
277	0	self.loadDebugFiles();
278		}, 100);
279		}
280		},
281		/**
282		* 记录当前进程的id
283		* 记录在Runtime/Data/app.pid文件里
284		* @return {[type]} [description]
285		*/
286		logPid: function(){
287	1	'use strict';
288	1	if (C('log_process_pid') && cluster.isMaster) {
289	0	mkdir(DATA_PATH);
290	0	var pidFile = DATA_PATH + '/app.pid';
291	0	fs.writeFileSync(pidFile, process.pid);
292	0	chmod(pidFile);
293		//进程退出时删除该文件
294	0	process.on('SIGTERM', function () {
295	0	if (fs.existsSync(pidFile)) {
296	0	fs.unlinkSync(pidFile);
297		}
298	0	process.exit(0);
299		});
300		}
301		},
302		/**
303		* 合并autoload的path
304		* @return {[type]} [description]
305		*/
306		mergeAutoloadPath: function(){
307	1	'use strict';
308	1	var file = '__CLASS__.js';
309	1	var sysAutoloadPath = {
310		'Behavior': [
311		LIB_PATH + '/Behavior/' + file,
312		THINK_LIB_PATH + '/Behavior/' + file
313		],
314		'Model': [
315		LIB_PATH + '/Model/' + file,
316		THINK_EXTEND_PATH + '/Model/' + file
317		],
318		'Logic': [
319		LIB_PATH + '/Logic/' + file
320		],
321		'Service': [
322		LIB_PATH + '/Service/' + file
323		],
324		'Controller': [
325		LIB_PATH + '/Controller/' + file,
326		THINK_EXTEND_PATH + '/Controller/' + file
327		],
328		'Cache': [
329		LIB_PATH + '/Driver/Cache/' + file,
330		THINK_LIB_PATH + '/Driver/Cache/' + file
331		],
332		'Db': [
333		LIB_PATH + '/Driver/Db/' + file,
334		THINK_LIB_PATH + '/Driver/Db/' + file
335		],
336		'Template': [
337		LIB_PATH + '/Driver/Template/' + file,
338		THINK_LIB_PATH + '/Driver/Template/' + file
339		],
340		'Socket': [
341		LIB_PATH + '/Driver/Socket/' + file,
342		THINK_LIB_PATH + '/Driver/Socket/' + file
343		],
344		'Session': [
345		LIB_PATH + '/Driver/Session/' + file,
346		THINK_LIB_PATH + '/Driver/Session/' + file
347		]
348		};
349	1	var autoloadPath = C('autoload_path');
350	1	for(var type in autoloadPath){
351	0	var paths = autoloadPath[type];
352	0	var override = false;
353	0	if (!isArray(paths)) {
354	0	paths = [paths];
355	0	}else if (isBoolean(paths[0])) {
356	0	override = paths.shift();
357		}
358	0	if (override) {
359	0	sysAutoloadPath[type] = paths;
360		}else{
361	0	paths.push.apply(paths, sysAutoloadPath[type]);
362	0	sysAutoloadPath[type] = paths;
363		}
364		}
365	1	autoloadPaths = sysAutoloadPath;
366		},
367		//thinkRequire的自动加载
368		autoload: function(cls){
369	46	'use strict';
370	46	var filepath = '';
371	46	var fn = function(item){
372	84	item = item.replace(/__CLASS__/g, cls);
373	84	if (isFile(item)) {
374	21	filepath = item;
375	21	return true;
376		}
377		};
378	46	for(var name in autoloadPaths){
379	346	var length = name.length;
380	346	if (cls.substr(0 - length) === name) {
381	44	var list = autoloadPaths[name];
382	44	list.some(fn);
383	44	if (filepath) {
384	21	if (!APP_DEBUG) {
385	21	aliasImport(cls, filepath);
386		}
387	21	return filepath;
388		}
389		}
390		}
391		}
392		};
393

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/View.js

89%

37

33

4

Line	Hits	Source
1		/**
2		* view
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Class(function(){
6	1	'use strict';
7	1	return {
8		init: function(http){
9	25	this.http = http;
10	25	this.tVar = {};
11		},
12		/**
13		* 给变量赋值
14		* @param {[type]} name [description]
15		* @param {[type]} value [description]
16		* @return {[type]} [description]
17		*/
18		assign: function(name, value){
19	57	if (name === undefined) {
20	1	return this.tVar;
21		}
22	56	if (isString(name) && arguments.length === 1) {
23	4	return this.tVar[name];
24		}
25	52	if (isObject(name)) {
26	1	this.tVar = extend(this.tVar, name);
27		}else{
28	51	this.tVar[name] = value;
29		}
30		},
31		/**
32		* 输出模版文件内容
33		* @param {[type]} templateFile [description]
34		* @param {[type]} charset [description]
35		* @param {[type]} contentType [description]
36		* @param {[type]} content [description]
37		* @return {[type]} [description]
38		*/
39		display: function(templateFile, charset, contentType){
40	3	var self = this;
41	3	return tag('view_init', this.http).then(function(){
42	3	return self.fetch(templateFile);
43		}).then(function(content){
44	3	self.render(content, charset, contentType);
45	3	return tag('view_end', self.http, content);
46		}).then(function(){
47	3	return self.http.end();
48		}).catch(function(){
49	0	return self.http.end();
50		});
51		},
52		/**
53		* 渲染模版
54		* @param {[type]} content [description]
55		* @param {[type]} charset [description]
56		* @param {[type]} contentType [description]
57		* @return {[type]} [description]
58		*/
59		render: function(content, charset, contentType){
60	3	if (!this.http.cthIsSend) {
61	3	charset = charset \|\| C('encoding');
62	3	contentType = contentType \|\| C('tpl_content_type');
63	3	this.http.setHeader('Content-Type', contentType + '; charset=' + charset);
64		}
65	3	if (C('show_exec_time')) {
66	0	this.http.sendTime('Exec-Time');
67		}
68	3	this.http.echo(content \|\| '', charset \|\| C('encoding'));
69		},
70		/**
71		* 获取模版文件内容
72		* @param {[type]} templateFile [description]
73		* @param {[type]} content [description]
74		* @return {[type]} [description]
75		*/
76		fetch: function(templateFile){
77	6	var self = this;
78	6	var promise = getPromise(templateFile);
79	6	if (!templateFile \|\| !isFile(templateFile)) {
80	6	promise = tag('view_template', this.http, templateFile).then(function(file){
81	6	if (isFile(file)) {
82	6	templateFile = file;
83		}else{
84	0	return getPromise(new Error("can't find template file"), true);
85		}
86		});
87		}
88	6	return promise.then(function(){
89	6	return tag('view_parse', self.http, {
90		'var': self.tVar,
91		'file': templateFile
92		});
93		}).then(function(content){
94	6	return tag('view_filter', self.http, content);
95		}).catch(function(err){
96		//输出模版解析异常
97	0	console.log(isError(err) ? err.stack : err);
98		});
99		}
100		};
101		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Cache/FileCache.js

71%

67

48

19

Line	Hits	Source
1	1	var fs = require('fs');
2		/**
3		* 基于文件的缓存
4		* @return {[type]} [description]
5		*/
6	1	module.exports = Cache(function(){
7	1	'use strict';
8	1	return {
9		gcType: 'FileCache',
10		init: function(options){
11	23	this.options = extend({
12		cache_path: C('cache_path'), //缓存目录
13		cache_path_level: 2, //缓存子目录深度
14		cache_file_suffix: C('cache_file_suffix') //缓存文件后缀名
15		}, options);
16	23	mkdir(this.options.cache_path);
17	23	this.gcType += ':' + this.options.cache_path;
18
19	23	this.super_('init', this.options);
20		},
21		/**
22		* 存储的缓存文件
23		* @param {[type]} name [description]
24		* @return {[type]} [description]
25		*/
26		getStoredFile: function(name){
27	47	name = md5(this.key \|\| name);
28	47	var dir = name.split('').slice(0, this.options.cache_path_level).join('/');
29	47	mkdir(this.options.cache_path + '/' + dir);
30	47	var path = this.options.cache_path + '/' + dir + '/' + name + this.options.cache_file_suffix;
31	47	return path;
32		},
33		/**
34		* 获取缓存，返回promise
35		* @param {[type]} name [description]
36		* @return {[type]} [description]
37		*/
38		getData: function(name){
39	9	var filePath = this.getStoredFile(name);
40	9	if (!isFile(filePath)) {
41	2	return getPromise();
42		}
43	7	var deferred = getDefer();
44	7	fs.exists(filePath, function(exists){
45	7	if (!exists) {
46	0	return deferred.resolve();
47		}
48	7	fs.readFile(filePath, {encoding: 'utf8'}, function(error, content){
49	7	if (error \|\| !content) {
50	0	return deferred.resolve();
51		}
52	7	try{
53	7	var data = JSON.parse(content);
54	7	if (Date.now() > data.expire) {
55	2	fs.unlink(filePath, function(){
56	2	return deferred.resolve();
57		});
58		}else{
59	5	deferred.resolve(data.data);
60		}
61		}catch(e){
62		//异常时删除该文件
63	0	fs.unlink(filePath, function(){
64	0	return deferred.resolve();
65		});
66		}
67		});
68		});
69	7	return deferred.promise;
70		},
71		get: function(name){
72	8	return this.getData(name).then(function(data){
73	8	return (data \|\| {})[name];
74		})
75		},
76		setData: function(name, value, timeout){
77	36	if (isObject(name)) {
78	29	timeout = value;
79		}
80	36	if (timeout === undefined) {
81	32	timeout = this.options.timeout;
82		}
83	36	var filePath = this.getStoredFile(name);
84	36	var data = {
85		data: isObject(name) ? name : getObject(name, value),
86		expire: Date.now() + timeout * 1000,
87		timeout: timeout
88		};
89	36	var deferred = getDefer();
90	36	fs.writeFile(filePath, JSON.stringify(data), function(){
91		//修改缓存文件权限，避免不同账号下启动时可能会出现无权限的问题
92	36	chmod(filePath);
93	36	deferred.resolve();
94		})
95	36	return deferred.promise;
96		},
97		/**
98		* 设置缓存
99		* @param {[type]} name [description]
100		* @param {[type]} value [description]
101		* @param {[type]} expire [description]
102		*/
103		set: function(name, value, timeout){
104	7	return this.setData(name, value, timeout);
105		},
106		/**
107		* 删除缓存
108		* @param {[type]} name [description]
109		* @return {[type]} [description]
110		*/
111		rm: function(name){
112	2	var filePath = this.getStoredFile(name);
113	2	if (isFile(filePath)) {
114	2	var deferred = getDefer();
115	2	fs.unlink(filePath, function(){
116	2	deferred.resolve();
117		})
118	2	return deferred.promise;
119		}
120	0	return getPromise();
121		},
122		/**
123		* gc
124		* @param {[type]} now [description]
125		* @return {[type]} [description]
126		*/
127		gc: function(now, path){
128	0	path = path \|\| this.options.cache_path;
129	0	var self = this;
130	0	var files = fs.readdirSync(path);
131	0	files.forEach(function(item){
132	0	var filePath = path + '/' + item;
133	0	var stat = fs.statSync(filePath);
134	0	if (stat.isDirectory()) {
135	0	self.gc(now, filePath);
136	0	}else if (stat.isFile()) {
137	0	var data = getFileContent(filePath);
138	0	try{
139	0	data = JSON.parse(data);
140	0	if (now > data.expire) {
141	0	fs.unlink(filePath, function(){});
142		}
143		}catch(e){}
144		}
145		});
146		}
147		};
148		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Cache/MemcacheCache.js

35%

14

5

9

Line	Hits	Source
1	1	var memcache = thinkRequire('MemcacheSocket');
2	1	module.exports = Cache(function(){
3	1	'use strict';
4	1	var instance = null;
5	1	return {
6		namePrefix: '__thinkjs__',
7		init: function(options){
8	0	this.super_('init', options);
9	0	if (!instance) {
10	0	instance = memcache(C('memcache_port'), C('memcache_host'));
11		}
12	0	this.handle = instance;
13		},
14		get: function(name){
15	0	return this.handle.get(this.namePrefix + name).then(function(value){
16	0	return value ? JSON.parse(value) : value;
17		})
18		},
19		set: function(name, value, timeout){
20	0	timeout = timeout \|\| this.options.timeout;
21	0	return this.handle.set(this.namePrefix + name, JSON.stringify(value), timeout);
22		},
23		rm: function(name){
24	0	return this.handle.delete(this.namePrefix + name);
25		}
26		};
27		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Db/MysqlDb.js

72%

51

37

14

Line	Hits	Source
1		/**
2		* mysql数据库
3		* @return {[type]} [description]
4		*/
5	1	var mysqlSocket = thinkRequire('MysqlSocket');
6	1	module.exports = Db(function(){
7	1	'use strict';
8
9	1	return {
10		init: function(config){
11	1	this.super_('init');
12	1	if (config) {
13	1	this.config = config;
14		}
15		//最后插入id
16	1	this.lastInsertId = 0;
17		//查询等待
18	1	this.queryWaiting = {};
19		},
20		/**
21		* 连接数据库
22		* @param {[type]} config [description]
23		* @param {[type]} linknum [description]
24		* @return {[type]} [description]
25		*/
26		connect: function(){
27	183	if (!this.linkId) {
28	1	this.linkId = mysqlSocket(this.config);
29		}
30	183	return this.linkId;
31		},
32		/**
33		* 查询一条sql
34		* @param string str
35		* @return promise
36		*/
37		query: function(str){
38	157	this.setSql(str);
39	157	var self = this;
40	157	if (!(str in this.queryWaiting)) {
41	157	this.queryWaiting[str] = [];
42	157	return this.connect().query(str).then(function(data){
43	157	process.nextTick(function(){
44	157	self.queryWaiting[str].forEach(function(deferred){
45	0	deferred.resolve(data);
46		});
47	157	delete self.queryWaiting[str];
48		})
49	157	return data;
50		});
51		}else{
52	0	var deferred = getDefer();
53	0	this.queryWaiting[str].push(deferred);
54	0	return deferred.promise;
55		}
56		},
57		/**
58		* 执行一条sql, 返回影响的行数
59		* @param {[type]} str [description]
60		* @return {[type]} [description]
61		*/
62		execute: function(str){
63	26	this.setSql(str);
64	26	var self = this;
65	26	return this.connect().query(str).then(function(data){
66	26	self.lastInsertId = data.insertId;
67	26	return data.affectedRows \|\| 0;
68		});
69		},
70		/**
71		* 获取数据表字段信息
72		* @param string tableName 数据表名
73		* @return promise 返回一个promise
74		*/
75		getFields: function(tableName){
76	5	var sql = 'SHOW COLUMNS FROM ' + this.parseKey(tableName);
77	5	return this.query(sql).then(function(data){
78	5	var ret = {};
79	5	data.forEach(function(item){
80	65	ret[item.Field] = {
81		'name': item.Field,
82		'type': item.Type,
83		'notnull': item.Null === '',
84		'default': item.Default,
85		'primary': item.Key === 'PRI',
86		'unique': item.Key === 'UNI',
87		'autoinc': item.Extra.toLowerCase() === 'auto_increment'
88		};
89		});
90	5	return ret;
91		});
92		},
93		/**
94		* 获取数据库的表信息
95		* @param {[type]} dbName [description]
96		* @return {[type]} [description]
97		*/
98		getTables: function(dbName){
99	0	var sql = 'SHOW TABLES';
100	0	if (dbName) {
101	0	sql += ' FROM ' + dbName;
102		}
103	0	return this.query(sql).then(function(data){
104	0	return data.map(function(item){
105	0	for(var key in item){
106	0	return item[key];
107		}
108		});
109		});
110		},
111		/**
112		* 关闭连接
113		* @return {[type]} [description]
114		*/
115		close: function(){
116	0	if (this.linkId) {
117	0	this.linkId.close();
118	0	this.linkId = null;
119		}
120		},
121		/**
122		* 解析key
123		* @param {[type]} key [description]
124		* @return {[type]} [description]
125		*/
126		parseKey: function(key){
127	360	key = (key \|\| '').trim();
128	360	if (!(/[,\'\"\*`.\s]/.test(key))) {
129	339	key = '`' + key + '`';
130		}
131	360	return key;
132		},
133		/**
134		* 获取最后插入的id
135		* @return {[type]} [description]
136		*/
137		getLastInsertId: function(){
138	8	return this.lastInsertId;
139		}
140		};
141		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Session/DbSession.js

9%

33

3

30

Line	Hits	Source
1		/**
2		* DbSession
3		* 需要在数据库中建立对应的数据表
4		*
5		* DROP TABLE IF EXISTS `think_session`;
6		CREATE TABLE `think_session` (
7		`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
8		`key` varchar(255) NOT NULL DEFAULT '',
9		`data` text,
10		`expire` bigint(11) NOT NULL,
11		PRIMARY KEY (`id`),
12		UNIQUE KEY `cookie` (`key`),
13		KEY `expire` (`expire`)
14		) ENGINE=InnoDB DEFAULT CHARSET=utf8;
15		*
16		*
17		* @return {[type]} [description]
18		*/
19	1	module.exports = Cache(function(){
20	1	'use strict';
21	1	return {
22		/**
23		* gc类型
24		* @type {String}
25		*/
26		gcType: 'DbSession',
27		/**
28		* [init description]
29		* @param {[type]} options [description]
30		* @return {[type]} [description]
31		*/
32		init: function(options){
33	0	this.super_('init', options);
34	0	this.key = this.options.cookie;
35	0	this.data = {};
36	0	this.initData();
37		},
38		/**
39		* 初始化数据
40		* @return {[type]} [description]
41		*/
42		initData: function(){
43	0	if (!this.promise) {
44	0	var model = D('Session');
45	0	var self = this;
46	0	this.promise = model.where({key: this.key}).find().then(function(data){
47	0	self.data = {};
48	0	if (isEmpty(data)) {
49	0	return model.add({
50		key: self.key,
51		expire: Date.now() + self.options.timeout * 1000
52		});
53		}
54	0	if (Date.now() > data.expire) {
55	0	return;
56		}
57	0	self.data = JSON.parse(data.data \|\| '{}');
58		});
59		}
60	0	return this.promise;
61		},
62		/**
63		* 获取
64		* @param {[type]} name [description]
65		* @return {[type]} [description]
66		*/
67		get: function(name){
68	0	var self = this;
69	0	return this.initData().then(function(){
70	0	return self.data[name];
71		});
72		},
73		/**
74		* 设置
75		* @param {[type]} name [description]
76		* @param {[type]} value [description]
77		*/
78		set: function(name, value){
79	0	var self = this;
80	0	return this.initData().then(function(){
81	0	self.data[name] = value;
82		});
83		},
84		/**
85		* 删除
86		* @param {[type]} name [description]
87		* @return {[type]} [description]
88		*/
89		rm: function(name){
90	0	if (this.data) {
91	0	delete this.data[name];
92		}
93	0	return getPromise();
94		},
95		/**
96		* 将数据保存到数据库中
97		* @return {[type]} [description]
98		*/
99		flush: function(){
100	0	var model = D('Session');
101	0	var self = this;
102	0	var data = {
103		expire: Date.now() + self.options.timeout * 1000,
104		data: JSON.stringify(self.data)
105		};
106	0	return this.initData().then(function(){
107	0	return model.where({key: self.key}).update(data);
108		});
109		},
110		/**
111		* [gc description]
112		* @param {[type]} now [description]
113		* @return {[type]} [description]
114		*/
115		gc: function(now){
116	0	return D('Session').where({
117		expire: ['<', now]
118		}).delete();
119		}
120		};
121		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Session/FileSession.js

96%

26

25

1

Line	Hits	Source
1		/**
2		* 文件Session
3		* @return {[type]} [description]
4		*/
5
6	1	var os = require('os');
7	1	module.exports = Class(function(){
8	1	'use strict';
9	1	return {
10		gcType: 'FileSession',
11		/**
12		* 差异化的init
13		* @return {[type]} [description]
14		*/
15		init: function(options){
16	6	options = options \|\| {};
17	6	options.cache_path = C('session_path') \|\| (os.tmpdir() + '/thinkjs');
18	6	this.super_('init', options);
19	6	this.key = options.cookie;
20		},
21		initData: function(){
22	39	if (!this.promise) {
23	1	var self = this;
24	1	this.promise = this.getData().then(function(data){
25	1	self.sessionData = data \|\| {};
26		})
27		}
28	39	return this.promise;
29		},
30		get: function(name){
31	5	var self = this;
32	5	return this.initData().then(function(){
33	5	return self.sessionData[name];
34		});
35		},
36		set: function(name, value, timeout){
37	5	var self = this;
38	5	return this.initData().then(function(){
39	5	self.sessionData[name] = value;
40	5	if (timeout) {
41	0	self.options.timeout = timeout;
42		}
43		});
44		},
45		rm: function(){
46	1	this.sessionData = {};
47	1	return getPromise();
48		},
49		/**
50		* 将数据写入到文件中
51		* @return {[type]} [description]
52		*/
53		flush: function(){
54	29	var self = this;
55	29	return this.initData().then(function(){
56	29	return self.setData(self.sessionData);
57		})
58		}
59		};
60		}, thinkRequire('FileCache'));

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Socket/MemcacheSocket.js

12%

124

15

109

Line	Hits	Source
1	1	var net = require('net');
2	1	var EventEmitter = require('events').EventEmitter;
3
4	1	var CRLF = '\r\n'; //换行符
5	1	var CRLF_LENGTH = CRLF.length;
6	1	var ERRORS = ['ERROR', 'NOT_FOUND', 'CLIENT_ERROR', 'SERVER_ERROR']; //错误
7	1	var ERRORS_LENGTH = ERRORS.length;
8
9		//读取一行数据
10	1	function readLine(string){
11	0	'use strict';
12	0	var pos = string.indexOf(CRLF);
13	0	if (pos > -1) {
14	0	return string.substr(0, pos);
15		}
16	0	return string;
17		}
18		/**
19		* memcache类
20		* @return {[type]} [description]
21		*/
22	1	module.exports = Class(function(){
23	1	'use strict';
24	1	return {
25		init: function(port, hostname){
26	0	EventEmitter.call(this);
27	0	this.port = port \|\| 11211;
28	0	this.hostname = hostname \|\| 'localhost';
29	0	this.buffer = '';
30	0	this.callbacks = []; //回调函数
31	0	this.handle = null; //socket连接句柄
32		},
33		/**
34		* 建立连接
35		* @return {[type]} [description]
36		*/
37		connect: function(){
38	0	if (this.handle) {
39	0	return this;
40		}
41	0	var self = this;
42	0	var deferred = getDefer();
43	0	this.handle = net.createConnection(this.port, this.host);
44	0	this.handle.on('connect', function(){
45	0	this.setTimeout(0);
46	0	this.setNoDelay();
47	0	self.emit('connect');
48	0	deferred.resolve();
49		});
50	0	this.handle.on('data', function(data){
51	0	self.buffer += data.toString();
52	0	self.handleData();
53		});
54	0	this.handle.on('end', function(){
55	0	self.handle.end();
56	0	self.handle = null;
57		});
58	0	this.handle.on('close', function(){
59	0	self.handle = null;
60	0	self.emit('close');
61		});
62	0	this.handle.on('timeout', function(){
63	0	self.handle = null;
64	0	self.emit('timeout');
65		});
66	0	this.handle.on('error', function(error){
67	0	self.handle = null;
68	0	self.emit('error', error);
69		});
70	0	this.promise = deferred.promise;
71	0	return this;
72		},
73		/**
74		* 处理接收的数据
75		* @return {[type]} [description]
76		*/
77		handleData: function(){
78	0	while(this.buffer.length > 0){
79	0	var result = this.getHandleResult(this.buffer);
80	0	if(result === false){
81	0	break;
82		}
83	0	var value = result[0];
84	0	var pos = result[1];
85	0	var error = result[2];
86	0	if (pos > this.buffer.length) {
87	0	break;
88		}
89	0	this.buffer = this.buffer.substring(pos);
90	0	var callback = this.callbacks.shift();
91	0	if (callback && callback.callback) {
92	0	callback.callback(error, value);
93		}
94		}
95		},
96		getHandleResult: function(buffer){
97	0	if (buffer.indexOf(CRLF) === -1) {
98	0	return false;
99		}
100	0	for(var i = 0; i < ERRORS_LENGTH; i++){
101	0	var item = ERRORS[i];
102	0	if (buffer.indexOf(item) > -1) {
103	0	return this.handleError(buffer);
104		}
105		}
106	0	var callback = this.callbacks[0];
107	0	if (callback && callback.type) {
108	0	return this['handle' + ucfirst(callback.type)](buffer);
109		}
110	0	return false;
111		},
112		/**
113		* 处理错误
114		* @param {[type]} buffer [description]
115		* @return {[type]} [description]
116		*/
117		handleError: function(buffer){
118	0	var line = readLine(buffer);
119	0	return [null, line.length + CRLF_LENGTH, line];
120		},
121		/**
122		* 处理获取数据
123		* @param {[type]} buffer [description]
124		* @return {[type]} [description]
125		*/
126		handleGet: function(buffer){
127	0	var value = null;
128	0	var end = 3;
129	0	var resultLen = 0;
130	0	var firstPos;
131	0	if (buffer.indexOf('END') === 0) {
132	0	return [value, end + CRLF_LENGTH];
133	0	}else if (buffer.indexOf('VALUE') === 0 && buffer.indexOf('END') > -1) {
134	0	firstPos = buffer.indexOf(CRLF) + CRLF_LENGTH;
135	0	var endPos = buffer.indexOf('END');
136	0	resultLen = endPos - firstPos - CRLF_LENGTH;
137	0	value = buffer.substr(firstPos, resultLen);
138	0	return [value, firstPos + parseInt(resultLen, 10) + CRLF_LENGTH + end + CRLF_LENGTH];
139		}else{
140	0	firstPos = buffer.indexOf(CRLF) + CRLF_LENGTH;
141	0	resultLen = buffer.substr(0, firstPos).split(' ')[3];
142	0	value = buffer.substr(firstPos, resultLen);
143	0	return [value, firstPos + parseInt(resultLen) + CRLF_LENGTH + end + CRLF_LENGTH];
144		}
145		},
146		/**
147		* 处理简单数据
148		* @param {[type]} buffer [description]
149		* @return {[type]} [description]
150		*/
151		handleSimple: function(buffer){
152	0	var line = readLine(buffer);
153	0	return [line, line.length + CRLF_LENGTH, null];
154		},
155		/**
156		* 版本号
157		* @param {[type]} buffer [description]
158		* @return {[type]} [description]
159		*/
160		handleVersion: function(buffer){
161	0	var pos = buffer.indexOf(CRLF);
162		//8 is length of 'VERSION '
163	0	var value = buffer.substr(8, pos - 8);
164	0	return [value, pos + CRLF_LENGTH, null];
165		},
166		/**
167		* 查询
168		* @param {[type]} query [description]
169		* @param {[type]} type [description]
170		* @param {Function} callback [description]
171		* @return {[type]} [description]
172		*/
173		query: function(query, type){
174	0	this.connect();
175	0	var self = this;
176	0	var deferred = getDefer();
177	0	var callback = function(error, value){
178	0	return error ? deferred.reject(error) : deferred.resolve(value);
179		}
180	0	this.promise.then(function(){
181	0	self.callbacks.push({type: type, callback: callback});
182	0	self.handle.write(query + CRLF);
183		});
184	0	return deferred.promise;
185		},
186		/**
187		* 获取
188		* @param {[type]} key [description]
189		* @param {Function} callback [description]
190		* @return {[type]} [description]
191		*/
192		get: function(key){
193	0	return this.query('get ' + key, 'get');
194		},
195		/**
196		* 存储
197		* @return {[type]} [description]
198		*/
199		store: function(key, value, type, lifetime, flags){
200	0	lifetime = lifetime \|\| 0;
201	0	flags = flags \|\| 0;
202	0	var length = Buffer.byteLength(value.toString());
203	0	var query = [type, key, flags, lifetime, length].join(' ') + CRLF + value;
204	0	return this.query(query, 'simple');
205		},
206		/**
207		* 删除
208		* @param {[type]} key [description]
209		* @param {Function} callback [description]
210		* @return {[type]} [description]
211		*/
212		delete: function(key){
213	0	return this.query('delete ' + key, 'simple');
214		},
215		/**
216		* 获取版本号
217		* @param {Function} callback [description]
218		* @return {[type]} [description]
219		*/
220		version: function(){
221	0	return this.query('version', 'version');
222		},
223		/**
224		* 增长
225		* @param {[type]} key [description]
226		* @param {[type]} step [description]
227		* @param {Function} callback [description]
228		* @return {[type]} [description]
229		*/
230		increment: function(key, step){
231	0	step = step \|\| 1;
232	0	return this.query('incr ' + key + ' ' + step, 'simple');
233		},
234		/**
235		* 减少
236		* @param {[type]} key [description]
237		* @param {[type]} step [description]
238		* @param {Function} callback [description]
239		* @return {[type]} [description]
240		*/
241		decrement: function(key, step){
242	0	step = step \|\| 1;
243	0	return this.query('decr ' + key + ' ' + step, 'simple');
244		},
245		/**
246		* 关闭
247		* @return {[type]} [description]
248		*/
249		close: function(){
250	0	if (this.handle && this.handle.readyState === 'open') {
251	0	this.handle.end();
252	0	this.handle = null;
253		}
254		}
255		}
256		}, EventEmitter).extend(function(){
257	1	'use strict';
258	1	var result = {};
259	1	['set', 'add', 'replace', 'append', 'prepend'].forEach(function(item){
260	5	result[item] = function(key, value, callback, lifetime, flags){
261	0	return this.store(key, value, item, callback, lifetime, flags);
262		}
263		});
264	1	return result;
265		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Socket/MysqlSocket.js

17%

45

8

37

Line	Hits	Source
1		/**
2		* mysql socket
3		* @return {[type]} [description]
4		*/
5
6		//暂时使用mysql库
7	1	var mysql = require('mysql');
8	1	module.exports = Class(function(){
9	1	'use strict';
10	1	return {
11		init: function(config){
12	1	this.handle = null;
13	1	this.config = config;
14	1	this.deferred = null;
15	1	this.tryTimes = 0;
16		},
17		/**
18		* 建立数据库连接
19		* @return {[type]} [description]
20		*/
21		connect: function(){
22	0	if (this.handle) {
23	0	return this.deferred.promise;
24		}
25	0	var self = this;
26	0	var deferred = getDefer();
27		//创建连接
28	0	var connection = mysql.createConnection({
29		host : this.config.hostname \|\| '127.0.0.1',
30		port : this.config.port \|\| 3306,
31		user : this.config.username \|\| 'root',
32		password : this.config.password \|\| '',
33		database : this.config.database \|\| '',
34		charset : this.config.charset
35		});
36		//连接
37	0	connection.connect(function(err){
38		//连接失败
39	0	if (err) {
40	0	deferred.reject(err);
41	0	self.close();
42		}else{
43	0	deferred.resolve();
44		}
45		});
46		//错误时关闭当前连接
47	0	connection.on('error', function(){
48	0	self.close();
49		});
50		//PROTOCOL_CONNECTION_LOST
51	0	connection.on('end', function(){
52	0	self.close();
53		})
54		//连接句柄
55	0	this.handle = connection;
56		//把上一次的promise reject
57	0	if (this.deferred) {
58	0	this.deferred.reject(new Error('connection closed'));
59		}
60	0	this.deferred = deferred;
61	0	return this.deferred.promise;
62		},
63		/**
64		* 查询sql语句，返回一个promise
65		* @param {[type]} sql [description]
66		* @return {[type]} [description]
67		*/
68		query: function(sql){
69	0	if (C('db_log_sql')) {
70	0	console.log('sql: ' + sql);
71		}
72	0	var self = this;
73	0	return this.connect().then(function(){
74	0	var deferred = getDefer();
75	0	self.handle.query(sql, function(err, rows){
76	0	if (err) {
77		//当数据量非常大时，可能会出现连接丢失，这里进行重连
78	0	if (err.code === 'PROTOCOL_CONNECTION_LOST' && self.tryTimes < 3) {
79	0	self.tryTimes++;
80	0	self.close();
81	0	return self.query(sql);
82		}
83	0	return deferred.reject(err);
84		}
85	0	self.tryTimes = 0;
86	0	return deferred.resolve(rows \|\| []);
87		});
88	0	return deferred.promise;
89		});
90		},
91		/**
92		* 关闭连接
93		* @return {[type]} [description]
94		*/
95		close: function(){
96	0	if (this.handle) {
97	0	this.handle.destroy();
98	0	this.handle = null;
99		}
100		}
101		};
102		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Template/EjsTemplate.js

100%

6

0

Line	Hits	Source
1		/**
2		* ejs
3		* https://github.com/visionmedia/ejs
4		* @type {[type]}
5		*/
6	1	var ejs = require('ejs');
7	1	module.exports = {
8		fetch: function(templateFile, tVar){
9	8	'use strict';
10	8	var content = getFileContent(templateFile);
11	8	var conf = extend({
12		filename: templateFile,
13		cache: true
14		}, C('tpl_engine_config'));
15	8	return ejs.compile(content, conf)(tVar);
16		}
17		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Extend/Controller/RestController.js

100%

46

0

Line	Hits	Source
1		/**
2		* REST Controller
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Controller(function(){
6	1	'use strict';
7	1	return {
8		init: function(http){
9	14	this.super('init', http);
10		//资源名
11	14	this.resource = this.get('resource');
12		//资源id
13	14	this.id = this.get('id') \| 0;
14		//实例化对应的模型
15	14	this.model = D(this.resource);
16		},
17		/**
18		* 获取
19		* @return {[type]} [description]
20		*/
21		getAction: function(){
22	4	var self = this;
23	4	if (this.id) {
24	2	return getPromise(this.model.getPk()).then(function(pk){
25	2	return self.model.where(getObject(pk, self.id)).find();
26		}).then(function(data){
27	1	return self.success(data);
28		}).catch(function(err){
29	1	return self.error(err.message);
30		})
31		}
32	2	return this.model.select().then(function(data){
33	1	return self.success(data);
34		}).catch(function(err){
35	1	return self.error(err.message);
36		});
37		},
38		/**
39		* 新建
40		* @return {[type]} [description]
41		*/
42		postAction: function(){
43	3	var self = this;
44	3	return getPromise(this.model.getPk()).then(function(pk){
45	3	var data = self.post();
46	3	delete data[pk];
47	3	if (isEmpty(data)) {
48	1	return self.error('data is empty');
49		}
50	2	return self.model.add(data);
51		}).then(function(insertId){
52	2	return self.success({id: insertId});
53		}).catch(function(err){
54	1	var msg = isError(err) ? err.message : err;
55	1	return self.error(msg);
56		});
57		},
58		/**
59		* 删除
60		* @return {[type]} [description]
61		*/
62		deleteAction: function(){
63	3	if (!this.id) {
64	1	return this.error('params error');
65		}
66	2	var self = this;
67	2	return getPromise(this.model.getPk()).then(function(pk){
68	2	return self.model.where(getObject(pk, self.id)).delete();
69		}).then(function(affectedRows){
70	1	return self.success({affectedRows: affectedRows});
71		}).catch(function(err){
72	1	return self.error(err.message);
73		});
74		},
75		/**
76		* 更新
77		* @return {[type]} [description]
78		*/
79		putAction: function(){
80	3	if (!this.id) {
81	1	return this.error('params error');
82		}
83	2	var self = this;
84	2	return getPromise(this.model.getPk()).then(function(pk){
85	2	var data = self.post();
86	2	delete data[pk];
87	2	if (isEmpty(data)) {
88	1	return self.error('data is empty');
89		}
90	1	return self.model.where(getObject(pk, self.id)).update(data);
91		}).then(function(affectedRows){
92	1	return self.success({affectedRows: affectedRows});
93		}).catch(function(err){
94	1	var msg = isError(err) ? err.message : err;
95	1	return self.error(msg);
96		});
97		},
98		__call: function(action){
99	1	return this.error('action `' + action + '` is not allowed');
100		}
101		}
102		})

/Users/welefen/Develop/git/thinkjs/lib/Lib/Extend/Model/AdvModel.js

5%

230

12

218

Line	Hits	Source
1		/**
2		* 高级模型
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Model(function(){
6	1	'use strict';
7		//关联类型
8	1	global.HAS_ONE = 1;
9	1	global.BELONGS_TO = 2;
10	1	global.HAS_MANY = 3;
11	1	global.MANY_TO_MANY = 4;
12
13		//post的操作类型
14	1	var ADD = 'ADD';
15	1	var UPDATE = 'UPDATE';
16	1	var DELETE = 'DELETE';
17
18		//get时不同的type对应的回调
19	1	var mapTypeGetFn = {
20		1: '_getHasOneRelation',
21		2: '_getBelongsToRelation',
22		3: '_getHasManyRelation',
23		4: '_getManyToManyRelation'
24		};
25
26		//post时不同的type对应的回调
27	1	var mapTypePostFn = {
28		1: '_postHasOneRelation',
29		2: '_postBelongsToRelation',
30		3: '_postHasManyRelation',
31		4: '_postManyToManyRelation'
32		};
33
34	1	return {
35		/**
36		* 关联定义
37		* 数据格式：
38		* 'Profile': {
39		type: 1,
40		model: 'Profile',
41		name: 'Profile',
42		key: 'id',
43		fKey: 'user_id',
44		field: 'id,name',
45		where: 'name=xx',
46		order: '',
47		limit: ''
48		* }
49		* @type {Object}
50		*/
51		relation: {},
52		/**
53		* 本次使用的关联名称，默认是全部使用
54		* @type {Boolean}
55		*/
56		_relationName: true,
57		/**
58		* 只读字段
59		* @type {String}
60		*/
61		readonlyField: '',
62		/**
63		* 保存时对数据进行校验
64		* @type {Boolean}
65		*/
66		_validateField: true,
67		/**
68		* 字段类型
69		* @type {Object}
70		*/
71		fieldType: {},
72		/**
73		* 设置本次使用的relation
74		* @param {[type]} name [description]
75		*/
76		setRelation: function(name, value){
77	0	if (isObject(name) \|\| !isEmpty(value)) {
78	0	var obj = isObject(name) ? name : getObject(name, value);
79	0	extend(this.relation, obj);
80	0	return this;
81		}
82	0	if (isString(name)) {
83	0	name = name.split(',');
84		}
85	0	this._relationName = name;
86	0	return this;
87		},
88		/**
89		* find后置操作
90		* @param {[type]} data [description]
91		* @return {[type]} [description]
92		*/
93		_afterFind: function(data, parsedOptions){
94	0	return this.getRelation(data, parsedOptions);
95		},
96		/**
97		* select后置操作
98		* @param {[type]} data [description]
99		* @return {[type]} [description]
100		*/
101		_afterSelect: function(data, parsedOptions){
102	0	return this.getRelation(data, parsedOptions);
103		},
104		/**
105		* 获取关联的数据
106		* @param {[type]} data [description]
107		* @param Boolean isDataList 是否是数据列表
108		* @return {[type]}
109		*/
110		getRelation: function(data, parsedOptions){
111	0	if (isEmpty(data) \|\| isEmpty(this.relation) \|\| isEmpty(this._relationName)) {
112	0	return data;
113		}
114	0	var self = this;
115	0	var promises = Object.keys(this.relation).map(function(key){
116	0	var mapName, mapType, model, mapKey, mapfKey;
117	0	var value = self.relation[key];
118	0	if (!isObject(value)) {
119	0	value = {type: value};
120		}
121	0	mapName = value.name \|\| key;
122		//如果不在开启的relation内，则直接返回
123	0	if (self._relationName !== true && self._relationName.indexOf(mapName) === -1) {
124	0	return;
125		}
126	0	mapType = value.type \|\| HAS_ONE;
127	0	mapKey = value.key \|\| self.getPk();
128	0	mapfKey = value.fKey \|\| (self.name.toLowerCase() + '_id');
129	0	model = D(value.model \|\| key);
130	0	model.where(value.where).cache(parsedOptions.cache).field(value.field).order(value.order).limit(value.limit);
131		//调用不同的类型解析
132	0	return self[mapTypeGetFn[mapType]](data, value, {
133		model: model,
134		mapName: mapName,
135		mapKey: mapKey,
136		mapfKey: mapfKey
137		}, parsedOptions);
138		});
139	0	return Promise.all(promises).then(function(){
140	0	return data;
141		});
142		},
143		_getHasOneRelation: function(data, value, mapOptions){
144	0	var self = this;
145	0	var where = self.parseRelationWhere(data, mapOptions.mapKey, mapOptions.mapfKey);
146	0	if (where === false) {
147	0	return {};
148		}
149	0	mapOptions.model.where(where);
150	0	return mapOptions.model.select().then(function(mapData){
151	0	return self.parseRelationData(data, mapData, mapOptions.mapName, mapOptions.mapKey, mapOptions.mapfKey);
152		});
153		},
154		_getBelongsToRelation: function(data, value, mapOptions){
155	0	var self = this;
156	0	var mapKey, mapfKey;
157	0	return mapOptions.model.getTableFields().then(function(){
158	0	mapKey = mapOptions.model.getModelName().toLowerCase() + '_id';
159	0	mapfKey = mapOptions.model.getPk();
160	0	var where = self.parseRelationWhere(data, mapKey, mapfKey);
161	0	if (where === false) {
162	0	return {};
163		}
164	0	mapOptions.model.where(where);
165	0	return mapOptions.model.select().then(function(mapData){
166	0	return self.parseRelationData(data, mapData, mapOptions.mapName, mapKey, mapfKey);
167		})
168		})
169		},
170		_getHasManyRelation: function(data, value, mapOptions){
171	0	var self = this;
172	0	var where = self.parseRelationWhere(data, mapOptions.mapKey, mapOptions.mapfKey);
173	0	if (where === false) {
174	0	return [];
175		}
176	0	mapOptions.model.where(where);
177	0	return mapOptions.model.select().then(function(mapData){
178	0	return self.parseRelationData(data, mapData, mapOptions.mapName, mapOptions.mapKey, mapOptions.mapfKey, true);
179		});
180		},
181		_getManyToManyRelation: function(data, value, mapOptions, parsedOptions){
182	0	var self = this;
183	0	return mapOptions.model.getTableFields().then(function(){
184	0	var where = self.parseRelationWhere(data, mapOptions.mapKey, mapOptions.mapfKey);
185	0	if (where === false) {
186	0	return [];
187		}
188	0	var whereStr = self.db.parseWhere(where);
189		//关联的实体表和关系表联合查询
190	0	var sql = 'SELECT b.%s, a.%s FROM %s as a, %s as b %s AND a.%s=b.%s %s';
191	0	var queryData = [
192		value.field \|\| '*',
193		mapOptions.mapfKey,
194		value.rTable \|\| self.getRelationTableName(mapOptions.model),
195		mapOptions.model.getTableName(),
196		whereStr \|\| 'WHERE ',
197		value.rfKey \|\| (mapOptions.model.getModelName().toLowerCase() + '_id'),
198		mapOptions.model.getPk(),
199		value.where ? (' AND ' + value.where) : ''
200		];
201	0	return self.parseSql(sql, queryData).then(function(sql){
202	0	return self.db.select(sql, parsedOptions.cache);
203		}).then(function(mapData){
204	0	return self.parseRelationData(data, mapData, mapOptions.mapName, mapOptions.mapKey, mapOptions.mapfKey, true);
205		});
206		});
207		},
208		/**
209		* 多对多关系下，获取对应的关联表
210		* @return {[type]} [description]
211		*/
212		getRelationTableName: function(model){
213	0	var table = [
214		this.tablePrefix,
215		this.tableName \|\| this.name,
216		'_',
217		model.getModelName()
218		].join('');
219	0	return table.toLowerCase();
220		},
221		/**
222		* 多堆垛关系下，回去对应关联表的模型
223		* @param {[type]} model [description]
224		* @return {[type]} [description]
225		*/
226		getRelationModel: function(model){
227	0	var name = ucfirst(this.tableName \|\| this.name) + ucfirst(model.getModelName());
228	0	return D(name);
229		},
230		/**
231		* 解析relation的where条件
232		* @param {[type]} data [description]
233		* @param {[type]} mapKey [description]
234		* @param {[type]} mapfKey [description]
235		* @return {[type]} [description]
236		*/
237		parseRelationWhere: function(data, mapKey, mapfKey){
238	0	if (isArray(data)) {
239	0	var keys = {};
240	0	data.forEach(function(item){
241	0	keys[item[mapKey]] = 1;
242		})
243	0	var value = Object.keys(keys);
244	0	if (value.length === 0) {
245	0	return false;
246		}
247	0	return getObject(mapfKey, ['IN', value]);
248		}
249	0	return getObject(mapfKey, data[mapKey]);
250		},
251		/**
252		* 解析查询后的数据
253		* @param {[type]} data [description]
254		* @param {[type]} mapData [description]
255		* @param {[type]} mapName [description]
256		* @param {[type]} mapKey [description]
257		* @param {[type]} mapfKey [description]
258		* @param {Boolean} isArrMap [description]
259		* @return {[type]} [description]
260		*/
261		parseRelationData: function(data, mapData, mapName, mapKey, mapfKey, isArrMap){
262	0	if (isArray(data)) {
263		//提前初始化，防止mapData为空导致data里的数据没有初始化的情况
264	0	data.forEach(function(item, i){
265	0	data[i][mapName] = isArrMap ? [] : {};
266		});
267	0	mapData.forEach(function(mapItem){
268	0	data.forEach(function(item, i){
269	0	if (mapItem[mapfKey] !== item[mapKey]) {
270	0	return;
271		}
272	0	if (isArrMap) {
273	0	data[i][mapName].push(mapItem);
274		}else{
275	0	data[i][mapName] = mapItem;
276		}
277		});
278		});
279		}else{
280	0	data[mapName] = isArrMap ? (mapData \|\| []) : (mapData[0] \|\| {});
281		}
282	0	return data;
283		},
284		/**
285		* 添加后置操作
286		* @param {[type]} data [description]
287		* @param {[type]} parsedOptions [description]
288		* @return {[type]} [description]
289		*/
290		_afterAdd: function(data, parsedOptions){
291	0	return this.postRelation(ADD, data, parsedOptions);
292		},
293		/**
294		* 删除后置操作
295		* @param {[type]} data [description]
296		* @param {[type]} parsedOptions [description]
297		* @return {[type]} [description]
298		*/
299		_afterDelete: function(data, parsedOptions){
300	0	return this.postRelation(DELETE, data, parsedOptions);
301		},
302		/**
303		* 更新前置操作
304		* @param {[type]} data [description]
305		* @param {[type]} parsedOptions [description]
306		* @return {[type]} [description]
307		*/
308		_beforeUpdate: function(data){
309		//只读字段处理
310	0	if (!isEmpty(this.readonlyField)) {
311	0	if (isString(this.readonlyField)) {
312	0	this.readonlyField = this.readonlyField.split(',');
313		}
314	0	this.readonlyField.forEach(function(field){
315	0	delete data[field];
316		});
317		}
318	0	return data;
319		},
320		/**
321		* 更新后置操作
322		* @param {[type]} data [description]
323		* @param {[type]} parsedOptions [description]
324		* @return {[type]} [description]
325		*/
326		_afterUpdate: function(data, parsedOptions){
327	0	return this.postRelation(UPDATE, data, parsedOptions);
328		},
329		/**
330		* 提交类关联操作
331		* @param {[type]} postType [description]
332		* @param {[type]} data [description]
333		* @param {[type]} parsedOptions [description]
334		* @return {[type]} [description]
335		*/
336		postRelation: function(postType, data, parsedOptions){
337	0	if (isEmpty(data) \|\| isEmpty(this.relation) \|\| isEmpty(this._relationName)) {
338	0	return data;
339		}
340	0	var self = this;
341	0	var promises = [];
342	0	Object.keys(this.relation).forEach(function(key){
343	0	var promise, mapName, mapType, model, mapKey, mapfKey, mapData;
344	0	var value = self.relation[key];
345	0	if (!isObject(value)) {
346	0	value = {type: value};
347		}
348	0	mapName = value.name \|\| key;
349		//如果没有开启对应的relation，则直接返回
350	0	if (self._relationName !== true && self._relationName.indexOf(mapName) === -1) {
351	0	return;
352		}
353	0	mapData = data[mapName];
354		//如果没有对应的数据，则直接返回
355	0	if (isEmpty(mapData) && postType !== DELETE) {
356	0	return;
357		}
358	0	mapKey = value.key \|\| self.getPk();
359	0	if (isEmpty(data[mapKey])) {
360	0	return;
361		}
362	0	mapType = value.type \|\| HAS_ONE;
363	0	mapfKey = value.fKey \|\| (self.name.toLowerCase() + '_id');
364	0	model = D(value.model \|\| key);
365	0	model.where(value.where);
366		//调用不同的类型解析
367	0	promise = self[mapTypePostFn[mapType]](data, value, {
368		model: model,
369		mapName: mapName,
370		mapKey: mapKey,
371		mapfKey: mapfKey,
372		mapData: mapData,
373		type: postType
374		}, parsedOptions);
375
376	0	promises.push(promise);
377		});
378	0	return Promise.all(promises).then(function(){
379	0	return data;
380		});
381		},
382		/**
383		* 一对一提交
384		* @param {[type]} data [description]
385		* @param {[type]} value [description]
386		* @param {[type]} mapOptions [description]
387		* @param {[type]} parsedOptions [description]
388		* @return {[type]} [description]
389		*/
390		_postHasOneRelation: function(data, value, mapOptions){
391	0	var promise = null;
392	0	var where;
393	0	switch(mapOptions.type){
394		case ADD:
395	0	mapOptions.mapData[mapOptions.mapfKey] = data[mapOptions.mapKey];
396	0	promise = mapOptions.model.add(mapOptions.mapData);
397	0	break;
398		case DELETE:
399	0	where = getObject(mapOptions.mapfKey, data[mapOptions.mapKey]);
400	0	promise = mapOptions.model.where(where).delete();
401	0	break;
402		case UPDATE:
403	0	where = getObject(mapOptions.mapfKey, data[mapOptions.mapKey]);
404	0	promise = mapOptions.model.where(where).update(mapOptions.mapData);
405	0	break;
406		default:
407	0	break;
408		}
409	0	return promise;
410		},
411		_postBelongsToRelation: function(data){
412	0	return data;
413		},
414		/**
415		* 一对多提交
416		* @param {[type]} data [description]
417		* @param {[type]} value [description]
418		* @param {[type]} mapOptions [description]
419		* @param {[type]} parsedOptions [description]
420		* @return {[type]} [description]
421		*/
422		_postHasManyRelation: function(data, value, mapOptions){
423	0	var type = mapOptions.type;
424	0	var mapData = mapOptions.mapData;
425	0	var model = mapOptions.model;
426	0	var promise;
427	0	if (!isArray(mapData)) {
428	0	mapData = [mapData];
429		}
430	0	switch(type){
431		case ADD:
432	0	mapData = mapData.map(function(item){
433	0	item[mapOptions.mapfKey] = data[mapOptions.mapKey];
434		});
435	0	promise = model.addAll(mapData);
436	0	break;
437		case UPDATE:
438	0	promise = model.getTableFields().then(function(){
439	0	var promises = [];
440	0	var pk = model.getPk();
441	0	mapData.forEach(function(item){
442	0	var pro;
443	0	if (item[pk]) {
444	0	pro = model.update(item);
445		}else{
446	0	item[mapOptions.mapfKey] = data[mapOptions.mapKey];
447	0	pro = model.add(item);
448		}
449	0	promises.push(pro);
450		});
451	0	return Promise.all(promises);
452		});
453	0	break;
454		case DELETE:
455	0	var where = getObject(mapOptions.mapfKey, data[mapOptions.mapKey]);
456	0	promise = model.where(where).delete();
457	0	break;
458		}
459	0	return promise;
460		},
461		/**
462		* 多对多提交
463		* @param Object data [description]
464		* @param object value [description]
465		* @param {[type]} mapOptions [description]
466		* @param {[type]} parsedOptions [description]
467		* @return {[type]} [description]
468		*/
469		_postManyToManyRelation: function(data, value, mapOptions){
470	0	var self = this;
471	0	var model = mapOptions.model;
472	0	var promise = model.getTableFields();
473	0	var rfKey = value.rfKey \|\| (model.getModelName().toLowerCase() + '_id');
474		//var relationTable = value.rTable \|\| self.getRelationTableName(model);
475	0	var where;
476	0	var type = mapOptions.type;
477	0	var mapData = mapOptions.mapData;
478	0	var relationModel = self.getRelationModel(model);
479	0	if (type === DELETE \|\| type === UPDATE) {
480	0	where = getObject(mapOptions.mapfKey, data[mapOptions.mapKey]);
481	0	promise = promise.then(function(){
482	0	return relationModel.where(where).delete();
483		});
484		}
485	0	if (type === ADD \|\| type === UPDATE) {
486	0	promise = promise.then(function(){
487	0	if (!isArray(mapData)) {
488	0	mapData = isString(mapData) ? mapData.split(',') : [mapData];
489		}
490	0	var firstItem = mapData[0];
491		//关系数据
492	0	if (isNumberString(firstItem) \|\| (isObject(firstItem) && (rfKey in firstItem))) {
493		//生成要更新的数据
494	0	var postData = mapData.map(function(item){
495	0	var key = [mapOptions.mapfKey, rfKey];
496	0	var val = [data[mapOptions.mapKey], item[rfKey] \|\| item];
497	0	return getObject(key, val);
498		});
499	0	return relationModel.addAll(postData);
500		}else{ //实体数据
501	0	var unqiueField = model.getUniqueField();
502	0	if (!unqiueField) {
503	0	return getPromise(model.getTableName() + ' table has no unqiue field', true);
504		}
505	0	return self._getRalationAddIds(mapData, model, unqiueField).then(function(ids){
506	0	var postData = ids.map(function(id){
507	0	var key = [mapOptions.mapfKey, rfKey];
508	0	var val = [data[mapOptions.mapKey], id];
509	0	return getObject(key, val);
510		});
511	0	return relationModel.addAll(postData);
512		});
513		}
514		});
515		}
516	0	return promise;
517		},
518		/**
519		* 插入数据，并获取插入的id集合
520		* @param {[type]} dataList [description]
521		* @param {[type]} model [description]
522		* @param {[type]} unqiueField [description]
523		* @return {[type]} [description]
524		*/
525		_getRalationAddIds: function(dataList, model, unqiueField){
526	0	var promises = [];
527	0	var ids = [];
528	0	dataList.forEach(function(item){
529	0	if (!isObject(item)) {
530	0	item = getObject(unqiueField, item);
531		}
532	0	var value = item[unqiueField];
533	0	if (!value) {
534	0	return true;
535		}
536	0	var where = getObject(unqiueField, value);
537	0	var promise = model.where(where).field(model.getPk()).find().then(function(data){
538	0	if (isEmpty(data)) {
539	0	return model.add(item).then(function(insertId){
540	0	ids.push(insertId);
541		});
542		}else{
543	0	ids.push(data[model.getPk()]);
544		}
545		});
546	0	promises.push(promise);
547		});
548	0	return Promise.all(promises).then(function(){
549	0	return ids;
550		});
551		},
552		/**
553		* 设置是否对数据进行校验
554		* @param {[type]} validate [description]
555		* @return {[type]} [description]
556		*/
557		validate: function(validate){
558	0	this._validateField = validate;
559		}
560		};
561		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Behavior.js

100%

7

0

Line	Hits	Source
1		/**
2		* 行为类
3		* @return {[type]} [description]
4		*/
5	1	module.exports = Class(function(){
6	1	'use strict';
7	1	return {
8		options: {}, //行为选项
9		http: null,
10		init: function(http){
11	67	this.http = http;
12	67	for(var name in this.options){
13	98	if (C(name) !== undefined) {
14	97	this.options[name] = C(name);
15		}
16		}
17		},
18		run: function(){
19
20		}
21		};
22		});

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Cache.js

66%

54

36

18

Line	Hits	Source
1		/**
2		* 缓存基类
3		* @return {[type]} [description]
4		*/
5		/**
6		* 缓存数据
7		* @type {Object}
8		*/
9	1	var cacheData = {};
10		/**
11		* 定时器
12		* @type {Number}
13		*/
14	1	var gcTimer = {};
15		/**
16		* 清除已经过期的Cache
17		* @return {[type]} [description]
18		*/
19	1	var gc = function(instance){
20	36	'use strict';
21	36	if (APP_DEBUG \|\| APP_MODE === 'cli' \|\| gcTimer[instance.gcType]) {
22	36	return;
23		}
24	0	gcTimer[instance.gcType] = setInterval(function(){
25	0	var hour = (new Date()).getHours();
26	0	if (C('cache_gc_hour').indexOf(hour) === -1) {
27	0	return;
28		}
29	0	var now = Date.now();
30	0	if (instance.gc) {
31	0	console.log('gc clean: ', instance.gcType, (new Date()).toUTCString());
32	0	instance.gc(now);
33		}
34		}, 3600 * 1000);
35		};
36
37	1	module.exports = Class(function(){
38	1	'use strict';
39	1	return {
40		/**
41		* gc的类型，用于定时器类型判断
42		* @type {String}
43		*/
44		gcType: 'Cache',
45		/**
46		* 初始化
47		* @param {[type]} options [description]
48		* @return {[type]} [description]
49		*/
50		init: function(options){
51	36	options = options \|\| {};
52	36	if (options.cacheData) {
53	0	this.cacheData = options.cacheData;
54		}else{
55	36	this.cacheData = cacheData;
56		}
57	36	if (options.gcType) {
58	0	this.gcType = options.gcType;
59		}
60	36	if (!options.timeout) {
61	21	options.timeout = C('cache_timeout')
62		}
63	36	this.options = options;
64		//操作的key
65	36	this.key = '';
66		//是否更新expire值
67	36	this.updateExpire = false;
68	36	gc(this);
69		},
70		/**
71		* 获取缓存值，返回一个promise
72		* @param {[type]} name [description]
73		* @return {[type]} [description]
74		*/
75		get: function(name){
76	5	var key = this.key \|\| name;
77	5	if (!(key in this.cacheData)) {
78	0	return getPromise();
79		}
80	5	var value = this.cacheData[key];
81	5	if (Date.now() > value.expire) {
82	2	delete this.cacheData[key];
83	2	return getPromise();
84		}
85	3	if (this.updateExpire) {
86	0	this.cacheData[key].expire = Date.now() + value.timeout * 1000;
87		}
88	3	return getPromise(value.data[name]);
89		},
90		/**
91		* 设置缓存值
92		* @param {[type]} name [description]
93		* @param {[type]} value [description]
94		*/
95		set: function(name, value, timeout){
96	6	if (timeout === undefined) {
97	0	timeout = this.options.timeout;
98		}
99	6	var key = this.key \|\| name;
100	6	if (key in this.cacheData) {
101	0	this.cacheData[key].data[name] = value;
102		}else{
103	6	this.cacheData[key] = {
104		data: getObject(name, value),
105		timeout: timeout,
106		expire: Date.now() + timeout * 1000
107		};
108		}
109	6	return getPromise();
110		},
111		/**
112		* 移除缓存值
113		* @param {[type]} name [description]
114		* @return {[type]} [description]
115		*/
116		rm: function(name){
117	1	var key = this.key \|\| name;
118	1	if (key in this.cacheData) {
119	1	delete this.cacheData[key].data[name];
120		}
121	1	return getPromise();
122		},
123		/**
124		* gc
125		* @param {[type]} now [description]
126		* @return {[type]} [description]
127		*/
128		gc: function(now){
129	0	for(var key in this.cacheData){
130	0	var item = this.cacheData[key] \|\| {};
131	0	if (now > item.expire) {
132	0	delete this.cacheData[key];
133		}
134		}
135		}
136		};
137		});

100%

35

0

Line	Hits	Source
1		/**
2		* cookie操作
3		* @type {Object}
4		*/
5	1	module.exports = {
6		/**
7		* 解析
8		* @param {[type]} str [description]
9		* @return {[type]} [description]
10		*/
11		parse: function(str){
12	22	'use strict';
13	22	var data = {};
14	22	str.split(/; */).forEach(function(item) {
15	44	var pos = item.indexOf('=');
16	44	if (pos === -1) {
17	9	return;
18		}
19	35	var key = item.substr(0, pos).trim();
20	35	var val = item.substr(pos + 1).trim();
21	35	if ('"' === val[0]) {
22	2	val = val.slice(1, -1);
23		}
24		// only assign once
25	35	if (undefined === data[key]) {
26	35	try {
27	35	data[key] = decodeURIComponent(val);
28		} catch (e) {
29	2	data[key] = val;
30		}
31		}
32		});
33	22	return data;
34		},
35		/**
36		* 格式化
37		* @param {[type]} name [description]
38		* @param {[type]} val [description]
39		* @param {[type]} options [description]
40		* @return {[type]} [description]
41		*/
42		stringify: function(name, value, options){
43	63	'use strict';
44	63	options = options \|\| {};
45	63	var item = [name + '=' + encodeURIComponent(value)];
46	63	if (options.maxage) {
47	1	item.push('Max-Age=' + options.maxage);
48		}
49	63	if (options.domain) {
50	1	item.push('Domain=' + options.domain);
51		}
52	63	if (options.path) {
53	53	item.push('Path=' + options.path);
54		}
55	63	var expires = options.expires;
56	63	if (expires){
57	2	if (!isDate(expires)) {
58	1	expires = new Date(expires);
59		}
60	2	item.push('Expires=' + expires.toUTCString());
61		}
62	63	if (options.httponly) {
63	1	item.push('HttpOnly');
64		}
65	63	if (options.secure) {
66	1	item.push('Secure');
67		}
68	63	return item.join('; ');
69		}
70		}

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Filter.js

100%

57

0

Line	Hits	Source
1		/**
2		* 过滤器
3		* @return {[type]} [description]
4		*/
5	1	var Filter = module.exports = {
6		/**
7		* 分页
8		* @param {[type]} value [description]
9		* @return {[type]} [description]
10		*/
11		page: function(value){
12	6	'use strict';
13	6	return this.id(value) \|\| 1;
14		},
15		/**
16		* xxx asc,yyy desc
17		* @return {[type]} [description]
18		*/
19		order: function(value){
20	7	'use strict';
21	7	if (isString(value)) {
22	6	value = value.split(',');
23		}
24	7	if (!isArray(value)) {
25	1	return '';
26		}
27	6	return value.filter(function(item){
28	8	item = item.trim().split(' ');
29	8	var field = item[0];
30	8	var type = item[1];
31	8	if (/^(ASC\|DESC)$/i.test(type) && /^[\w]+$/.test(field)) {
32	6	return field + ' ' + type;
33		}
34		}).join(',');
35		},
36		/**
37		* 大于0
38		* @return {[type]} [description]
39		*/
40		id: function(value){
41	14	'use strict';
42	14	value = parseInt(value + '', 10);
43	14	if (value > 0) {
44	7	return value;
45		}
46	7	return 0;
47		},
48		/**
49		* id列表
50		* @return {[type]} [description]
51		*/
52		ids: function(value, split){
53	5	'use strict';
54	5	if (isNumber(value)) {
55	2	value = this.id(value);
56	2	if (value) {
57	1	return [value];
58		}
59	1	return [];
60		}
61	3	if (isString(value)) {
62	2	value = value.split(split \|\| ',');
63		}
64	3	if (!isArray(value)) {
65	1	return [];
66		}
67	2	var ret = [];
68	2	for(var i = 0, length = value.length; i < length; i++){
69	3	var item = (value[i] + '').trim();
70	3	item = parseInt(item, 10);
71	3	if (item > 0) {
72	3	ret.push(item);
73		}
74		}
75	2	return ret;
76		},
77		/**
78		* 是否在一个中
79		* @param {[type]} value [description]
80		* @param {[type]} arr [description]
81		* @return {[type]} [description]
82		*/
83		in: function(value, arr){
84	4	'use strict';
85	4	if (!isArray(arr)) {
86	2	arr = [arr];
87		}
88	4	if(arr.indexOf(value) > -1){
89	2	return value;
90		}
91	2	return '';
92		},
93		/**
94		* 将字符串切割为数组
95		* @param {[type]} value [description]
96		* @param {[type]} split [description]
97		* @return {[type]} [description]
98		*/
99		strs: function(value, split){
100	5	'use strict';
101	5	if (isString(value)) {
102	4	value = value.split(split \|\| ',');
103		}
104	5	if (!isArray(value)) {
105	1	return [];
106		}
107	4	return value.filter(function(item){
108	7	return (item + '').trim();
109		});
110		}
111		};
112		/**
113		* 调用一个过滤器
114		* @param {[type]} data [description]
115		* @param {[type]} type [description]
116		* @return {[type]} [description]
117		*/
118	1	Filter.filter = function(value, type){
119	34	'use strict';
120	34	var fn = Filter[type];
121	34	if (typeof fn === 'function') {
122	33	var args = [].slice.call(arguments, 2);
123	33	args.unshift(value);
124	33	return Filter[type].apply(Filter, args);
125		}
126	1	return false;
127		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Session.js

100%

52

0

Line	Hits	Source
1	1	var crypto = require('crypto');
2		/**
3		* 生成uid
4		* @param int length
5		* @return string
6		*/
7	1	var uid = function(length){
8	4	'use strict';
9	4	var ratio = Math.log(64) / Math.log(256);
10	4	var numbytes = Math.ceil(length * ratio);
11	4	var str = crypto.randomBytes(numbytes).toString('base64').slice(0, length);
12	4	return str.replace(/\+/g, '_').replace(/\//g, '-');
13		};
14		/**
15		* 生成cookie签名
16		* @param string val
17		* @param string secret
18		* @return string
19		*/
20	1	var cookieSign = function(val, secret){
21	8	'use strict';
22	8	secret = crypto.createHmac('sha256', secret).update(val).digest('base64');
23	8	secret = secret.replace(/\=+$/, '');
24	8	return val + '.' + secret;
25		};
26		/**
27		* 解析cookie签名
28		* @param {[type]} val
29		* @param {[type]} secret
30		* @return {[type]}
31		*/
32	1	var cookieUnsign = function(val, secret){
33	5	'use strict';
34	5	var str = val.slice(0, val.lastIndexOf('.'));
35	5	return cookieSign(str, secret) === val ? str : '';
36		};
37
38	1	var Session = module.exports = Cache(function(){
39	1	'use strict';
40	1	return {
41		init: function(options){
42	1	this.super_('init', options);
43	1	this.key = this.options.cookie;
44	1	this.updateExpire = true;
45		}
46		};
47		});
48
49	1	Session.start = function(http){
50	18	'use strict';
51	18	if (http.session) {
52	11	return http.session;
53		}
54	7	var name = C('session_name');
55		//是否使用签名
56	7	var secret = C('session_sign');
57	7	var cookie = http.cookie[name];
58	7	if (cookie && secret) {
59	5	cookie = cookieUnsign(cookie, secret);
60	5	if (cookie) {
61	2	http.cookie[name] = cookie;
62		}
63		}
64	7	var session_cookie = cookie;
65	7	if (!cookie) {
66	4	cookie = uid(32);
67	4	session_cookie = cookie;
68	4	if (secret) {
69	3	cookie = cookieSign(cookie, secret);
70		}
71		//将生成的cookie放在http.cookie对象上，方便程序内读取
72	4	http.cookie[name] = cookie;
73	4	http.setCookie(name, cookie, C('session_options'));
74		}
75	7	var type = C('session_type');
76	7	if (!type) {
77	3	if (APP_DEBUG \|\| C('use_cluster')) {
78	2	type = 'File';
79	2	C('session_type', 'File');
80	2	console.log("in debug or cluster mode, session can't use memory for storage, convert to File");
81		}
82		}
83	7	name = type + 'Session';
84		//session类
85	7	var session = http.session = thinkRequire(name)({
86		cookie: session_cookie,
87		timeout: C('session_timeout')
88		});
89		//afterend时刷新缓存
90	7	http.on('afterEnd', function(){
91		//刷新session
92	29	return session.flush && session.flush();
93		})
94	7	return cookie;
95		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Valid.js

100%

101

0

Line	Hits	Source
1		/**
2		* Valid
3		* @return {[type]} [description]
4		*/
5	1	var net = require('net');
6
7	1	var Valid = {
8		/**
9		* 长度区域
10		* @param {[type]} min [description]
11		* @param {[type]} max [description]
12		* @return {[type]} [description]
13		*/
14		length: function(value, min, max){
15	6	'use strict';
16	6	min = min \| 0;
17	6	var length = ((value \|\| '') + '').length;
18	6	if (length < min) {
19	2	return false;
20		}
21	4	if (max && length > max) {
22	1	return false;
23		}
24	3	return true;
25		},
26		/**
27		* 必填
28		* @return {[type]} [description]
29		*/
30		required: function(value){
31	13	'use strict';
32	13	return ((value \|\| '') + '').length > 0;
33		},
34		/**
35		* 自定义正则校验
36		* @param {[type]} reg [description]
37		* @return {[type]} [description]
38		*/
39		regexp: function(value, reg){
40	17	'use strict';
41	17	return reg.test(value);
42		},
43		/**
44		* 邮箱
45		* @return {[type]} [description]
46		*/
47		email: function(value){
48	4	'use strict';
49	4	var reg = /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
50	4	return this.regexp(value, reg);
51		},
52		/**
53		* 时间戳
54		* @return {[type]} [description]
55		*/
56		time: function(value){
57	2	'use strict';
58	2	var reg = /^[1-5]\d{12}$/;
59	2	return this.regexp(value, reg);
60		},
61		/**
62		* 中文名
63		* @return {[type]} [description]
64		*/
65		cnname: function(value){
66	3	'use strict';
67	3	var reg = /^[\u4e00-\u9fa5\u3002\u2022]{2,32}$/;
68	3	return this.regexp(value, reg);
69		},
70		/**
71		* 身份证号码
72		* @return {[type]} [description]
73		*/
74		idnumber: function(value){
75	3	'use strict';
76	3	if (/^\d{15}$/.test(value)) {
77	1	return true;
78		}
79	2	if ((/^\d{17}[0-9xX]$/).test(value)) {
80	1	var vs = '1,0,x,9,8,7,6,5,4,3,2'.split(','),
81		ps = '7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2'.split(','),
82		ss = value.toLowerCase().split(''),
83		r = 0;
84	1	for (var i = 0; i < 17; i++) {
85	17	r += ps[i] * ss[i];
86		}
87	1	var isOk = (vs[r % 11] === ss[17]);
88	1	return isOk;
89		}
90	1	return false;
91		},
92		/**
93		* 手机号
94		* @return {[type]} [description]
95		*/
96		mobile: function(value){
97	2	'use strict';
98	2	var reg = /^(13\|15\|18\|14\|17)\d{9}$/;
99	2	return this.regexp(value, reg);
100		},
101		/**
102		* 邮编
103		* @return {[type]} [description]
104		*/
105		zipcode: function(value){
106	2	'use strict';
107	2	var reg = /^\d{6}$/;
108	2	return this.regexp(value, reg);
109		},
110		/**
111		* 2次值是否一致
112		* @param {[type]} field [description]
113		* @return {[type]} [description]
114		*/
115		confirm: function(value, cvalue){
116	2	'use strict';
117	2	return value === cvalue;
118		},
119		/**
120		* url
121		* @return {[type]} [description]
122		*/
123		url: function(value){
124	2	'use strict';
125	2	var reg = /^http(s?):\/\/(?:[A-za-z0-9-]+\.)+[A-za-z]{2,4}(?:[\/\?#][\/=\?%\-&~`@[\]\':+!\.#\w]*)?$/;
126	2	return this.regexp(value, reg);
127		},
128		/**
129		* 整数
130		* @param {[type]} o [description]
131		* @return {[type]} [description]
132		*/
133		int: function(value){
134	6	'use strict';
135	6	var val = parseInt(value, 10);
136	6	if (isNaN(val)) {
137	1	return false;
138		}
139	5	return (val + '').length === value.length;
140		},
141		/**
142		* 浮点数
143		* @return {[type]} [description]
144		*/
145		float: function(value){
146	2	'use strict';
147	2	return isNumberString(value);
148		},
149		/**
150		* 整数范围
151		* @param {[type]} min [description]
152		* @param {[type]} max [description]
153		* @return {[type]} [description]
154		*/
155		range: function(value, min, max){
156	4	'use strict';
157	4	value = parseInt(value, 10);
158	4	min = min \| 0;
159	4	if (isNaN(value) \|\| value < min) {
160	1	return false;
161		}
162	3	if (max && value > max) {
163	1	return false;
164		}
165	2	return true;
166		},
167		/**
168		* ip4校验
169		* @return {[type]} [description]
170		*/
171		ip4: function(value){
172	2	'use strict';
173	2	return net.isIPv4(value);
174		},
175		/**
176		* ip6校验
177		* @return {[type]} [description]
178		*/
179		ip6: function(value){
180	1	'use strict';
181	1	return net.isIPv6(value);
182		},
183		/**
184		* ip校验
185		* @return {[type]} [description]
186		*/
187		ip: function(value){
188	1	'use strict';
189	1	return net.isIP(value);
190		},
191		/**
192		* 日期校验
193		* @return {[type]} [description]
194		*/
195		date: function(value){
196	2	'use strict';
197	2	var reg = /^\d{4}-\d{1,2}-\d{1,2}$/;
198	2	return this.regexp(value, reg);
199		},
200		/**
201		* 在一个范围内
202		* @param {[type]} value [description]
203		* @param {[type]} arr [description]
204		* @return {[type]} [description]
205		*/
206		in: function(value, arr){
207	1	'use strict';
208	1	return arr.indexOf(value) > -1;
209		}
210		};
211		/**
212		* data格式
213		* [{
214		* value: xxx,
215		* name: '',
216		* valid: ['required', 'range'],
217		* range_args: [],
218		* msg:{
219		* required: '',
220		* range: ''
221		* }
222		* },{
223		* value: xxx,
224		* name: '',
225		* valid: ['required', 'range'],
226		* range_args: [],
227		* msg:{
228		* required: '',
229		* range: ''
230		* }
231		* }]
232		* @param {[type]} data [description]
233		* @return {[type]} [description]
234		*/
235	1	module.exports = function(data){
236	57	'use strict';
237	57	if (!data) {
238	1	return true;
239		}
240	56	if (!isArray(data)) {
241	48	data = [data];
242		}
243	56	var result = {};
244	56	data.forEach(function(item){
245	61	var valid = item.valid;
246	61	if (!isArray(valid)) {
247	53	valid = [valid];
248		}
249	61	valid.some(function(validItem){
250	63	var flag = true;
251		//自定义检测方法
252	63	if (isFunction(validItem)) {
253	4	flag = validItem(item.value, item);
254	4	if (isString(flag)) {
255	3	result[item.name] = flag;
256	3	flag = false;
257		}
258	59	}else if(!isFunction(Valid[validItem])){
259	1	throw new Error(validItem + ' is not valid');
260		}else{
261	58	var args = item[validItem + '_args'] \|\| [];
262	58	if (!isArray(args)) {
263	3	args = [args];
264		}
265	58	args = [item.value].concat(args);
266	58	flag = Valid[validItem].apply(Valid, args);
267	58	if (flag === false) {
268	33	var msg = (isObject(item.msg) ? item.msg[validItem] : item.msg) \|\| '';
269	33	msg = msg.replace('{name}', item.name).replace('{value}', item.value);
270	33	result[item.name] = msg;
271		}
272		}
273	62	return !flag;
274		});
275		});
276	55	return result;
277		};

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/WebSocket.js

8%

107

9

98

Line	Hits	Source
1	1	var thinkHttp = thinkRequire('Http');
2	1	var url = require('url');
3	1	var websocket = require('websocket').server;
4	1	var querystring = require('querystring');
5
6	1	var WebSocket = module.exports = Class(function(){
7	1	'use strict';
8		/**
9		* socket初始化id
10		* @type {Number}
11		*/
12	1	var socketId = 1000;
13	1	return {
14		init: function(httpServer, app){
15	0	this.httpServer = httpServer;
16	0	this.app = app;
17		},
18		/**
19		* 检测origin是否合法
20		* @param {[type]} origin [description]
21		* @return {[type]} [description]
22		*/
23		originIsAllowed: function(origin){
24	0	var allowOrigins = C('websocket_allow_origin');
25	0	if (!allowOrigins) {
26	0	return true;
27		}
28	0	var info = url.parse(origin);
29	0	var hostname = info.hostname;
30	0	if (isString(allowOrigins) && allowOrigins === hostname) {
31	0	return true;
32	0	}else if (isArray(allowOrigins) && allowOrigins.indexOf(hostname) > -1) {
33	0	return true;
34	0	}else if (isFunction(allowOrigins)) {
35	0	return allowOrigins(hostname, info);
36		}
37	0	return false;
38		},
39		/**
40		* 选择子协议
41		* @param {[type]} protocolFullCaseMap [description]
42		* @return {[type]} [description]
43		*/
44		getSubProtocal: function(protocolFullCaseMap){
45	0	var selectedProtocal = C('websocket_sub_protocal');
46	0	if (isFunction(selectedProtocal)) {
47	0	var subProtocals = Object.values(protocolFullCaseMap);
48	0	selectedProtocal = selectedProtocal(subProtocals);
49		}
50	0	return selectedProtocal;
51		},
52		/**
53		* 建立连接处理
54		* @param {[type]} request [description]
55		* @return {[type]} [description]
56		*/
57		openHandle: function(request, protocal){
58	0	var req = request.httpRequest;
59	0	if (req.url === '/') {
60	0	return getPromise([]);
61		}
62	0	var deferred = getDefer();
63	0	var fn = function(){};
64	0	var res = {setHeader: fn, end: fn, write: fn};
65	0	var self = this;
66	0	thinkHttp(req, res).run(function(http){
67	0	http.websocket = request.socket;
68		//子协议
69	0	http.websocket_sub_protocal = protocal;
70	0	self.app.listener(http).then(function(){
71	0	deferred.resolve({
72		cookie: Object.values(http._cookie),
73		http: http
74		});
75		}).catch(function(err){
76	0	deferred.reject(err);
77		})
78		});
79	0	return deferred.promise;
80		},
81		/**
82		* 消息处理
83		* @return {[type]} [description]
84		*/
85		messageHandle: function(message, connection, app, type){
86	0	if (type !== 'utf8') {
87	0	connection.socket.send(WebSocket.ERROR_MESSAGE.TYPE_ERROR, message + ' is not valid json');
88	0	return;
89		}
90		//解析数据
91	0	try{
92	0	message = JSON.parse(message);
93		}catch(e){
94	0	connection.socket.send(WebSocket.ERROR_MESSAGE.INVALID_JSON, message + ' is not valid json');
95	0	return;
96		}
97	0	if (message.jsonrpc !== '2.0') {
98	0	connection.socket.send(WebSocket.ERROR_MESSAGE.INVALID_JSONRPC, 'data.jsonrpc must be 2.0');
99	0	return;
100		}
101	0	var method = message.method + '';
102	0	if (!method) {
103	0	connection.socket.send(WebSocket.ERROR_MESSAGE.INVALID_METHOD, 'data.method is not valid');
104	0	return;
105		}
106	0	var pars = message.params;
107	0	var headers = {};
108	0	if (isObject(message.params.headers)) {
109	0	headers = message.params.headers;
110	0	pars = message.params.data;
111		}
112	0	if (isObject(pars)) {
113	0	method += (method.indexOf('?') > -1 ? '&' : '?') + querystring.stringify(pars)
114		}
115	0	var self = this;
116	0	var data = {
117		host: '',
118		url: method,
119		headers: headers,
120		write: function(data, encoding, errMsg){
121	0	var pars = self.getRPCData(JSON.parse(data), errMsg);
122	0	pars.id = message.id;
123	0	connection.send(JSON.stringify(pars));
124		},
125		end: function(data){
126	0	if (data) {
127	0	this.write(data);
128		}
129	0	connection.close();
130		}
131		}
132	0	var defaultHttp = thinkHttp.getDefaultHttp(data);
133	0	var httpInstance = thinkHttp(defaultHttp.req, defaultHttp.res);
134		//将websocket实例添加到http对象上
135	0	httpInstance.http.websocket = connection.socket;
136	0	httpInstance.run(app.listener);
137		},
138		/**
139		* 获取rpc数据对象
140		* @param {[type]} data [description]
141		* @param {[type]} errMsg [description]
142		* @return {[type]} [description]
143		*/
144		getRPCData: function(data, errMsg){
145	0	var pars = {jsonrpc: '2.0'};
146	0	if (errMsg) {
147	0	pars.error = {code: data, message: errMsg};
148		}else{
149	0	pars.result = data;
150		}
151	0	return pars;
152		},
153		run: function(){
154	0	var instance = new websocket({
155		httpServer: this.httpServer,
156		autoAcceptConnections: false
157		});
158	0	var self = this;
159	0	instance.on('request', function(request){
160		//检测origin
161	0	if (!self.originIsAllowed(request.origin)) {
162	0	return request.reject();
163		}
164	0	var socket = request.socket;
165	0	socket.id = socketId++;
166	0	socket.activeTime = Date.now();
167		//选择子协议
168	0	var protocal = self.getSubProtocal(request.protocolFullCaseMap);
169	0	return self.openHandle(request, protocal).then(function(data){
170	0	var connection = socket.connection = request.accept(protocal, request.origin, data.cookie);
171	0	socket.close = function(){
172	0	connection.close();
173		}
174	0	if (!socket.send) {
175	0	socket.send = function(data, errMsg){
176	0	var pars = self.getRPCData(data, errMsg);
177	0	connection.send(JSON.stringify(pars));
178		}
179		}
180	0	var messageHandle = C('websocket_message_handle');
181	0	connection.on('message', function(message) {
182	0	socket.activeTime = Date.now();
183	0	var data = message.type === 'utf8' ? message.utf8Data : message.binaryData;
184	0	if (isFunction(messageHandle)) {
185	0	messageHandle(data, connection, self.app, message.type);
186		}else{
187	0	self.messageHandle(data, connection, self.app, message.type);
188		}
189		});
190	0	connection.on('close', function() {
191	0	data.http.emit('websocket.close');
192		});
193		}).catch(function(err){
194	0	request.reject(err);
195		})
196		})
197		}
198		}
199		});
200		/**
201		* 错误信息
202		* @type {Object}
203		*/
204	1	WebSocket.ERROR_MESSAGE = {
205		TYPE_ERROR: -100001, //数据类型错误
206		INVALID_JSON: -100002, //不是合法的json
207		INVALID_JSONRPC: -100003, //不是jsonrpc数据格式
208		INVALID_METHOD: -100004 //请求方法不合法
209		}

/Users/welefen/Develop/git/thinkjs/lib/think.js

85%

20

17

3

Line	Hits	Source
1	1	var path = require('path');
2	1	var fs = require('fs');
3
4	1	if (!global.APP_PATH) {
5	0	throw new Error('APP_PATH must be defined');
6		}
7	1	if (!global.RUNTIME_PATH) {
8	1	global.RUNTIME_PATH = APP_PATH + '/Runtime';
9		}
10		//DEBUG模式
11	1	if (global.APP_DEBUG === undefined) {
12	1	global.APP_DEBUG = false;
13		}
14		//线上环境自动关闭debug模式
15	1	if (process.argv[2] === 'online' && APP_DEBUG === true) {
16	0	process.argv[2] = '';
17	0	APP_DEBUG = false;
18		}
19		//静态资源文件的根目录
20	1	global.RESOURCE_PATH = global.RESOURCE_PATH \|\| '';
21		//THINKJS的根目录
22	1	global.THINK_PATH = __dirname;
23		//默认为http模式
24	1	global.APP_MODE = global.APP_MODE \|\| '';
25		//命令行模式
26	1	if (process.argv[2]) {
27	1	APP_MODE = 'cli';
28		}
29		//从package.json文件里获取版本号
30	1	var pkgPath = path.dirname(THINK_PATH) + '/package.json';
31	1	var pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
32	1	global.THINK_VERSION = pkg.version;
33		//启动
34	1	require(THINK_PATH + '/Lib/Core/Think.js').start();

Coverage

/Users/welefen/Develop/git/thinkjs/lib/Common/common.js

/Users/welefen/Develop/git/thinkjs/lib/Common/extend.js

/Users/welefen/Develop/git/thinkjs/lib/Common/function.js

/Users/welefen/Develop/git/thinkjs/lib/Conf/alias.js

/Users/welefen/Develop/git/thinkjs/lib/Conf/config.js

/Users/welefen/Develop/git/thinkjs/lib/Conf/mode.js

/Users/welefen/Develop/git/thinkjs/lib/Conf/tag.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/CheckResourceBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/CheckRouteBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/DenyIpBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/LocationTemplateBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/ParseTemplateBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/ReadHtmlCacheBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Behavior/WriteHtmlCacheBehavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/App.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Controller.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Db.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Dispatcher.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Http.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Model.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/Think.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Core/View.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Cache/FileCache.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Cache/MemcacheCache.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Db/MysqlDb.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Session/DbSession.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Session/FileSession.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Socket/MemcacheSocket.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Socket/MysqlSocket.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Driver/Template/EjsTemplate.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Extend/Controller/RestController.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Extend/Model/AdvModel.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Behavior.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Cache.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Cookie.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Filter.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Session.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/Valid.js

/Users/welefen/Develop/git/thinkjs/lib/Lib/Util/WebSocket.js

/Users/welefen/Develop/git/thinkjs/lib/think.js