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	116	function T(args) {
24	116	for(var name in cls.__prop){
25	435	var val = cls.__prop[name];
26	435	this[name] = isObject(val) ? extend({}, val) : val;
27		}
28		//自动执行init方法
29	116	if(isFunction(this.init)){
30		//获取init返回值，如果返回一个promise，可以让后续执行在then之后
31	116	this.__initReturn = this.init.apply(this, args);
32		}
33	116	return this;
34		}
35	116	T.prototype = cls.prototype;
36	116	T.constructor = cls;
37	116	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	333	var val = prop[name];
48	333	if (isFunction(val)) {
49	292	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	30	if (!this[name]) {
75	1	return;
76		}
77	29	var super_ = this.constructor.super_;
78		//如果父级没有这个方法，那么直接返回
79	29	if (!isFunction(super_.prototype[name])) {
80	1	return;
81		}
82		//如果参数不是数组，自动转为数组
83	28	if (!isArray(data)) {
84	28	data = [data];
85		}
86	28	while(1){
87	29	if (this[name] === super_.prototype[name] && super_.super_) {
88	1	super_ = super_.super_;
89		}else{
90	28	break;
91		}
92		}
93	28	var method = super_.prototype[name];
94	28	delete super_.prototype[name];
95	28	var ret = method.apply(this, data);
96	28	super_.prototype[name] = method;
97	28	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	969	'use strict';
110	969	var args = [].slice.call(arguments);
111	969	var deep = true;
112	969	var target = args.shift();
113	969	if (isBoolean(target)) {
114	445	deep = target;
115	445	target = args.shift();
116		}
117	969	target = target \|\| {};
118	969	var length = args.length;
119	969	var options, name, src, copy, copyAsArray, clone;
120	969	for(var i = 0; i < length; i++){
121	1324	options = args[i] \|\| {};
122	1324	if (isFunction(options)) {
123	1	options = options();
124		}
125	1324	for(name in options){
126	1705	src = target[name];
127	1705	copy = options[name];
128	1705	if (src === copy) {
129	257	continue;
130		}
131	1448	if (deep && copy && (isObject(copy) \|\| (copyAsArray = isArray(copy) ))) {
132	443	if (copyAsArray) {
133	237	copyAsArray = false;
134	237	clone = src && isArray(src) ? src : [];
135		}else{
136	206	clone = src && isObject(src) ? src : {};
137		}
138	443	target[name] = extend(deep, clone, copy);
139	1005	}else if (copy !== undefined) {
140	1005	target[name] = copy;
141		}
142		}
143		}
144	969	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	1191	'use strict';
158	1191	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	543	'use strict';
167	543	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	3231	'use strict';
176	3231	if (isBuffer(obj)) {
177	2	return false;
178		}
179	3229	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	2453	'use strict';
188	2453	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	2294	'use strict';
197	2294	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	7	'use strict';
214	7	return util.isRegExp(obj);
215		};
216		/**
217		* 是否是个错误
218		* @param {[type]} obj [description]
219		* @return {Boolean} [description]
220		*/
221	1	global.isError = function(obj){
222	2	'use strict';
223	2	return util.isError(obj);
224		};
225		/**
226		* 判断对象是否为空
227		* @param {[type]} obj
228		* @return {Boolean}
229		*/
230	1	global.isEmpty = function(obj){
231	538	'use strict';
232	538	if (isObject(obj)) {
233	275	var key;
234	275	for(key in obj){
235	246	return false;
236		}
237	29	return true;
238	263	}else if (isArray(obj)) {
239	91	return obj.length === 0;
240	172	}else if (isString(obj)) {
241	2	return obj.length === 0;
242	170	}else if (isNumber(obj)) {
243	4	return obj === 0;
244	166	}else if (obj === null \|\| obj === undefined) {
245	163	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	136	'use strict';
258	136	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	120	'use strict';
279	120	if (!fs.existsSync(p)) {
280	76	return false;
281		}
282	44	var stats = fs.statSync(p);
283	44	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	480	'use strict';
320	480	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	75	'use strict';
352	75	mode = mode \|\| '0777';
353	75	if (fs.existsSync(p)) {
354	67	chmod(p, mode);
355	67	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	107	'use strict';
419	107	mode = mode \|\| '0777';
420	107	if (!fs.existsSync(p)) {
421	1	return true;
422		}
423	106	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	14	'use strict';
432	14	if (!fs.existsSync(file)) {
433	1	return '';
434		}
435	13	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	1740	'use strict';
456	1740	name = (name \|\| '') + '';
457	1740	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	63	'use strict';
466	63	var instance = crypto.createHash('md5');
467	63	instance.update(str + '');
468	63	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	475	'use strict';
477	475	if (isPromise(obj)) {
478	1	return obj;
479		}
480	474	if (reject) {
481	11	return Promise.reject(obj);
482		}
483	463	return Promise.resolve(obj);
484		};
485		/**
486		* 生成一个defer对象
487		* @return {[type]} [description]
488		*/
489	1	global.getDefer = function(){
490	82	'use strict';
491	82	var deferred = {};
492	82	deferred.promise = new Promise(function(resolve, reject){
493	82	deferred.resolve = resolve;
494	82	deferred.reject = reject;
495		});
496	82	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	25	'use strict';
506	25	var obj = {};
507	25	if (!isArray(key)) {
508	16	obj[key] = value;
509	16	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%

154

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	248	'use strict';
14	248	if (_alias[name]) {
15	202	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	211	'use strict';
32		//如果不是字符串则直接返回
33	211	if (!isString(name)) {
34	1	return name;
35		}
36	210	var path = name;
37	210	if (path[0] !== '/') {
38	210	path = getThinkRequirePath(name);
39		}
40	210	if (path) {
41	209	var obj = require(path);
42	209	if (isFunction(obj)) {
43		//修正子类继承的方法获取到正确的文件名
44	181	obj.prototype.__filename = path;
45		}
46	209	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	24	'use strict';
90	24	if (!name) {
91	1	return data;
92		}
93	23	if (typeof name === 'function') {
94	3	return name(http, data);
95		}
96	20	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	487	'use strict';
134		//获取所有的配置
135	487	if (arguments.length === 0) {
136	14	return _config;
137		}
138		//清除所有的配置
139	473	if (name === null) {
140	2	_config = {};
141	2	return;
142		}
143	471	if (isString(name)) {
144	467	name = name.toLowerCase();
145		//name里不含. 一级
146	467	if (name.indexOf('.') === -1) {
147	429	if (value === undefined) {
148	422	return _config[name];
149		}
150	7	_config[name] = value;
151	7	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	25	'use strict';
223	25	if (name === undefined) {
224	1	return thinkRequire('Model')(name, config);
225		}
226	24	name = name.split(':');
227	24	name[0] = name[0][0].toUpperCase() + name[0].slice(1);
228	24	var path = getThinkRequirePath(name[0] + 'Model');
229	24	if (path) {
230	3	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	26	'use strict';
255	26	if (isNumber(options)) {
256	3	options = {timeout: options};
257	23	}else if (options === true) {
258	9	options = {type: true}
259		}
260	26	options = options \|\| {};
261	26	var type = options.type === undefined ? C('cache_type') : options.type;
262	26	var cls = (type === true ? '' : ucfirst(type)) + 'Cache';
263	26	var instance = thinkRequire(cls)(options);
264		//获取缓存
265	26	if (value === undefined) {
266	12	return instance.get(name);
267		}
268		//移除缓存
269	14	if (value === null) {
270	2	return instance.rm(name);
271		}
272	12	return instance.set(name, value, options.timeout);
273		};
274		/**
275		* 语言
276		* @param {[type]} name [description]
277		*/
278	1	global.L = function(name){
279	2	'use strict';
280	2	return name;
281		};

/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
83		tpl_content_type: 'text/html', //模版输出类型
84		tpl_file_suffix: '.html', //模版文件名后缀
85		tpl_file_depr: '_', //controller和action之间的分隔符
86		tpl_engine_type: 'ejs', //模版引擎名称
87		tpl_engine_config: {},
88
89		log_record: false, //是否记录日志，开启后会重写console.log等系列方法
90		log_file_path: LOG_PATH, //日志文件存在路径
91		log_console_type: ['error'], //默认只接管console.error日志
92
93		cache_type: 'File', //数据缓存类型
94		cache_timeout: 6 * 3600, //数据缓存有效期，单位: 秒
95		cache_path: CACHE_PATH, //缓存路径设置 (File缓存方式有效)
96		cache_file_suffix: '.json', //File缓存方式下文件后缀名
97		cache_gc_hour: [4], //缓存清除的时间点，数据为小时
98
99		html_cache_on: false, //HTML静态缓存
100		html_cache_timeout: 3600, //缓存时间，单位为秒
101		html_cache_rules: {}, //缓存规则
102		html_cache_path: CACHE_PATH + '/html',
103		html_cache_file_callback: undefined, //生成缓存文件的回调函数
104		html_cache_file_suffix: '.html', //缓存文件后缀名
105
106		memcache_host: '127.0.0.1', //memcache host
107		memcache_port: 11211, //memecache端口
108		};

/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

48%

25

12

13

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	1	if (!RESOURCE_PATH \|\| !this.options.url_resource_on \|\| !this.http.pathname) {
15	0	return false;
16		}
17	1	var pathname = this.http.pathname;
18	1	if (pathname.indexOf('/') === 0) {
19	1	pathname = pathname.substr(1);
20		}
21	1	var reg = C('url_resource_reg');
22		//通过正则判断是否是静态资源请求
23	1	if (!reg.test(pathname)) {
24	1	return false;
25		}
26
27	0	var file = RESOURCE_PATH + '/' + pathname;
28	0	var res = this.http.res;
29	0	if (fs.existsSync(file)) {
30	0	var contentType = mime.lookup(file);
31	0	var fileStream = fs.createReadStream(file);
32	0	res.setHeader('Content-Type', contentType + '; charset=' + C('encoding'));
33	0	fileStream.pipe(res);
34	0	fileStream.on('end', function(){
35	0	res.end();
36		});
37		}else{
38	0	res.statusCode = 404;
39	0	res.end();
40		}
41		//返回一个pendding promise, 不让后续执行
42	0	return getDefer().promise;
43		}
44		};
45		});

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

10%

98

10

88

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

/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

90%

10

9

1

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	6	var file = data.file;
10		//将模版文件路径写入到http对象上，供writehtmlcache里使用
11	6	this.http.tpl_file = file;
12	6	var engine = C('tpl_engine_type');
13		//不使用模版引擎，直接返回文件内容
14	6	if (!engine) {
15	0	return getFileContent(file);
16		}
17	6	var engineClass = ucfirst(engine) + 'Template';
18	6	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

50%

158

80

78

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) {
159	0	return;
160		}
161	0	var message = isError(error) ? error.stack : error;
162	0	console.error(message);
163	0	if (!http.res) {
164	0	return;
165		}
166	0	if (APP_DEBUG) {
167	0	http.res.statusCode = 500;
168	0	http.res.end(message);
169		}else{
170	0	http.res.statusCode = 500;
171	0	http.setHeader('Content-Type', 'text/html; charset=' + C('encoding'));
172	0	var readStream = fs.createReadStream(C('error_tpl_path'));
173	0	readStream.pipe(http.res);
174	0	readStream.on('end', function(){
175	0	http.res.end();
176		});
177		}
178		}
179
180		/**
181		* run
182		* @return {[type]} [description]
183		*/
184	1	App.run = function(){
185	1	'use strict';
186	1	if (APP_MODE && App.mode[APP_MODE]) {
187	1	return App.mode[APP_MODE]();
188		}
189	0	return App.mode.http();
190		};
191		/**
192		* 不同模式下的run
193		* @type {Object}
194		*/
195	1	App.mode = {
196		//命令行模式
197		cli: function(){
198	1	'use strict';
199	1	var defaultHttp = thinkHttp.getDefaultHttp(process.argv[2]);
200	1	thinkHttp(defaultHttp.req, defaultHttp.res).run().then(App.listener);
201		},
202		//HTTP模式
203		http: function(){
204	0	'use strict';
205	0	var clusterNums = C('use_cluster');
206		//不使用cluster
207	0	if (!clusterNums) {
208	0	return App.createServer();
209		}
210		//使用cpu的个数
211	0	if (clusterNums === true) {
212	0	clusterNums = require('os').cpus().length;
213		}
214	0	if (cluster.isMaster) {
215	0	for (var i = 0; i < clusterNums; i++) {
216	0	cluster.fork();
217		}
218	0	cluster.on('exit', function(worker) {
219	0	console.log('worker ' + worker.process.pid + ' died');
220	0	process.nextTick(function(){
221	0	cluster.fork();
222		});
223		});
224		}else {
225	0	App.createServer();
226		}
227		}
228		};
229		/**
230		* 创建服务
231		* @return {[type]} [description]
232		*/
233	1	App.createServer = function(){
234	0	'use strict';
235		//自定义创建server
236	0	var createServerFn = C('create_server_fn');
237	0	if (createServerFn) {
238	0	if (isFunction(createServerFn)) {
239	0	return createServerFn(App);
240	0	}else if (isFunction(global[createServerFn])) {
241	0	return global[createServerFn](App);
242		}
243		}
244	0	var server = require('http').createServer(function (req, res) {
245	0	thinkHttp(req, res).run().then(App.listener);
246		});
247	0	thinkRequire('WebSocket')(server, App).run();
248	0	server.listen(C('port'));
249	0	if (APP_DEBUG) {
250	0	console.log('Server running at http://127.0.0.1:' + C('port') + '/');
251		}
252		}
253		/**
254		* 监听回调函数
255		* @param {[type]} http [description]
256		* @return {[type]} [description]
257		*/
258	1	App.listener = function(http){
259	1	'use strict';
260		//自动发送thinkjs和版本的header
261	1	http.setHeader('X-Powered-By', 'thinkjs-' + THINK_VERSION);
262		//禁止远程直接用带端口的访问,websocket下允许
263	1	if (C('use_proxy') && http.host !== http.hostname && !http.websocket) {
264	0	http.res.statusCode = 403;
265	0	http.res.end();
266	0	return getDefer().promise;
267		}
268	1	var domainInstance = domain.create();
269	1	var deferred = getDefer();
270	1	domainInstance.on('error', function(err){
271	0	App.sendError(http, err);
272	0	deferred.reject(err);
273		});
274	1	domainInstance.run(function(){
275	1	return tag('app_init', http).then(function(){
276	1	return Dispatcher(http).run();
277		}).then(function(){
278	1	return tag('app_begin', http);
279		}).then(function(){
280	1	return tag('action_init', http);
281		}).then(function(){
282	1	return App.exec(http);
283		}).then(function(){
284	1	return tag('app_end', http);
285		}).catch(function(err){
286	0	App.sendError(http, err);
287		}).then(function(){
288	1	deferred.resolve();
289		})
290		});
291	1	return deferred.promise;
292		};

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

100%

151

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

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

82%

366

303

63

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

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

84%

50

42

8

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	1	'use strict';
90	1	group = group \|\| C('default_group');
91	1	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	1	'use strict';
106	1	if (!controller \|\| !nameReg.test(controller)) {
107	1	return ucfirst(C('default_controller'));
108		}
109	0	return ucfirst(controller);
110		};
111		/**
112		* 获取action
113		* @param {[type]} action [description]
114		* @return {[type]} [description]
115		*/
116	1	Dispatcher.getAction = function(action){
117	1	'use strict';
118	1	if (!action \|\| !nameReg.test(action)) {
119	1	return C('default_action');
120		}
121	0	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	6	this.req = req;
17	6	this.res = res;
18		//http对象为EventEmitter的实例
19	6	this.http = new EventEmitter();
20		//记录当前请求的开始时间
21	6	this.http.startTime = Date.now();
22		},
23		/**
24		* 执行
25		* @param {Function} callback [description]
26		* @return Promise [description]
27		*/
28		run: function(){
29	6	this._request();
30	6	this._response();
31		//数组的indexOf要比字符串的indexOf略快
32	6	var methods = ['POST', 'PUT', 'PATCH'];
33	6	if (methods.indexOf(this.req.method) > -1) {
34	0	return this.getPostData();
35		}
36	6	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	6	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	6	extend(this.http, req);
172
173		//解析url中的参数
174	6	var urlInfo = url.parse('//' + req.headers.host + this.req.url, true, true);
175	6	this.http.pathname = urlInfo.pathname;
176		//query只记录?后面的参数
177	6	this.http.query = urlInfo.query;
178		//get包含路由解析追加的参数
179	6	this.http.get = extend({}, urlInfo.query);
180		//主机名，带端口
181	6	this.http.host = urlInfo.host;
182		//主机名，不带端口
183	6	this.http.hostname = urlInfo.hostname;
184		//将原生的request对象放在http上，方便后续在controller等地方使用
185	6	this.http.req = this.req;
186		},
187		/**
188		* HttpResponse增强
189		* @return {[type]} [description]
190		*/
191		_response: function(){
192	6	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	4	options = options \|\| {};
217	4	if (typeof options === 'number') {
218	0	options = {timeout: options};
219		}
220	4	var timeout = options.timeout;
221	4	if (timeout === undefined) {
222	4	timeout = C('cookie_timeout');
223		}
224	4	delete options.timeout;
225		//if value is null, remove cookie
226	4	if (value === null) {
227	0	timeout = -1000;
228		}
229	4	var defaultOptions = {
230		path: C('cookie_path'),
231		domain: C('cookie_domain'),
232		expires: new Date (Date.now() + timeout * 1000)
233		};
234	4	if (timeout === 0) {
235	4	delete defaultOptions.expires;
236		}
237	4	for(var key in options){
238	0	defaultOptions[key.toLowerCase()] = options[key];
239		}
240	4	defaultOptions.name = name;
241	4	defaultOptions.value = encodeURIComponent(value + '');
242	4	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	6	extend(this.http, res);
309		//将原生的response对象放在http上，方便后续controller等地方使用
310	6	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

67%

429

288

141

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

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

53%

168

90

78

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

/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	11	this.http = http;
10	11	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	29	if (name === undefined) {
20	1	return this.tVar;
21		}
22	28	if (isString(name) && arguments.length === 1) {
23	4	return this.tVar[name];
24		}
25	24	if (isObject(name)) {
26	1	this.tVar = extend(this.tVar, name);
27		}else{
28	23	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	18	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	18	mkdir(this.options.cache_path);
17	18	this.gcType += ':' + this.options.cache_path;
18
19	18	this.super_('init', this.options);
20		},
21		/**
22		* 存储的缓存文件
23		* @param {[type]} name [description]
24		* @return {[type]} [description]
25		*/
26		getStoredFile: function(name){
27	44	name = md5(this.key \|\| name);
28	44	var dir = name.split('').slice(0, this.options.cache_path_level).join('/');
29	44	mkdir(this.options.cache_path + '/' + dir);
30	44	var path = this.options.cache_path + '/' + dir + '/' + name + this.options.cache_file_suffix;
31	44	return path;
32		},
33		/**
34		* 获取缓存，返回promise
35		* @param {[type]} name [description]
36		* @return {[type]} [description]
37		*/
38		getData: function(name){
39	8	var filePath = this.getStoredFile(name);
40	8	if (!isFile(filePath)) {
41	1	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	7	return this.getData(name).then(function(data){
73	7	return (data \|\| {})[name];
74		})
75		},
76		setData: function(name, value, timeout){
77	35	if (isObject(name)) {
78	29	timeout = value;
79		}
80	35	if (timeout === undefined) {
81	32	timeout = this.options.timeout;
82		}
83	35	var filePath = this.getStoredFile(name);
84	35	var data = {
85		data: isObject(name) ? name : getObject(name, value),
86		expire: Date.now() + timeout * 1000,
87		timeout: timeout
88		};
89	35	var deferred = getDefer();
90	35	fs.writeFile(filePath, JSON.stringify(data), function(){
91		//修改缓存文件权限，避免不同账号下启动时可能会出现无权限的问题
92	35	chmod(filePath);
93	35	deferred.resolve();
94		})
95	35	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	6	return this.setData(name, value, timeout);
105		},
106		/**
107		* 删除缓存
108		* @param {[type]} name [description]
109		* @return {[type]} [description]
110		*/
111		rm: function(name){
112	1	var filePath = this.getStoredFile(name);
113	1	if (isFile(filePath)) {
114	1	var deferred = getDefer();
115	1	fs.unlink(filePath, function(){
116	1	deferred.resolve();
117		})
118	1	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	176	if (!this.linkId) {
28	1	this.linkId = mysqlSocket(this.config);
29		}
30	176	return this.linkId;
31		},
32		/**
33		* 查询一条sql
34		* @param string str
35		* @return promise
36		*/
37		query: function(str){
38	154	this.setSql(str);
39	154	var self = this;
40	154	if (!(str in this.queryWaiting)) {
41	154	this.queryWaiting[str] = [];
42	154	return this.connect().query(str).then(function(data){
43	154	process.nextTick(function(){
44	154	self.queryWaiting[str].forEach(function(deferred){
45	0	deferred.resolve(data);
46		});
47	154	delete self.queryWaiting[str];
48		})
49	154	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	22	this.setSql(str);
64	22	var self = this;
65	22	return this.connect().query(str).then(function(data){
66	22	self.lastInsertId = data.insertId;
67	22	return data.affectedRows \|\| 0;
68		});
69		},
70		/**
71		* 获取数据表字段信息
72		* @param string tableName 数据表名
73		* @return promise 返回一个promise
74		*/
75		getFields: function(tableName){
76	4	var sql = 'SHOW COLUMNS FROM ' + this.parseKey(tableName);
77	4	return this.query(sql).then(function(data){
78	4	var ret = {};
79	4	data.forEach(function(item){
80	52	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	4	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	342	key = (key \|\| '').trim();
128	342	if (!(/[,\'\"\*`.\s]/.test(key))) {
129	321	key = '`' + key + '`';
130		}
131	342	return key;
132		},
133		/**
134		* 获取最后插入的id
135		* @return {[type]} [description]
136		*/
137		getLastInsertId: function(){
138	6	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	4	options = options \|\| {};
17	4	options.cache_path = C('session_path') \|\| (os.tmpdir() + '/thinkjs');
18	4	this.super_('init', options);
19	4	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 (APP_DEBUG) {
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	6	'use strict';
10	6	var content = getFileContent(templateFile);
11	6	var conf = extend({
12		filename: templateFile,
13		cache: true
14		}, C('tpl_engine_config'));
15	6	return ejs.compile(content, conf)(tVar);
16		}
17		};

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

6%

44

3

41

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

/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	20	this.http = http;
12	20	for(var name in this.options){
13	16	if (C(name) !== undefined) {
14	14	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	31	'use strict';
21	31	if (APP_DEBUG \|\| APP_MODE === 'cli' \|\| gcTimer[instance.gcType]) {
22	31	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	31	options = options \|\| {};
52	31	if (options.cacheData) {
53	0	this.cacheData = options.cacheData;
54		}else{
55	31	this.cacheData = cacheData;
56		}
57	31	if (options.gcType) {
58	0	this.gcType = options.gcType;
59		}
60	31	if (!options.timeout) {
61	20	options.timeout = C('cache_timeout')
62		}
63	31	this.options = options;
64		//操作的key
65	31	this.key = '';
66		//是否更新expire值
67	31	this.updateExpire = false;
68	31	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	18	'use strict';
13	18	var data = {};
14	18	str.split(/; */).forEach(function(item) {
15	35	var pos = item.indexOf('=');
16	35	if (pos === -1) {
17	6	return;
18		}
19	29	var key = item.substr(0, pos).trim();
20	29	var val = item.substr(pos + 1).trim();
21	29	if ('"' === val[0]) {
22	2	val = val.slice(1, -1);
23		}
24		// only assign once
25	29	if (undefined === data[key]) {
26	29	try {
27	29	data[key] = decodeURIComponent(val);
28		} catch (e) {
29	2	data[key] = val;
30		}
31		}
32		});
33	18	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

80%

57

46

11

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	6	'use strict';
21	6	if (isString(value)) {
22	6	value = value.split(',');
23		}
24	6	if (!isArray(value)) {
25	0	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	1	'use strict';
85	1	if (!isArray(arr)) {
86	0	arr = [arr];
87		}
88	1	if(arr.indexOf(value) > -1){
89	0	return value;
90		}
91	1	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	0	'use strict';
101	0	if (isString(value)) {
102	0	value = value.split(split \|\| ',');
103		}
104	0	if (!isArray(value)) {
105	0	return [];
106		}
107	0	return value.filter(function(item){
108	0	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	24	'use strict';
120	24	var fn = Filter[type];
121	24	if (typeof fn === 'function') {
122	24	var args = [].slice.call(arguments, 2);
123	24	args.unshift(value);
124	24	return Filter[type].apply(Filter, args);
125		}
126	0	return false;
127		};

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

92%

54

50

4

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	3	'use strict';
9	3	var ratio = Math.log(64) / Math.log(256);
10	3	var numbytes = Math.ceil(length * ratio);
11	3	var str = crypto.randomBytes(numbytes).toString('base64').slice(0, length);
12	3	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	5	'use strict';
22	5	secret = crypto.createHmac('sha256', secret).update(val).digest('base64');
23	5	secret = secret.replace(/\=+$/, '');
24	5	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	3	'use strict';
34	3	var str = val.slice(0, val.lastIndexOf('.'));
35	3	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	16	'use strict';
51	16	if (http.session) {
52	11	return http.session;
53		}
54	5	var name = C('session_name');
55		//是否使用签名
56	5	var secret = C('session_sign');
57	5	var cookie = http.cookie[name];
58	5	if (cookie && secret) {
59	3	cookie = cookieUnsign(cookie, secret);
60	3	if (cookie) {
61	1	http.cookie[name] = cookie;
62		}
63		}
64	5	var session_cookie = cookie;
65	5	if (!cookie) {
66	3	cookie = uid(32);
67	3	session_cookie = cookie;
68	3	if (secret) {
69	2	cookie = cookieSign(cookie, secret);
70		}
71		//将生成的cookie放在http.cookie对象上，方便程序内读取
72	3	http.cookie[name] = cookie;
73	3	http.setCookie(name, cookie, C('session_options'));
74		}
75	5	var type = C('session_type');
76	5	if (!type) {
77	1	if (APP_DEBUG) {
78	0	type = 'File';
79	0	console.log("in debug mode, session can't use memory type for storage, convert to File type");
80	1	}else if (C('use_cluster')) {
81	0	type = 'File';
82	0	console.log("in cluster mode, session can't use memory type for storage, convert to File type");
83		}
84		}
85	5	name = type + 'Session';
86		//session类
87	5	var session = http.session = thinkRequire(name)({
88		cookie: session_cookie,
89		timeout: C('session_timeout')
90		});
91		//afterend时刷新缓存
92	5	http.on('afterEnd', function(){
93		//刷新session
94	29	return session.flush && session.flush();
95		})
96	5	return cookie;
97		};

/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

100%

12

0

Line	Hits	Source
1	1	var path = require('path');
2	1	var fs = require('fs');
3
4		//APP根目錄
5	1	global.APP_PATH = global.APP_PATH ? path.normalize(global.APP_PATH) : path.dirname(__dirname) + '/App';
6		//RUNTIME目录
7	1	global.RUNTIME_PATH = global.RUNTIME_PATH ? path.normalize(global.RUNTIME_PATH) : global.APP_PATH + '/Runtime';
8		//DEBUG模式
9	1	global.APP_DEBUG = global.APP_DEBUG \|\| false;
10		//静态资源文件的根目录
11	1	global.RESOURCE_PATH = global.RESOURCE_PATH \|\| '';
12		//THINKJS的根目录
13	1	global.THINK_PATH = __dirname;
14		//默认为http模式
15	1	global.APP_MODE = global.APP_MODE \|\| '';
16		//命令行模式
17	1	if (process.argv[2]) {
18	1	APP_MODE = 'cli';
19		}
20		//从package.json文件里获取版本号
21	1	global.THINK_VERSION = JSON.parse(fs.readFileSync(global.THINK_PATH + '/../package.json', 'utf8')).version;
22		//启动
23	1	require(global.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