1 |
|
2 |
|
3 |
|
4 | var assert = require('assert');
|
5 | var request = require('request');
|
6 | var util = require('util');
|
7 | var endpoints = require('./endpoints');
|
8 | var helpers = require('./helpers');
|
9 | var StreamingAPIConnection = require('./streaming-api-connection');
|
10 | var STATUS_CODES_TO_ABORT_ON = require('./settings').STATUS_CODES_TO_ABORT_ON;
|
11 |
|
12 |
|
13 | var required_for_app_auth = [
|
14 | 'consumer_key',
|
15 | 'consumer_secret'
|
16 | ];
|
17 |
|
18 |
|
19 | var required_for_user_auth = required_for_app_auth.concat([
|
20 | 'access_token',
|
21 | 'access_token_secret'
|
22 | ]);
|
23 |
|
24 |
|
25 |
|
26 |
|
27 | var Twitter = function (config) {
|
28 | var self = this
|
29 | var credentials = {
|
30 | consumer_key : config.consumer_key,
|
31 | consumer_secret : config.consumer_secret,
|
32 |
|
33 | access_token : config.access_token,
|
34 | access_token_secret : config.access_token_secret,
|
35 |
|
36 | app_only_auth : config.app_only_auth,
|
37 | }
|
38 |
|
39 | this._validateConfigOrThrow(config);
|
40 | this.config = config;
|
41 | }
|
42 |
|
43 | Twitter.prototype.get = function (path, params, callback) {
|
44 | return this.request('GET', path, params, callback)
|
45 | }
|
46 |
|
47 | Twitter.prototype.post = function (path, params, callback) {
|
48 | return this.request('POST', path, params, callback)
|
49 | }
|
50 |
|
51 | Twitter.prototype.request = function (method, path, params, callback) {
|
52 | var self = this
|
53 | assert(method == 'GET' || method == 'POST')
|
54 |
|
55 | if (typeof params === 'function') {
|
56 | callback = params
|
57 | params = {}
|
58 | }
|
59 |
|
60 | self._buildReqOpts(method, path, params, false, function (err, reqOpts) {
|
61 | if (err) {
|
62 | callback(err, null, null)
|
63 | return
|
64 | }
|
65 |
|
66 | var twitOptions = (params && params.twit_options) || {}
|
67 |
|
68 | process.nextTick(function () {
|
69 |
|
70 | self._doRestApiRequest(reqOpts, twitOptions, method, callback)
|
71 | })
|
72 | })
|
73 |
|
74 | return self
|
75 | }
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 |
|
89 | Twitter.prototype._buildReqOpts = function (method, path, params, isStreaming, callback) {
|
90 | var self = this
|
91 | if (!params) {
|
92 | params = {}
|
93 | }
|
94 |
|
95 | var paramsClone = JSON.parse(JSON.stringify(params))
|
96 |
|
97 | var finalParams = this.normalizeParams(paramsClone)
|
98 | delete finalParams.twit_options
|
99 |
|
100 |
|
101 | var reqOpts = {
|
102 | headers: {
|
103 |
|
104 | },
|
105 |
|
106 | }
|
107 |
|
108 |
|
109 | try {
|
110 |
|
111 | path = helpers.moveParamsIntoPath(finalParams, path)
|
112 | } catch (e) {
|
113 | callback(e, null, null)
|
114 | return
|
115 | }
|
116 |
|
117 | if (isStreaming) {
|
118 | var stream_endpoint_map = {
|
119 | user: endpoints.USER_STREAM,
|
120 | site: endpoints.SITE_STREAM
|
121 | }
|
122 | var endpoint = stream_endpoint_map[path] || endpoints.PUB_STREAM
|
123 | reqOpts.url = endpoint + path + '.json'
|
124 | } else {
|
125 |
|
126 | if (path === 'media/upload') {
|
127 | reqOpts.url = endpoints.MEDIA_UPLOAD + 'media/upload.json'
|
128 | reqOpts.headers['Content-type'] = 'multipart/form-data'
|
129 | reqOpts.formData = finalParams
|
130 |
|
131 |
|
132 | finalParams = {}
|
133 | } else {
|
134 | reqOpts.url = endpoints.REST_ROOT + path + '.json'
|
135 | reqOpts.headers['Content-type'] = 'application/json'
|
136 | }
|
137 | }
|
138 |
|
139 | if (Object.keys(finalParams).length) {
|
140 |
|
141 |
|
142 | var qs = helpers.makeQueryString(finalParams)
|
143 | reqOpts.url += '?' + qs
|
144 | }
|
145 |
|
146 | if (!self.config.app_only_auth) {
|
147 |
|
148 |
|
149 | reqOpts.oauth = {
|
150 | consumer_key: self.config.consumer_key,
|
151 | consumer_secret: self.config.consumer_secret,
|
152 | token: self.config.access_token,
|
153 | token_secret: self.config.access_token_secret,
|
154 | }
|
155 |
|
156 | callback(null, reqOpts);
|
157 | return;
|
158 | } else {
|
159 |
|
160 |
|
161 | self._getBearerToken(function (err, bearerToken) {
|
162 | if (err) {
|
163 | callback(err, null)
|
164 | return
|
165 | }
|
166 |
|
167 | reqOpts.headers['Authorization'] = 'Bearer ' + bearerToken;
|
168 | callback(null, reqOpts)
|
169 | return
|
170 | })
|
171 | }
|
172 | }
|
173 |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 | Twitter.prototype._doRestApiRequest = function (reqOpts, twitOptions, method, callback) {
|
183 | var request_method = request[method.toLowerCase()];
|
184 | var req = request_method(reqOpts);
|
185 |
|
186 | var body = '';
|
187 | var response = null;
|
188 |
|
189 | var onRequestComplete = function () {
|
190 | try {
|
191 | body = JSON.parse(body)
|
192 | } catch (jsonDecodeError) {
|
193 |
|
194 |
|
195 | var err = helpers.makeTwitError('JSON decode error: Twitter HTTP response body was not valid JSON')
|
196 | err.statusCode = response ? response.statusCode: null;
|
197 | err.allErrors.concat({error: jsonDecodeError.toString()})
|
198 | callback(err, body, response);
|
199 | return
|
200 | }
|
201 |
|
202 | if (body.error || body.errors) {
|
203 |
|
204 |
|
205 | var err = helpers.makeTwitError('Twitter API Error')
|
206 | err.statusCode = response ? response.statusCode: null;
|
207 | helpers.attachBodyInfoToError(err, body);
|
208 | callback(err, body, response);
|
209 | return
|
210 | }
|
211 |
|
212 |
|
213 | callback(err, body, response)
|
214 | }
|
215 |
|
216 | req.on('response', function (res) {
|
217 | response = res
|
218 |
|
219 |
|
220 | req.on('data', function (chunk) {
|
221 | body += chunk.toString('utf8')
|
222 | })
|
223 |
|
224 | req.on('end', function () {
|
225 | onRequestComplete()
|
226 | })
|
227 | })
|
228 |
|
229 | req.on('error', function (err) {
|
230 |
|
231 | if (twitOptions.retry &&
|
232 | STATUS_CODES_TO_ABORT_ON.indexOf(err.statusCode) !== -1
|
233 | ) {
|
234 |
|
235 | self.request(method, path, params, callback);
|
236 | return;
|
237 | } else {
|
238 |
|
239 | err.statusCode = null
|
240 | err.code = null
|
241 | err.allErrors = [];
|
242 | helpers.attachBodyInfoToError(err, body)
|
243 | callback(err, body, response);
|
244 | return;
|
245 | }
|
246 | })
|
247 | }
|
248 |
|
249 |
|
250 |
|
251 |
|
252 |
|
253 |
|
254 |
|
255 |
|
256 |
|
257 | Twitter.prototype.stream = function (path, params) {
|
258 | var self = this;
|
259 | var twitOptions = (params && params.twit_options) || {};
|
260 |
|
261 | var streamingConnection = new StreamingAPIConnection()
|
262 | self._buildReqOpts('POST', path, params, true, function (err, reqOpts) {
|
263 | if (err) {
|
264 |
|
265 |
|
266 | streamingConnection.emit('error', err)
|
267 | return
|
268 | }
|
269 |
|
270 | streamingConnection.reqOpts = reqOpts
|
271 | streamingConnection.twitOptions = twitOptions
|
272 |
|
273 | process.nextTick(function () {
|
274 | streamingConnection.start()
|
275 | })
|
276 | })
|
277 |
|
278 | return streamingConnection
|
279 | }
|
280 |
|
281 |
|
282 |
|
283 |
|
284 |
|
285 |
|
286 |
|
287 | Twitter.prototype._getBearerToken = function (callback) {
|
288 | var self = this;
|
289 | if (self._bearerToken) {
|
290 | return callback(null, self._bearerToken)
|
291 | }
|
292 |
|
293 | helpers.getBearerToken(self.config.consumer_key, self.config.consumer_secret,
|
294 | function (err, bearerToken) {
|
295 | if (err) {
|
296 |
|
297 | callback(err, null);
|
298 | return;
|
299 | }
|
300 | self._bearerToken = bearerToken;
|
301 | callback(null, self._bearerToken);
|
302 | return;
|
303 | })
|
304 | }
|
305 |
|
306 | Twitter.prototype.normalizeParams = function (params) {
|
307 | var normalized = params
|
308 | if (params && typeof params === 'object') {
|
309 | Object.keys(params).forEach(function (key) {
|
310 | var value = params[key]
|
311 |
|
312 | if (Array.isArray(value))
|
313 | normalized[key] = value.join(',')
|
314 | })
|
315 | } else if (!params) {
|
316 | normalized = {}
|
317 | }
|
318 | return normalized
|
319 | }
|
320 |
|
321 | Twitter.prototype.setAuth = function (auth) {
|
322 | var self = this
|
323 | var configKeys = [
|
324 | 'consumer_key',
|
325 | 'consumer_secret',
|
326 | 'access_token',
|
327 | 'access_token_secret'
|
328 | ];
|
329 |
|
330 |
|
331 | configKeys.forEach(function (k) {
|
332 | if (auth[k]) {
|
333 | self.config[k] = auth[k]
|
334 | }
|
335 | })
|
336 | this._validateConfigOrThrow(self.config);
|
337 | }
|
338 |
|
339 | Twitter.prototype.getAuth = function () {
|
340 | return this.config
|
341 | }
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 | Twitter.prototype._validateConfigOrThrow = function (config) {
|
348 |
|
349 | if (typeof config !== 'object') {
|
350 | throw new TypeError('config must be object, got ' + typeof config)
|
351 | }
|
352 |
|
353 | if (config.app_only_auth) {
|
354 | var auth_type = 'app-only auth'
|
355 | var required_keys = required_for_app_auth
|
356 | } else {
|
357 | var auth_type = 'user auth'
|
358 | var required_keys = required_for_user_auth
|
359 | }
|
360 |
|
361 | required_keys.forEach(function (req_key) {
|
362 | if (!config[req_key]) {
|
363 | var err_msg = util.format('Twit config must include `%s` when using %s.', req_key, auth_type)
|
364 | throw new Error(err_msg)
|
365 | }
|
366 | })
|
367 | }
|
368 |
|
369 | module.exports = Twitter
|