app.post('/file-upload', function(req, res, next) {
// console.log(req.files.thumbnail1.path);
// console.log(req.files.thumbnail2.path);
console.log("SESSION STARTS", global.fbtoken , " SESSION ENDS");
var form = new FormData(); //Create multipart form
form.append('file', fs.createReadStream(req.files.thumbnail1.path)); //Put file
form.append('message', "Learning how to analyze my Facebook feed through code at the Startup Institute High School RampUp. \n \n Sponsored by Startup Institute Alumni and the Kendall Square Chipoltle."); //Put message
var options = {
method: 'post',
host: 'graph.facebook.com',
path: '/me/photos?access_token='+global.fbtoken,
headers: form.getHeaders(),
}
var request = https.request(options, function (res){
console.log(res);
});
form.pipe(request);
request.on('error', function (error) {
console.log(error);
});
res.render("done");
});
doUpload: function (hostname, port, uriPath, headers, filename, callback) {
var form, options, req;
form = new FormData();
form.append('file', fs.createReadStream(filename));
options = {
hostname: hostname,
port: port,
path: uriPath,
method: 'put',
headers: form.getHeaders()
};
options.headers['User-Agent'] = userAgent;
if (headers) {
for (var name in headers) {
options.headers[name] = headers[name];
}
}
req = http.request(options, function (res) {
var data = '';
res.setEncoding('utf8');
res.on('data', function (chunk) {
data += chunk;
});
res.on('end', function () {
if (res.statusCode !== 200) {
return callback({status: res.statusCode, data: data});
}
callback(null, data);
});
});
form.pipe(req);
req.on('error', function (err) {
callback(err);
});
},
NeoCities.prototype.post = function(method, args, callback) {
var form = new FormData()
var i
for(i=0;i<args.length;i++)
form.append(args[i].name, args[i].value)
var request = this.client.request({
method: 'post',
host: this.url.hostname,
port: this.url.port,
path: '/api/'+method,
headers: form.getHeaders(),
auth: this.user+':'+this.pass
}, function(res) {
var body = ''
res.on('data', function (chunk) {
body += chunk
})
res.on('end', function() {
var resObj = JSON.parse(body)
callback(resObj)
})
})
form.pipe(request)
}
form.getLength(function (error, length) {
formLength = length;
headers = form.getHeaders({'content-length': formLength});
var r = request.post({
uri : uri,
method : 'POST',
strictSSL : constants.VERIFY,
headers : headers
}, function (error, response) {
var code = constants.HTTP_INTERNAL_SERVER_ERROR,
result = utils.makeEmptyResult('resource',
code,
'The resource couldn\'t be created');
return utils.requestResponse('create', constants.HTTP_CREATED,
[constants.HTTP_PAYMENT_REQUIRED,
constants.HTTP_UNAUTHORIZED,
constants.HTTP_BAD_REQUEST,
constants.HTTP_NOT_FOUND],
error, undefined, response,
result, options.cb);
});
form.pipe(r);
});
form.getLength(function(err, len)
{
//console.log("got len ", len);
var concat = require('concat-stream');
form.pipe(concat(function(buf)
{
// buf is a Node Buffer instance which contains the entire data in stream
// if your stream sends textual data, use buf.toString() to get entire stream as string
var streamContent = buf.toString();
require('fs').writeFile("./base64", buf);
(function post(url)
{
//send the modified statement up to the configured LRS
var postReq = require('request')(
{
uri: url,
method: "POST",
followRedirect: true,
body: buf,
headers: combine(
{
"X-Experience-API-Version": req.headers[
"x-experience-api-version"],
"Content-Length": len
}, form.getHeaders())
}).auth(req.lrsConfig.username, req.lrsConfig.password, true);
postReq.headers["content-type"] = postReq.headers["content-type"].replace("form-data", "mixed");
//console.log(postReq.headers);
//console.log(streamContent);
postReq.on('response', function(r) {});
postReq.on("response", function(r)
{
var data = "";
postReq.on('data', function(chunk)
{
data += chunk;
});
postReq.on('end', function()
{
if (r.statusCode == 301)
{
post(r.headers.location);
}
else
{
res.status(r.statusCode).send(data);
//console.log(data);
}
})
});
postReq.on('error', function(e)
{
res.status(500).send(e);
});
})(req.lrsConfig.endpoint + "/statements");
}));
})
app.post('/uploadtoolzip', upload.single('tooldriver'), function(req, res) {
if (req.session.userAuth == true) {
var csrfBodyToken = req.body.csrf;
var cookieArray = req.headers.cookie.split(";");
var csrfCookie = "";
for (var i = 0; i < cookieArray.length; i++) {
var tempArr = cookieArray[i].split("csrfToken=");
if (tempArr.length == 2) {
csrfCookie = tempArr[1];
}
}
if (csrfBodyToken == csrfCookie) {
var form = new FormData();
console.log(req.file);
if (req.file != undefined) {
var toolID = req.file.originalname;
form.append('filename', fs.createReadStream(req.file.path));
var request = http.request({
method: 'POST',
host: config.serverIP,
port: config.serverPort,
path: "/admin/uploadtoolserver/",
headers: form.getHeaders()
});
// console.log(form.filename);
form.pipe(request);
request.on('response', function(resEngine) {
console.log(resEngine.statusCode);
if (resEngine.statusCode == "200") {
fs.unlink(req.file.path);
res.render('uploadstatus.jade', {
csrf: req.session.csrfCookie
});
} else {
console.log("Error uploading");
fs.unlink(req.file.path);
res.status(404).send({
"status": "Fail"
});
}
});
request.on('error', function(e) {
console.log('problem with request: ' + e.message);
fs.unlink(req.file.path);
res.send("Some error occured");
});
} else {
res.send("Some data missing");
}
} else {
res.send("Invalid CSRF token");
}
} else {
res.redirect('/');
}
});
MD5Promise.then((fileMd5)=>{
//TODO:判断文件的mime
var filetype;
var mediatype = "pic";
var timeFormated = dateFormat(now) + " GMT+0800 (CST)";
var form = new FormData();
form.append("id","WU_FILE_0");
form.append("name",filename);
form.append("type","image/png");
form.append("lastModifiedDate", timeFormated);
form.append("size",filesize);
form.append("mediatype",mediatype);
form.append("pass_ticket",pass_ticket);
form.append("webwx_data_ticket",webwx_data_ticket);
form.append("uploadmediarequest",JSON.stringify({
"UploadType": 2,
"BaseRequest": baseParams,
"ClientMediaId": "e" + new Date().getTime(),
"TotalLen": filesize,
"StartPos": 0,
"DataLen": filesize,
"MediaType": 4,
"FromUserName": myAccount.UserName,
"ToUserName": targetGroup,
"FileMd5": fileMd5
}));
form.append('filename', fs.createReadStream(filePath));
var options = {
rejectUnauthorized:true,
agent:false,
hostname: "file." + redirectUriObject.hostname,
path: "/cgi-bin/mmwebwx-bin/webwxuploadmedia?f=json",
method: 'POST',
headers: {
'Content-Type': 'multipart/form-data; boundary=' + form.getBoundary(),
'Cookie': cookies,
},
};
var resMessage = "";
var req = https.request(options, (res) =>{
res.setEncoding('utf8');
res.on('data', (chunk) => {
resMessage += chunk;
});
res.on('end', () => {
console.log(`end: ${resMessage}`);
var responseObject = JSON.parse(resMessage);
resolve(responseObject.MediaId);
});
});
form.pipe(req);
});
rem.connect('facebook.com').prompt(function (err, user) {
var form = new FormData();
form.append('message', 'Testing from Rem');
form.append('source', fs.createReadStream(path.join(__dirname, 'my_image.png')))
user.debug = true;
form.pipe(user('me/photos').post(form.getHeaders()['content-type'], function (err, json) {
console.log('After upload:', err, json);
}));
});
function doPost () {
var form = new FormData(),
reqOptions = {
method: 'POST',
uri: 'http://localhost:8000/enwiki/page/' + name + '?rev/',
};
form.append('_timestamp', timestamp);
form.append('_rev', revision.id);
form.append('wikitext', revision.text);
reqOptions.headers = form.getHeaders();
form.pipe(request(reqOptions, handlePostResponse));
}
app.listen(3000, function() {
var form = new FormData();
form.append('body', new Buffer('<test>Test Body</test>'));
var dir = __dirname + '/images/';
// var files = [ 'logoEbay_x45.gif', 'ebay_closeup.jpeg', 'ql.io.jpg' ];
// var files = [ 'logoEbay_x45.gif', 'ebay_closeup.jpeg' ];
var files = [ 'logoEbay_x45.gif' ];
var idx = 0;
_.each(files, function(file) {
form.append(file, fs.createReadStream(dir + file));
});
var options = {
host: 'localhost',
port: 3000,
path: '/multipart/test/upload?desc=something',
method: 'POST',
headers: _.extend({
host: 'localhost',
connection: 'close'
}, form.getHeaders())
};
var request = http.request(options);
form.pipe(request);
request.on('response', function(response) {
response.setEncoding('utf8');
var data = "";
response.on('data', function(chunk) {
data += chunk;
});
response.on('end', function() {
var r = JSON.parse(data);
test.equals(r.parts[0], 'body');
test.equals(r.parts[1], 'logoEbay_x45.gif');
test.equals(response.statusCode, 200);
app.close();
upload_server.close();
test.done();
});
});
request.on('error', function(error) {
if (error) {
console.log('error: ' + error);
}
});
});
return new Promise(function (resolve, reject) {
var form = new FormData()
files.forEach(function (file) {
form.append(file.name, file.file, {
filename: '_',
contentType: 'application/json',
})
})
var request = http.request({
hostname: url.hostname,
port: url.port,
path: url.path,
method: 'POST',
headers: form.getHeaders(),
})
request.on('response', function (response) {
var responseBody = ''
response.on('data', function (chunk) {
responseBody += chunk
})
response.on('end', function () {
if (response.statusCode === 200) {
resolve({
contentType: response.headers['content-type'],
body: responseBody,
})
} else {
reject(new Error(
util.format('[IPFS %s %s]: status = %s, body = `%s`',
'POST',
url.path,
response.statusCode,
responseBody)))
}
})
})
request.on('error', reject)
if (form) {
form.pipe(request)
}
request.end()
})
form.getLength(function(err,len){
headers ["Content-length"] =len ;
headers ['Authorization'] = "Bearer "+options.access_token
var data=""
var re = https.request({
method: 'POST',
host: self.API_HOST,
path: options.path.replace(self.API_BASE_URL,""),
headers: headers
});
form.pipe(re);
re.on('response', function(res){
var chunks = [], size = 0;
res.on('data', function (chunk) {
size += chunk.length;
chunks.push(chunk);
});
res.on('end', function () {
var data = null;
switch (chunks.length) {
case 0:
data = new Buffer(0);
break;
case 1:
data = chunks[0];
break;
default:
data = new Buffer(size);
for (var i = 0, pos = 0, l = chunks.length; i < l; i++) {
chunks[i].copy(data, pos);
pos += chunks[i].length;
}
break;
}
var e=null;
var body=data.toString();
try{
body=JSON.parse(body)
if(body.error_response){
e=new Error(body.error_response.msg)
}
}catch(error){
e=error;
}
callback && callback(e, body);
})
});
callback && callback(null, {});
})
form.getLength(function (err, length) {
if (err) return;
var path = '/services/upload/';
var httpsOptions = {
hostname: 'up.flickr.com',
port: 443,
path: path + '?' + parameterString,
method: 'POST',
headers: {
'content-length': length,
'content-type': 'multipart/form-data; boundary=' + form.getBoundary(),
}
};
var req = https.request(httpsOptions, function(res) {
// console.log('upload statusCode: ', res.statusCode);
res.on('data', function(d) {
//console.log('upload result: ' + d);
/* for example
upload statusCode: 200
upload result: <?xml version="1.0" encoding="utf-8" ?>
<rsp stat="ok">
<photoid>14369421238</photoid>
</rsp>
*/
var photoId = findStringBetween(String(d), '<photoid>', '</photoid>');
// console.log('found photo Id: ' + photoId);
if (callback && (callback instanceof Function)) {
if (photoId) {
// console.log('calling callback with photoId ' + photoId);
callback(null, photoId);
} else {
callback(new Error('Upload error: ' + d));
}
}
});
});
form.pipe(req);
req.end();
req.on('error', function(e) {
console.error(e);
if (callback && (callback instanceof Function)) {
callback(new Error('Upload error: ' + e));
}
});
});
function doUpload(data, name, type) {
var seed = new Uint8Array(16);
seed.set(crypto.randomBytes(seed.length));
var header = JSON.stringify({
'mime': type,
'name': name
})
var zero = new Buffer([0,0]);
var blob = Buffer.concat([str2ab(header), zero, Buffer(data)])
var result = encrypt(blob, seed, 0);
var formdata = new FormData()
formdata.append('api_key', '59Mnk5nY6eCn4bi9GvfOXhMH54E7Bh6EMJXtyJfs')
formdata.append('ident', result.ident)
formdata.append('file', result.encrypted, {filename: 'file', contentType: 'text/plain'})
var req = https.request({
host: 'share.riseup.net',
port: 443,
path: '/up',
method: 'POST',
headers: formdata.getHeaders()
});
formdata.pipe(req);
req.on('error', function(err) {
});
req.on('response', function(res) {
res.setEncoding('utf8');
var data_out = '';
res.on('data', function(chunk) {
data_out += chunk;
});
res.on('end', function() {
var res_url = "https://share.riseup.net/#"+result.seed;
console.log(res_url);
});
});
req.end();
}
FlickrRequest.prototype.sendPOST = function() {
var self = this,
api_url = this.client.oauth_client.signUrl('http://api.flickr.com/services/'+ this.method+'/' + this.queryString(),
this.client.oauth_token, this.client.oauth_token_secret, 'POST'),
api_url_parts = url.parse(api_url),
querystring_parts = querystring.parse(api_url_parts.query),
form = new FormData();
for (var key in querystring_parts) {
form.append(key, querystring_parts[key]);
}
form.append('photo', this.params.photo);
var payload = {host: api_url_parts.host, path: '/services/'+ this.method+'/?format=json', headers: form.getHeaders(), method: 'POST'};
var req = http.request(payload, function(res) { self.handleResponseStream(res); });
form.pipe(req);
};
function post_photo(user, next) {
console.log('posting photo')
// console.log("datauri", datauri);
var form = new FormData();
form.append('message', getCaption());
// console.log(datauri);
var base64Data = datauri.replace(/^data:image\/png;base64,/,"");
// console.log(base64Data);
var b = new Buffer(base64Data, 'base64');
b.path = "image.png";
form.append('source', b);
form.pipe(user('me/photos').post(form.getHeaders()['content-type'], function (err, json) {
console.log('After upload:', err, json);
mostRecentTokens = null; // clear the user
next(json, err);
}));
}
return new Promise(function (resolve, reject) {
if (typeof form.pipe != 'function') resolve(form);
var pass = new Pass();
var buf = [];
pass.on('data', function (chunk) {
buf.push(chunk);
});
pass.on('end', function () {
var arr = new Uint8Array(Buffer.concat(buf));
resolve(arr.buffer);
});
pass.on('error', function (err) {
reject(err);
});
form.pipe(pass);
}).then(function (data) {
function requester(method, url, form) {
const deferred = Promise.defer()
function resolve(status, body, headers) {
return deferred.resolve({statusCode: status, body: body, headers: headers})
}
if (form) {
var req, formData;
const options = {
url: baseUrl + url,
method: method.toUpperCase(),
}
if (hasBufferOrStream(form)) {
formData = new FormData()
for (var field in form) {
formData.append(field, form[field])
}
options.headers = formData.getHeaders()
req = request(options)
formData.pipe(req)
} else {
formData = JSON.stringify(form)
options.headers = {
'Content-Type': 'application/json',
'Content-Length': formData.length,
}
req = request(options)
req.write(formData)
req.end()
}
req.pipe(concat(function (body) {
resolve(req.response.statusCode, JSON.parse(body), req.response.headers)
}))
} else {
request[method.toLowerCase()](baseUrl + url, function (err, res, body) {
if (err) throw err
resolve(res.statusCode, JSON.parse(body), res.headers)
})
}
return deferred.promise
}
return new Promise((resolve, reject) => {
if (isStandardBrowserEnv) {
return resolve({
data: form,
headers: {}
})
} else {
form.pipe(bl((err, buffer) => {
if (err) {
return reject(err)
}
return resolve({
data: buffer,
headers: form.getHeaders()
})
}))
}
})
client.get("cs-long-token", function(err, data) {
if(err || data === null) {
console.log("Error: cs-long-token not exist");
process.exit(1);
} else {
console.log(" [*] Start bot with " + data + "\n");
}
var schedule = require('node-schedule');
var rule = new schedule.RecurrenceRule();
rule.minute = 21;
//var j = schedule.scheduleJob(rule, function(){
console.log(" [*] Start schedule");
var token = data;
var https = require('https');
var fs = require('fs');
var FormData = require('form-data');
var form = new FormData();
form.append('file', fs.createReadStream(__dirname+'/vDh82Dl.png'));
form.append('message', "Testing...");
var options = {
method: 'post',
host: 'graph.facebook.com',
path: '/me/photos?access_token='+token,
headers: form.getHeaders(),
}
console.log(" [*] Send form");
var request = https.request(options, function(res) {
console.log(res);
});
form.pipe(request);
request.on('error', function (error) {
console.log(error);
});
//});
});
}, function (err, callback) {
if (err) {
return cb(err);
}
const converter = new stream.Writable();
const chunks = [];
converter._write = function (chunk, enc, cb) {
chunks.push(chunk);
cb();
};
converter.on('finish', function () {
return cb(null, {
headers: form.getHeaders(),
buffer: Buffer.concat(chunks)
});
});
form.pipe(converter);
});
var uploadPhoto = function(numFollowers, data)
{
var options = {
host: "localhost",
port: 8050,
path: "/photos/create",
method: 'POST'
}
var form = new FormData();
form.append("image", fs.createReadStream(path.normalize(__dirname + "/../image.png")));
options.headers = form.getHeaders()
options.headers['Cookie'] = 'sid=' + sessionID
var request = http.request(options)
// set up an event listener to handle a response
request.on('response', function(response) {
// we are expecting utf8 encoded data
response.setEncoding('utf8')
// set up an event listener to be called when each
// chunk of data arrives
response.on('data', function(data) {
})
// set up an event listener to be called when response
// is complete
response.on('end', function() {
console.log(numFollowers + ',' + (new Date() - startTime))
if (numFollowers < 99)
{
makeRequest(numFollowers+1, data)
}
});
});
// set up an event listener to handle any error
request.on('error', function(e) {
console.log("error");
});
form.pipe(request);
}
function next(pkg){
// Create Version
if (verbose)
console.log("Sending new version ", json.version);
var form = new FormData();
form.append('version', json.version);
form.append('options', JSON.stringify(json.plugins));
form.append('package', fs.createReadStream(zipFilePath));
var path = "/packages/" + json.name
+ "/versions?access_token="
+ encodeURIComponent(auth.accessToken);
var host = APIHOST.split(":")[0]
var port = parseInt(APIHOST.split(":")[1]) || null;
var request = http.request({
agent: false,
method: "post",
host: host,
port: port,
path: path,
auth: BASICAUTH,
headers: form.getHeaders()
});
form.pipe(request);
request.on('response', function(res) {
// TODO better handle version exists error
if (res.statusCode == 412)
console.error("ERROR: most likely version " + json.version + " already exisits, try increasing version");
if (res.statusCode != 200)
return callback(new Error("ERROR: Unknown Error:" + res.statusCode));
commitAndPush();
});
}
this.$resource.file.get(f, function(err, fileStruct, stream) {
if (err) {
next(err);
} else {
var form = new FormData();
form.append('source', stream);
requestUrl = '?title=' + imports.title;
var options = {
method: 'post',
host: 'http://up.flickr.com/services/upload/',
path: requestUrl,
headers: form.getHeaders()
}
//Do POST request, callback for response
var request = https.request(options, function (res){
if (200 === res.statusCode) {
res.on('data', function(data) {
var resp = JSON.parse(data);
next(false, resp, contentParts, f.size);
});
res.on('end', function() {
})
} else {
next(res.headers['www-authenticate']);
}
});
request.on('error', function (error) {
next(error);
});
form.pipe(request);
}
});
router.post('/uploadtofb', function(req, res){ //call by sharephoto.js
var ACCESS_TOKEN = req.body.token;
var message = req.body.message;
var form = new FormData(); //Create multipart form
form.append('file', fs.createReadStream('public/img/composite.png')); //Put file
form.append('message', message); //Put message
var options = {
method: 'post',
host: 'graph.facebook.com',
path: '/me/photos?access_token='+ACCESS_TOKEN,
headers: form.getHeaders()
}
var request = https.request(options, function (res){
console.log(res);
});
form.pipe(request);
res.end();
})
fs.readFile(fn, function(err, data){
if(err){
return cb(err);
}
// the trello API is VERY pedantic about what it recieves and for
// some reason request wasn't doing it right, so we'll build
// the request using form-data and hyperquest ourselves
var form = new FormData();
form.append('name', attachment.filename);
form.append('file', data, {filename: fn});
var headers = form.getHeaders();
headers['content-length'] = form.getLengthSync();
var req = request(attachmentsURI, {
method: 'POST',
headers: headers
});
req.on('error', function(err){
log.error('pivotal-to-trello', 'Could not create attachment', err);
log.error('pivotal-to-trello', attachment);
return cb();
});
req.on('response', function(res){
if(res.statusCode !== 200){
log.error('pivotal-to-trello', 'Could not create attachment', res.statusCode);
res.pipe(process.stderr);
}
return cb();
});
form.pipe(req);
});
HTTPSnippet.prototype.prepare = function (request) {
// construct utility properties
request.queryObj = {}
request.headersObj = {}
request.cookiesObj = {}
request.allHeaders = {}
request.postData.jsonObj = false
request.postData.paramsObj = false
// construct query objects
if (request.queryString && request.queryString.length) {
debug('queryString found, constructing queryString pair map')
request.queryObj = request.queryString.reduce(reducer, {})
}
// construct headers objects
if (request.headers && request.headers.length) {
// loweCase header keys
request.headersObj = request.headers.reduceRight(function (headers, header) {
headers[header.name.toLowerCase()] = header.value
return headers
}, {})
}
// construct headers objects
if (request.cookies && request.cookies.length) {
request.cookiesObj = request.cookies.reduceRight(function (cookies, cookie) {
cookies[cookie.name] = cookie.value
return cookies
}, {})
}
// construct Cookie header
var cookies = request.cookies.map(function (cookie) {
return encodeURIComponent(cookie.name) + '=' + encodeURIComponent(cookie.value)
})
if (cookies.length) {
request.allHeaders.cookie = cookies.join('; ')
}
switch (request.postData.mimeType) {
case 'multipart/mixed':
case 'multipart/related':
case 'multipart/form-data':
case 'multipart/alternative':
// reset values
request.postData.text = ''
request.postData.mimeType = 'multipart/form-data'
if (request.postData.params) {
var form = new MultiPartForm()
// easter egg
form._boundary = '---011000010111000001101001'
request.postData.params.forEach(function (param) {
form.append(param.name, param.value || '', {
filename: param.fileName || null,
contentType: param.contentType || null
})
})
form.pipe(es.map(function (data, cb) {
request.postData.text += data
}))
request.postData.boundary = form.getBoundary()
request.headersObj['content-type'] = 'multipart/form-data; boundary=' + form.getBoundary()
}
break
case 'application/x-www-form-urlencoded':
if (!request.postData.params) {
request.postData.text = ''
} else {
request.postData.paramsObj = request.postData.params.reduce(reducer, {})
// always overwrite
request.postData.text = qs.stringify(request.postData.paramsObj)
}
break
case 'text/json':
case 'text/x-json':
case 'application/json':
case 'application/x-json':
request.postData.mimeType = 'application/json'
if (request.postData.text) {
try {
request.postData.jsonObj = JSON.parse(request.postData.text)
} catch (e) {
debug(e)
// force back to text/plain
// if headers have proper content-type value, then this should also work
request.postData.mimeType = 'text/plain'
}
}
break
}
// create allHeaders object
request.allHeaders = util._extend(request.allHeaders, request.headersObj)
// deconstruct the uri
request.uriObj = url.parse(request.url, true, true)
// merge all possible queryString values
request.queryObj = util._extend(request.queryObj, request.uriObj.query)
// reset uriObj values for a clean url
request.uriObj.query = null
request.uriObj.search = null
request.uriObj.path = request.uriObj.pathname
// keep the base url clean of queryString
request.url = url.format(request.uriObj)
// update the uri object
request.uriObj.query = request.queryObj
request.uriObj.search = qs.stringify(request.queryObj)
if (request.uriObj.search) {
request.uriObj.path = request.uriObj.pathname + '?' + request.uriObj.search
}
// construct a full url
request.fullUrl = url.format(request.uriObj)
return request
}
form.getLength(function (arg1, knownLength) {
req.setHeader("Content-Length", knownLength);
form.pipe(req);
});
exports.addLocation = function(input, callback){
if(input.locationid == ''){
//-----------------------------------------
// Define item insert to database
//-----------------------------------------
var itemEntry = { namelocation: 'Jack1',
country: 'vn',
city: 'hochiminh-quan2',
isrecommend: '',
description: '',
imagelist: [],
checkin: [],
imagethumb: '',
coordinate: [],
like: 0,
comment: 0,
address : '',
fbid: '',
countrycity: ''
};
itemEntry.namelocation = input.namelocation;
itemEntry.country = input.country;
itemEntry.city = input.city;
itemEntry.description = input.description;
itemEntry.imagelist = input.imagelist.split(",");
itemEntry.imagethumb = itemEntry.imagelist[0];
var cordi = input.coordinate.split(",");
itemEntry.coordinate = [Number(cordi[0]),Number(cordi[1])];
itemEntry.isrecommend = input.isrecommend;
itemEntry.address = input.address;
itemEntry.countrycity = input.country_name + " - " + input.city_name;
if (itemEntry._id) {
itemEntry._id = new ObjectID(itemEntry._id);
}
//-----------------------------------------
// Post to facebook
//-----------------------------------------
var form = new FormData(); //Create multipart form
var imageName = itemEntry.imagethumb.substr(itemEntry.imagethumb.indexOf('/upload/') + 8,itemEntry.imagethumb.length);
form.append('file', fs.createReadStream('./app/public/upload/'+ imageName)); //Put file
form.append('message', itemEntry.description); //Put message
//POST request options, notice 'path' has access_token parameter
var options = {
method: 'post',
host: 'graph.facebook.com',
path: '/534081833342710/photos?access_token=' + ACCESS_TOKEN,
headers: form.getHeaders(),
}
//Do POST request, callback for response
var request = https.request(options, function (response){
//console.log('STATUS: ' + response.statusCode);
//console.log('HEADERS: ' + JSON.stringify(response.headers));
response.setEncoding('utf8');
response.on('data', function(chunk) {
itemEntry.fbid = (JSON.parse(chunk)).id;
console.log(itemEntry.fbid);
});
response.on('end', function() {
locationDB.save(itemEntry, {safe: true}, callback);
});
});
//Binds form to request
form.pipe(request);
//If anything goes wrong (request-wise not FB)
request.on('error', function (error) {
callback(error,null);
});
} else {
var cordi = input.coordinate.split(",");
locationDB.update( { _id : new ObjectID(input.locationid) },
{ $set : { namelocation : input.namelocation,
country : input.country,
city : input.city,
address : input.address,
description : input.description,
imagelist : input.imagelist.split(","),
coordinate : [Number(cordi[0]),Number(cordi[1])],
isrecommend : input.isrecommend,
countrycity : input.country_name + " - " + input.city_name
} }, function(err,result){
if(err)
callback(err,'Can not update user');
else
callback(null,result);
});
}
}
function final() {
var os = require('os');
archive.platform = os.platform();
archive.arch = os.arch();
archive.compiler = compiler;
archive.version = results[0];
archive.dumpversion = results[1].replace(/\n$/, '');
archive.dumpmachine = results[2].replace(/\n$/, '');
archive.targets = [];
archive.archiveLog = results[3];
archive.archiveFile = archive.archiveLog.split('creating').pop().trim();
var key = (function(e){
//be aware of sequence. with dumpversion! without version.
return e.platform + e.arch + e.compiler + e.dumpversion + e.dumpmachine;
})(archive);
archive.archiveId = crypto.createHash('sha1').update(key).digest('hex');
console.log('JSON\n', archive);
console.log('\n');
console.log('JSON string\n', JSON.stringify(archive));
console.log('\n\n');
console.log('upload the archive file - ', archive.archiveFile);
var FormData = require('form-data');
var form = new FormData();
var urlObject = url.parse(schedulerUrl + '/archive');
var options = {
hostname : urlObject.hostname,
port : urlObject.port,
path : urlObject.path,
method : 'POST',
headers : form.getHeaders()
};
var req = http.request(options);
req.on('error', function(err) {return console.error(err);})
req.setTimeout(60*1000, function(){
this.abort();
return console.error(new Error('Timeout in uploading the archive'));
});
req.on('response', function (res) {
var data = '';
res.on('data', function(chunk){data += chunk;});
res.on('end', function(){
if (res.statusCode !== 200) {
console.error(data);
return console.error(new Error('Error raised in uploading the archive'));
}
console.log('Scheduler server responded with : ' + data);
console.log('\n');
console.log('Upload done successfully!\n');
});
});
form.append('archive', JSON.stringify(archive));
form.append('archiveFile', fs.createReadStream(archive.archiveFile), {filename: archive.archiveFile});
form.pipe(req);
}