1 var weixin = {
 2     _busyTimer: null,
 3     _busyDelay: 1500,
 4     toast: function (message, icon) {
 5         wx.showToast({
 6             title: message,
 7             icon: icon == null || icon == \'\' ? \'none\' : icon
 8         });
 9     },
10     toastSuccess: function (message) {
11         this.toast(message, \'success\');
12     },
13     busy: function (option, delay) {
14         clearTimeout(this._busyTimer);
15         if (option === false) {
16             wx.hideLoading();
17             return;
18         }
19         if (delay === 0) {
20             wx.showLoading({
21                 title: option,
22                 mask: true
23             });
24         }
25         else {
26             this._busyTimer = setTimeout(function () {
27                 wx.showLoading({
28                     title: option,
29                     mask: true
30                 });
31             }, delay == null ? this._busyDelay : delay);
32         }
33     },
34     alert: function (title, content, callback) {
35         content = content == undefined ? \'\' : content;
36         wx.showModal({
37             title: title,
38             content: content,
39             showCancel: false,
40             confirmText: "确定",
41             success: res => {
42                 callback && callback();
43             }
44         });
45     },
46     confirm: function (title, content, buttons) {
47         var buttonList = [];
48         for (var p in buttons) {
49             if (buttons.hasOwnProperty(p)) {
50                 buttonList.push({
51                     text: p,
52                     handler: buttons[p]
53                 })
54             }
55         }
56         content = content == undefined ? \'\' : content;
57         wx.showModal({
58             title: title,
59             content: content,
60             showCancel: true,
61             cancelText: buttonList[0].text,
62             confirmText: buttonList[1].text,
63             success: res => {
64                 if (res.confirm) {
65                     buttonList[1].handler && buttonList[1].handler();
66                 } else if (res.cancel) {
67                     buttonList[0].handler && buttonList[0].handler();
68                 }
69             }
70         });
71     }
72 };
73 
74 module.exports = weixin;

  1 var ArrayExtensions = {};
  2 
  3 Array.prototype._each = function (func) {
  4     for (var i = 0; i < this.length; i++) {
  5         var item = this[i];
  6         var result = func(i, item);
  7         if (result === false) {
  8             return;
  9         }
 10     }
 11 };
 12 
 13 Array.prototype._sum = function (propertyOrFunc) {
 14     var total = 0;
 15     var isFunc = typeof (propertyOrFunc) == "function";
 16     this._each(function (i, item) {
 17         if (isFunc) {
 18             total += propertyOrFunc(item);
 19         } else {
 20             var value = item[propertyOrFunc];
 21             if (value != undefined) {
 22                 value = value * 1;
 23                 if (!isNaN(value)) {
 24                     total += value;
 25                 }
 26             }
 27         }
 28     });
 29     return total;
 30 };
 31 
 32 Array.prototype._where = function (predicateFunction) {
 33     var results = new Array();
 34     this._each(function (i, item) {
 35         if (predicateFunction(item)) {
 36             results.push(item);
 37         }
 38     });
 39     return results;
 40 };
 41 
 42 Array.prototype._orderBy = function (property, isFirstGreaterThanSecondFunction) {
 43     var items = this;
 44     for (var i = 0; i < items.length - 1; i++) {
 45         for (var j = 0; j < items.length - 1 - i; j++) {
 46             if (isFirstGreaterThanSecond(items[j], items[j + 1])) {
 47                 var temp = items[j + 1];
 48                 items[j + 1] = items[j];
 49                 items[j] = temp;
 50             }
 51         }
 52     }
 53     function isFirstGreaterThanSecond(first, second) {
 54         if (isFirstGreaterThanSecondFunction != undefined) {
 55             return isFirstGreaterThanSecondFunction(first, second);
 56         }
 57         else if (property == undefined || property == null) {
 58             return first > second;
 59         }
 60         else {
 61             return first[property] > second[property];
 62         }
 63     }
 64 
 65     return items;
 66 };
 67 
 68 Array.prototype._orderByDescending = function (property, isFirstGreaterThanSecondFunction) {
 69     var items = this;
 70     for (var i = 0; i < items.length - 1; i++) {
 71         for (var j = 0; j < items.length - 1 - i; j++) {
 72             if (!isFirstGreaterThanSecond(items[j], items[j + 1])) {
 73                 var temp = items[j + 1];
 74                 items[j + 1] = items[j];
 75                 items[j] = temp;
 76             }
 77         }
 78     }
 79     function isFirstGreaterThanSecond(first, second) {
 80         if (isFirstGreaterThanSecondFunction != undefined) {
 81             return isFirstGreaterThanSecondFunction(first, second);
 82         }
 83         else if (property == undefined || property == null) {
 84             return first > second;
 85         }
 86         else {
 87             return first[property] > second[property];
 88         }
 89     }
 90 
 91     return items;
 92 };
 93 
 94 Array.prototype._groupBy = function (property) {
 95     var results = [];
 96     var items = this;
 97 
 98     var keys = {}, index = 0;
 99     for (var i = 0; i < items.length; i++) {
100         var selector;
101         if (typeof property === "string") {
102             selector = items[i][property];
103         } else {
104             selector = property(items[i]);
105         }
106         if (keys[selector] === undefined) {
107             keys[selector] = index++;
108             results.push({ key: selector, value: [items[i]] });
109         } else {
110             results[keys[selector]].value.push(items[i]);
111         }
112     }
113     return results;
114 };
115 
116 Array.prototype._skip = function (count) {
117     var items = new Array();
118     for (var i = count; i < this.length; i++) {
119         items.push(this[i]);
120     }
121     return items;
122 };
123 
124 Array.prototype._take = function (count) {
125     var items = new Array();
126     for (var i = 0; i < this.length && i < count; i++) {
127         items.push(this[i]);
128     }
129     return items;
130 };
131 
132 Array.prototype._firstOrDefault = function (predicateFunction) {
133     if (this.length == 0) {
134         return null;
135     }
136     if (predicateFunction == undefined) {
137         return this[0];
138     }
139     var foundItem = null;
140     this._each(function (i, item) {
141         if (predicateFunction(item)) {
142             foundItem = item;
143             return false;
144         }
145         return true;
146     });
147     return foundItem;
148 };
149 
150 Array.prototype._any = function (predicateFunction) {
151     if (predicateFunction == undefined) {
152         return this.length > 0;
153     }
154     var hasAny = false;
155     this._each(function (i, item) {
156         if (predicateFunction(item)) {
157             hasAny = true;
158             return false;
159         }
160         return true;
161     });
162     return hasAny;
163 };
164 
165 Array.prototype._select = function (newObjectFunction) {
166     if (newObjectFunction == undefined) {
167         throw "parameter newObjectFunction cannot be null or undefined";
168     }
169     var items = [];
170     this._each(function (i, item) {
171         items.push(newObjectFunction(item));
172     });
173     return items;
174 };
175 
176 Array.prototype._insert = function (index, item) {
177     this.splice(index, 0, item);
178 };
179 
180 Array.prototype._insertMany = function (index, items) {
181     if (items == null) {
182         return;
183     }
184     for (var i = 0; i < items.length; i++) {
185         this._insert(index + i, items[i]);
186     }
187 };
188 
189 Array.prototype._add = function (item) {
190     this.push(item);
191 };
192 
193 Array.prototype._addMany = function (items) {
194     if (items == null) {
195         return;
196     }
197     for (var i = 0; i < items.length; i++) {
198         this.push(items[i]);
199     }
200 };
201 
202 Array.prototype._clear = function () {
203     this.splice(0, this.length);
204 };
205 
206 Array.prototype._count = function (predicateFunction) {
207     var count = 0;
208     this._each(function (i, item) {
209         if (predicateFunction(item)) {
210             count++;
211         }
212     });
213     return count;
214 };
215 
216 
217 /************************************** */
218 module.exports = ArrayExtensions;

  1 var weixin = require(\'../weixin.js\');
  2 
  3 function WebClient() {
  4     this.busyText = null;
  5     this.busyDelay = 1500;
  6     this.url = \'\';
  7     this.data = null;
  8     this.method = \'GET\';
  9     this.contentType = \'application/x-www-form-urlencoded\';
 10     this.dataType = \'json\';
 11     this.onlyCallbackOnSuccess = false;
 12     this._request = null;
 13     this._callback = null;
 14     this._header = {};
 15 };
 16 
 17 WebClient.prototype = {
 18     setHeader: function(key, value){
 19         this._header[key] = value;
 20     },
 21     removeHeader: function(key){
 22         delete this.header[key];
 23     },
 24     get: function (url, callback, busyText, onlyCallbackOnSuccess){
 25         this.method = \'GET\';
 26         this.url = url;
 27         this.data = null;
 28         this._callback = callback; 
 29         this.busyText = busyText;
 30         this.onlyCallbackOnSuccess = onlyCallbackOnSuccess == null ? false : onlyCallbackOnSuccess;
 31         this.execute();
 32     },
 33     post: function (url, data, callback, busyText, onlyCallbackOnSuccess) {
 34         this.method = \'POST\';
 35         this.url = url;
 36         this.data = data;
 37         this._callback = callback;
 38         this.busyText = busyText;
 39         this.onlyCallbackOnSuccess = onlyCallbackOnSuccess == null ? false : onlyCallbackOnSuccess;
 40         this.execute();
 41     },
 42     execute: function () {
 43         var me = this;
 44         if (this.busyText != null && this.busyText !== \'\') {
 45             weixin.busy(me.busyText, me.busyDelay);
 46         }
 47         this._request = wx.request({
 48             url: me.url,
 49             data: me.data,
 50             method: me.method,
 51             header: me._getRequestHeader(),
 52             success: (response) => {
 53                 if (me.busyText != null) {
 54                     weixin.busy(false);
 55                 }
 56                 me._onResponse(response);
 57             },
 58             fail: res => {
 59                 if (me.busyText != null) {
 60                     weixin.busy(false);
 61                 }
 62                 me._handleError({ statusCode: 500 });
 63             }
 64         });
 65     },
 66     _getRequestHeader: function(){
 67         var header = {};
 68         if(this.contentType != null && this.contentType !== \'\'){
 69             header[\'content-type\'] = this.contentType;
 70         }
 71         for(var p in this._header){
 72             if(this._header.hasOwnProperty(p)){
 73                 header[p] = this._header[p];
 74             }
 75         }
 76         return header;
 77     },
 78     _onResponse: function (response) {
 79         if (response.statusCode === 200) {
 80             if (this.onlyCallbackOnSuccess === false) {
 81                 this._callback && this._callback(response.data);
 82             } else {
 83                 if (response.data.success === true) {
 84                     this._callback && this._callback(response.data);
 85                 } else {
 86                     weixin.alert("提示", response.data.message);
 87                 }
 88             }
 89         }
 90         else {
 91             this._handleError(response);
 92         }
 93     },
 94     _handleError: function (response) {
 95         if (response.statusCode === 0 && err.statusText === "abort") {
 96             return;
 97         }
 98         if (this.onlyCallbackOnSuccess) {
 99             weixin.alert("网络错误", "错误码：" + response.statusCode);
100         } else {
101             this._callback && this._callback({
102                 success: false,
103                 message: "网络错误：" + response.statusCode,
104                 code: response.statusCode
105             });
106         }
107     }
108 };
109 
110 module.exports = WebClient;

 1 var weixin = require(\'../weixin.js\');
 2 
 3 
 4 
 5 function AuthorizeManager() {
 6     this.pageUrl = \'/pages/_authorize/_authorize\';
 7 };
 8 
 9 AuthorizeManager.scopes = {
10     userInfo: \'scope.userInfo\'
11 };
12 
13 AuthorizeManager.prototype = {
14     authorize: function (scope, callback) {
15         var me = this;
16         me._isAuthorized(scope, function (authorized) {
17             if (authorized) {
18                 callback();
19             }
20             else {
21                 me._showAuthorize(scope, callback);
22             }
23         });
24     },
25     getUserInfo: function (callback) {
26         var me = this;
27         var scope = AuthorizeManager.scopes.userInfo;
28         function handleAuthorized() {
29             wx.getUserInfo({
30                 success: function (res) {
31                     callback && callback(res);
32                 },
33                 fail: function (res) {
34                     var url = getApp().getCurrentPage().getFullUrl();
35                     wx.redirectTo({
36                         url: me.pageUrl + "?returnUrl=" + encodeURIComponent(url)
37                     });
38                 }
39             })
40         };
41         me.authorize(scope, handleAuthorized);
42     },
43     _isAuthorized: function (scope, callback) {
44         wx.getSetting({
45             success: function (res) {
46                 callback(res.authSetting[scope] === true);
47             }
48         });
49     },
50     _showAuthorize: function (scope, callback) {
51         var me = this;
52         wx.authorize({
53             scope: scope,
54             success: function () {
55                 callback();
56             },
57             fail: function (res) {
58                 if (scope === AuthorizeManager.scopes.userInfo) {
59                     callback();
60                 }
61                 else {
62                     me._openAuthorizeSetting(scope, callback);
63                 }
64             }
65         })
66     },
67     _openAuthorizeSetting: function (scope, calback) {
68         var me = this;
69         weixin.alert(\'提示\', \'您需要授权才能继续操作\', function () {
70             wx.openSetting({
71                 success: function (res) {
72                     if (!res.authSetting[scope]) {
73                         me._openAuthorizeSetting(scope, callback);
74                     } else {
75                         callback && callback();
76                     }
77                 }
78             })
79         });
80     }
81 };
82 
83 module.exports = AuthorizeManager;