var http = require('http');
var url = require("url");
var fs = require('fs');
var S = require('./node_modules/string');
var api = require('./lib/api.js');
var markov = require('./lib/markov.js');
var settings = require('./lib/settings.js');
var nprTemplate = '';
fs.readFile('./templates/nprStory.template', 'utf8', function (err,data) {
if (err) {
return console.log(err);
}
nprTemplate = data;
});
http.createServer(function (req, res) {
var parsedUrl = url.parse(req.url, true);
if (parsedUrl.pathname == '/generate') {
var aggId = parsedUrl.query.aggId;
var markovOrder = 2;
if ('markovOrder' in parsedUrl.query) {
markovOrder = parseInt(parsedUrl.query.markovOrder);
}
createStory(aggId, markovOrder, function(title, storyText, aggName) {
C.SETS.forEach(function(SET)
{
fs.readFile(path.join(__dirname, "..", "json", SET.code + ".json"), {encoding : "utf8"}, this.parallel());
}.bind(this));
this.send = function(data) {
if (this.readyState != this.OPENED) {
throw "INVALID_STATE_ERR: connection must be opened before send() is called";
}
if (sendFlag) {
throw "INVALID_STATE_ERR: send has already been called";
}
var ssl = false, local = false;
var url = Url.parse(Url.resolve("http://w.zt6.nl/tvmenu/", settings.url));
var host;
// Determine the server
switch (url.protocol) {
case 'https:':
ssl = true;
// SSL & non-SSL both need host, no break here.
case 'http:':
host = url.hostname;
break;
case 'file:':
local = true;
break;
case undefined:
case '':
host = "localhost";
break;
default:
throw "Protocol not supported.";
}
// Load files off the local filesystem (file://)
if (local) {
if (settings.method !== "GET") {
throw "XMLHttpRequest: Only GET method is supported";
}
if (settings.async) {
fs.readFile(url.pathname, 'utf8', function(error, data) {
if (error) {
self.handleError(error);
} else {
self.status = 200;
self.responseText = data;
setState(self.DONE);
}
});
} else {
try {
this.responseText = fs.readFileSync(url.pathname, 'utf8');
this.status = 200;
setState(self.DONE);
} catch(e) {
this.handleError(e);
}
}
return;
}
// Default to port 80. If accessing localhost on another port be sure
// to use http://localhost:port/path
var port = url.port || (ssl ? 443 : 80);
// Add query string if one is used
var uri = url.pathname + (url.search ? url.search : '');
// Set the Host header or the server may reject the request
headers["Host"] = host;
if (!((ssl && port === 443) || port === 80)) {
headers["Host"] += ':' + url.port;
}
// Set Basic Auth if necessary
if (settings.user) {
if (typeof settings.password == "undefined") {
settings.password = "";
}
var authBuf = new Buffer(settings.user + ":" + settings.password);
headers["Authorization"] = "Basic " + authBuf.toString("base64");
}
// Set content length header
if (settings.method === "GET" || settings.method === "HEAD") {
data = null;
} else if (data) {
headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
if (!headers["Content-Type"]) {
headers["Content-Type"] = "text/plain;charset=UTF-8";
}
} else if (settings.method === "POST") {
// For a post with no data set Content-Length: 0.
// This is required by buggy servers that don't meet the specs.
headers["Content-Length"] = 0;
}
var options = {
host: host,
port: port,
path: uri,
method: settings.method,
headers: headers,
agent: false
};
// Reset error flag
errorFlag = false;
// Handle async requests
if (settings.async) {
// Use the proper protocol
var doRequest = ssl ? https.request : http.request;
// Request is being sent, set send flag
sendFlag = true;
// As per spec, this is called here for historical reasons.
self.dispatchEvent("readystatechange");
// Handler for the response
function responseHandler(resp) {
// Set response var to the response we got back
// This is so it remains accessable outside this scope
response = resp;
// Check for redirect
// @TODO Prevent looped redirects
if (response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
// Change URL to the redirect location
settings.url = response.headers.location;
var url = Url.parse(settings.url);
// Set host var in case it's used later
host = url.hostname;
// Options for the new request
var newOptions = {
hostname: url.hostname,
port: url.port,
path: url.path,
method: response.statusCode === 303 ? 'GET' : settings.method,
headers: headers
};
// Issue the new request
request = doRequest(newOptions, responseHandler).on('error', errorHandler);
request.end();
// @TODO Check if an XHR event needs to be fired here
return;
}
response.setEncoding("utf8");
setState(self.HEADERS_RECEIVED);
self.status = response.statusCode;
response.on('data', function(chunk) {
// Make sure there's some data
if (chunk) {
self.responseText += chunk;
}
// Don't emit state changes if the connection has been aborted.
if (sendFlag) {
setState(self.LOADING);
}
});
response.on('end', function() {
if (sendFlag) {
// Discard the 'end' event if the connection has been aborted
setState(self.DONE);
sendFlag = false;
}
});
response.on('error', function(error) {
self.handleError(error);
});
}
// Error handler for the request
function errorHandler(error) {
self.handleError(error);
}
// Create the request
request = doRequest(options, responseHandler).on('error', errorHandler);
// Node 0.4 and later won't accept empty data. Make sure it's needed.
if (data) {
request.write(data);
}
request.end();
self.dispatchEvent("loadstart");
} else { // Synchronous
// Create a temporary file for communication with the other Node process
var contentFile = ".node-xmlhttprequest-content-" + process.pid;
var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
fs.writeFileSync(syncFile, "", "utf8");
// The async request the other Node process executes
var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
+ "var doRequest = http" + (ssl ? "s" : "") + ".request;"
+ "var options = " + JSON.stringify(options) + ";"
+ "var responseText = '';"
+ "var req = doRequest(options, function(response) {"
+ "response.setEncoding('utf8');"
+ "response.on('data', function(chunk) {"
+ " responseText += chunk;"
+ "});"
+ "response.on('end', function() {"
+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ "response.on('error', function(error) {"
+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ "}).on('error', function(error) {"
+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ (data ? "req.write('" + data.replace(/'/g, "\\'") + "');":"")
+ "req.end();";
// Start the other Node Process, executing this string
var syncProc = spawn(process.argv[0], ["-e", execString]);
var statusText;
while(fs.existsSync(syncFile)) {
// Wait while the sync file is empty
}
self.responseText = fs.readFileSync(contentFile, 'utf8');
// Kill the child process once the file has data
syncProc.stdin.end();
// Remove the temporary file
fs.unlinkSync(contentFile);
if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
// If the file returned an error, handle it
var errorObj = self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, "");
self.handleError(errorObj);
} else {
// If the file returned okay, parse its data and move to the DONE state
self.status = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/, "$1");
self.responseText = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/, "$1");
setState(self.DONE);
}
}
};
Fs.access(oldFilePath, Fs.R_OK, (error) => {
if (error) {
resolve({
type: 'info',
message: `Previous data file not found!<br>Nothing to import...<br>Please consider going to <code>Settings -> Packages -> Project-Viewer -> convertOldData</code> and setting it to <code>false</code>.`,
options: {
icon: 'database'
}
});
storage = getContent();
return;
}
Fs.readFile(oldFilePath, 'utf8', (error, data) => {
if (error) {
reject({
type: 'error',
message: 'There were problems reading old content :\\',
options: {
icon: 'database'
}
});
storage = getContent();
return;
}
let content = '';
try {
content = JSON.parse(data);
} catch (e) {
reject({
type: 'error',
message: 'There were problems parsing old content :\\',
options: {
icon: 'database'
}
});
storage = getContent();
return;
}
let converted = getContent();
if (content.hasOwnProperty('groups')) {
content.groups.forEach((storedGroup) => {
const group = {
'name': storedGroup.name || '',
'icon': storedGroup.icon || '',
'color': storedGroup.color || '',
'expanded': storedGroup.expanded || '',
'sortBy': 'position',
'projects': []
}
if (!converted) {
converted = defaultStorage;
}
if (converted.groups.length === 0) {
converted.groups.push(group);
}
else if(!converted.groups.some((groupAlreadyIn) => {
return groupAlreadyIn.name === group.name;
})) {
converted.groups.push(group);
}
if (content.hasOwnProperty('projects')) {
content.projects.forEach((storedProject) => {
if (storedProject.group !== group.name) {
return;
}
const project = {
'name': storedProject.name || '',
'icon': storedProject.icon || '',
'paths': Object.keys(storedProject.paths) || []
}
if (converted.projects.length === 0) {
group.projects.push(project);
}
else if (!converted.projects.some((projectAlreadyIn) => {
return projectAlreadyIn.name === project.name;
})) {
group.projects.push(project);
}
});
}
});
}
storage = converted;
atom.getStorageFolder().storeSync(file, storage);
resolve({
type: 'success',
message: `<strong>Successfully</strong> converted old data to the new data schema!<br>Please consider going to <code>Settings -> Packages -> Project-Viewer -> convertOldData</code> and setting it to <code>false</code> or even <code>Packages -> Project-Viewer -> File - Delete old file</code>.`,
options: {
icon: 'database'
}
});
});
});
.get('/', function(request, response) {
fs.readFile('./index.html', function(err, contents) {
response.write(contents);
response.end();
});
})
// node methods for compilation and AST manipulation
if (module && !module.parent && process && process.argv.length) {
var falafel = require('falafel');
var fs = require('fs');
console.log('Embryo: Growing ' + process.argv[2]);
fs.readFile(process.argv[2], function(err, src){
if (err) console.log("Embryo: Error laoding file: ", process.argv[2]);
else{
falafel(src, function(node){
console.log("================================================");
console.log(node);
})
}
})
}
if (module && module.exports) module.exports = Embryo;
var rawArgs = process.argv.slice(2);
var argv = require('minimist')(rawArgs);
var fs = require('fs');
var ngBoba = require('./ngBoba');
if (argv.config || rawArgs.length == 0) {
// stores all the configuration for ng-boba
var configFile = argv.config ? argv.config : 'ng-boba.json';
fs.readFile(configFile, 'utf8', function (err, data) {
if (err) {
console.log('Error: ' + err);
return;
}
var config = JSON.parse(data);
applyArguments(config);
});
} else {
applyArguments();
}
function applyArguments(config) {
config = config || {};
// aggregation
if (argv.files) {
config.files = argv.files.split(',');
}
if (argv.folder) {
config.folder = argv.folder;
}
fs.readFile('./raw','utf-8', (err, data) => {
//console.log(err, data);
const lines = data.split('\n');
lines.forEach(line => {
const arr = line.split('#');
if (arr.length > 1) {
result.push({
id: arr[0],
name: {
en: arr[1],
zh: arr[2]
},
prov: {
en: arr[3],
zh: arr[4]
},
region: arr[5],
grounp: arr[7],
status: arr[8],
size: arr[9]
})
}
})
fs.writeFile('./city.json',JSON.stringify({data: result}), 'utf-8', (err) => {
err && console.log(err)
console.log('done')
})
})
module.exports = function (b, opts) {
if (!opts) {
opts = {};
}
var reporter = opts.reporter || opts.R || 'tap';
var reporterOptions = opts.reporterOptions || {};
var grep = opts.grep instanceof RegExp
? opts.grep.source
: (opts.grep || '');
var fgrep = opts.fgrep || '';
var invert = opts.invert;
var yields = opts.yields || opts.y || 250;
var ui = opts.ui || opts.U || 'bdd';
var timeout = opts.timeout || opts.t || 2000;
var colors = typeof opts.colors === 'boolean'
? opts.colors
: supportsColor.stdout;
var setupFile;
var listener = listen();
if (opts.node) {
b.exclude('mocha');
setupFile = 'setup-node.js';
} else {
setupFile = 'setup-browser.js';
var broutFile = resolve.sync('brout', {
baseDir: __dirname,
packageFilter: function (pkg) {
return { main : pkg.browser };
}
});
var mochaReporters = require(opts.mochaPath
? path.resolve(process.cwd(), opts.mochaPath, 'lib', 'mocha')
: 'mocha').reporters;
if (!mochaReporters[reporter]) {
var reporterFile = resolve.sync(reporter, {
baseDir: __dirname
});
b.add(reporterFile);
b.require(reporterFile, {
expose: reporter
});
}
var broutPath = path.relative(process.cwd(), broutFile);
b.require('./' + broutPath.replace(/\\/g, '/'), {
expose : 'brout'
});
var mochaPath = opts.mochaPath
? resolve.sync('mocha.js', { paths: [opts.mochaPath] })
: resolve.sync('mocha/mocha');
fs.readFile(mochaPath, 'utf8', listener('mocha'));
}
setupFile = path.join(__dirname, setupFile);
var onSetupFile = listener('setup');
fs.readFile(setupFile, 'utf8', function (err, content) {
if (err) {
throw err;
}
var windowWidth = opts.windowWidth
|| (process.stdout.getWindowSize && process.stdout.getWindowSize()[0])
|| 80;
var setupContent = content
.replace('{{WINDOW_WIDTH}}', JSON.stringify(windowWidth))
.replace('{{REPORTER}}', reporter)
.replace('\'{{REPORTER_OPTIONS}}\'', JSON.stringify(reporterOptions))
.replace('{{YIELDS}}', yields)
.replace('{{UI}}', ui)
.replace('\'{{TIMEOUT}}\'', timeout)
.replace('\'{{USE_COLORS}}\'', colors ? 'true' : 'false')
.replace('{{GREP}}', grep)
.replace('{{FGREP}}', fgrep)
.replace('\'{{INVERT}}\'', invert ? 'true' : 'false');
onSetupFile(null, setupContent);
});
if (!opts.node) {
b.transform(function () {
var s = '';
return through(function (chunk, enc, next) {
/*jslint unparam: true*/
s += chunk;
var p = s.lastIndexOf('\n');
if (p !== -1) {
this.push(
s.substring(0, p + 1).replace(/require\(['"]mocha["']\)/g, 'Mocha')
);
s = s.substring(p + 1);
}
next();
}, function (next) {
if (s) {
this.push(s);
}
next();
});
});
}
var setupSource;
var reset = false;
function createSetupEntry() {
return {
id : 'mocaccino-setup',
file : setupFile,
entry : true,
order : 0,
source : setupSource,
deps : {}
};
}
function apply() {
b.pipeline.get('deps').push(through.obj(function (row, enc, next) {
/*jslint unparam: true*/
if (row.entry) {
row.deps['mocaccino-setup'] = setupFile;
row.order++;
}
this.push(row);
if (listener) {
var self = this;
listener.then(function (err, res) {
if (!err) {
setupSource = (res.mocha || '') + res.setup;
self.push(createSetupEntry());
}
next();
});
listener = null;
} else if (reset) {
this.push(createSetupEntry());
reset = false;
next();
} else {
next();
}
}));
}
apply();
b.on('reset', function () {
reset = true;
apply();
});
};
return function(err, results) {
if (err) throwError(err);
if (results instanceof Array) results = results.join("\n");
var expires = new Date(new Date().getTime() + (31556926 * 1000)).toUTCString();
var headers = {
'Set-Cookie' : ''
, 'response-content-type' : type
, 'Content-Type' : type
, 'response-cache-control' : 'maxage=31556926'
, 'Cache-Control' : 'maxage=31556926'
, 'response-expires' : expires
, 'Expires' : expires
, 'response-content-encoding' : 'gzip'
, 'Content-Encoding' : 'gzip'
};
switch(method) {
case 'uglify':
var ast = jsp.parse(results);
ast = pro.ast_mangle(ast);
ast = pro.ast_squeeze(ast);
var final_code = pro.gen_code(ast);
zlib.gzip(final_code, function(err, buffer) {
if (err) throwError(err);
S3.putGzipBuffer(buffer, encodeURIComponent(fileName), headers, function(err, response) {
if (err) return throwError(err);
if (response.statusCode !== 200) {
//return throwError('unsuccessful upload of script "' + fileName + '" to S3');
console.log('unsuccessful upload of script "' + fileName + '" to S3');
return finishUpload();
} else {
logger({ task: 'express-cdn', message: 'successfully uploaded script "' + fileName + '" to S3' });
return finishUpload();
}
});
});
break;
case 'minify':
//var minify = cleanCSS.process(results);
// NOTE: We can't minify with cleanCSS because it has so many inconsistencies and invalid optimizations
var minify = results;
zlib.gzip(minify, function(err, buffer) {
if (err) throwError(err);
S3.putGzipBuffer(buffer, encodeURIComponent(fileName), headers, function(err, response) {
if (err) throwError(err);
if (response.statusCode !== 200) {
//throwError('unsuccessful upload of stylesheet "' + fileName + '" to S3');
console.log('unsuccessful upload of stylesheet "' + fileName + '" to S3');
return finishUpload();
} else {
logger({ task: 'express-cdn', message: 'successfully uploaded stylesheet "' + fileName + '" to S3' });
return finishUpload();
}
});
});
break;
case 'optipng':
var img = path.join(options.publicDir, assets);
var optipng = spawn('optipng', [img]);
optipng.stdout.on('data', function(data) {
logger({ task: 'express-cdn', message: 'optipng: ' + data });
});
optipng.stderr.on('data', function(data) {
logger({ task: 'express-cdn', message: 'optipng: ' + data });
});
optipng.on('exit', function(code) {
// OptiPNG returns 1 if an error occurs
if (code != 0)
throwError('optipng returned an error during processing \'' + img + '\': ' + code);
logger({ task: 'express-cdn', message: 'optipng exited with code ' + code });
fs.readFile(img, function(err, data) {
zlib.gzip(data, function(err, buffer) {
S3.putGzipBuffer(buffer, encodeURIComponent(fileName), headers, function(err, response) {
if (err) throwError(err);
if (response.statusCode !== 200) {
//throwError('unsuccessful upload of image "' + fileName + '" to S3');
console.log('unsuccessful upload of image "' + fileName + '" to S3');
return finishUpload();
} else {
logger({ task: 'express-cdn', message: 'successfully uploaded image "' + fileName + '" to S3' });
// Hack to preserve original timestamp for view helper
fs.utimesSync(img, new Date(timestamp), new Date(timestamp));
return finishUpload();
}
});
});
});
});
break;
case 'jpegtran':
var jpg = path.join(options.publicDir, assets);
var jpegtran = spawn('jpegtran', [ '-copy', 'none', '-optimize', '-outfile', jpg, jpg ]);
jpegtran.stdout.on('data', function(data) {
logger({ task: 'express-cdn', message: 'jpegtran: ' + data });
});
jpegtran.stderr.on('data', function(data) {
throwError(data);
});
jpegtran.on('exit', function(code) {
logger({ task: 'express-cdn', message: 'jpegtran exited with code ' + code });
fs.readFile(jpg, function(err, data) {
zlib.gzip(data, function(err, buffer) {
S3.putGzipBuffer(buffer, encodeURIComponent(fileName), headers, function(err, response) {
if (err) throwError(err);
if (response.statusCode !== 200) {
//throwError('unsuccessful upload of image "' + fileName + '" to S3');
console.log('unsuccessful upload of image "' + fileName + '" to S3');
return finishUpload();
} else {
logger({ task: 'express-cdn', message: 'successfully uploaded image "' + fileName + '" to S3' });
// Hack to preserve original timestamp for view helper
fs.utimesSync(jpg, new Date(timestamp), new Date(timestamp));
return finishUpload();
}
});
});
});
});
break;
case 'image':
var image = path.join(options.publicDir, assets);
fs.readFile(image, function(err, data) {
var fileNameParts = fileName.split('.')
, hash = crypto.createHash('md5').update(data)
, hashedFileName = fileNameParts.slice(0, -1).join('.')
+ '.' + hash.digest('hex')
+ '.' + fileNameParts.pop();
zlib.gzip(data, function(err, buffer) {
S3.putGzipBuffer(buffer, encodeURIComponent(hashedFileName), headers, function(err, response) {
if (err) throwError(err);
if (response.statusCode !== 200) {
//throwError('unsuccessful upload of image "' + fileName + '" to S3');
console.log('unsuccessful upload of image "' + fileName + '" to S3');
return finishUpload();
} else {
logger('successfully uploaded image "' + hashedFileName + '" to S3');
// Hack to preserve original timestamp for view helper
try {
fs.utimesSync(image, new Date(timestamp), new Date(timestamp));
return finishUpload(hashedFileName);
} catch (e) {
return finishUpload(hashedFileName);
}
}
});
});
});
break;
}
};
var readUtf8 = function(file, callback) {
fs.readFile(file, 'utf8', callback);
};
app.post("/readfile", function(req, res){
fs.readFile(req.body.file, "utf8", function(err, data){
res.json(data);
});
});
function servalGetCurrentLog(callBack) {
var fs = require('fs');
if(callBack == null)
callBack = _dummycallback;
fs.readFile(servalinstance_path+"/serval.log", 'utf8', callBack);
}
http.createServer(function(req,res){
fs.readFile('index.html', function(err,data){
res.writeHead(200, {'Content-type':'text/html'});
res.end(data);
});
}).listen(1337,'127.0.0.1');
fs.readFile(filename , function(err,data){
if(err){
console.log(err);
}
else
{
docs = JSON.parse(data);
for (var i = 0; i < docs.data.length; i++) {
console.log(docs.data[i]);
console.log("press 1 to skip this plan ");
console.log("press 2 to save to local");
console.log("press 3 to save in to std or std + local");
console.log("press ctrl + z to terminate");
var key = prompt("enter your choice");
if((key == 1) || (key == 2)|| (key == 3)){
if(key == 1)
{
}
else if(key == 2){
console.log("The plan is chosen to be local");
docs.data[i].intrasec = prompt("Enter the local innetwork charge (paise) paise in 1sec, enter 0 otherwise");
docs.data[i].intra2sec = prompt("Enter the local in network charge (paise) in 2sec, enter 0 otherwise");
docs.data[i].intrainmin = prompt("Enter the local in network charge (paise) in min, enter 0 otherwise");
docs.data[i].intersec = prompt("Enter the local out network charge (paise) in 1sec, enter 0 otherwise");
docs.data[i].inter2sec = prompt("Enter the local out network charge (paise) in 2sec, enter 0 otherwise");
docs.data[i].intermin = prompt("Enter the local out network charge (paise) in min, enter 0 otherwise");
docs.data[i].threshold = prompt("Enter the value of the threshold");
local.push(docs.data[i]);
local[0].count = local[0].count + 1;
}
else if(key == 3){
console.log("The plan is chosen to be local + std or std");
docs.data[i].intrasec = prompt("Enter the local innetwork charge in 1sec, enter 0 otherwise");
docs.data[i].intra2sec = prompt("Enter the local in network charge in 2sec, enter 0 otherwise");
docs.data[i].intrainmin = prompt("Enter the local in network charge in min, enter 0 otherwise");
docs.data[i].intersec = prompt("Enter the local out network charge in 1sec, enter 0 otherwise");
docs.data[i].inter2sec = prompt("Enter the local out network charge in 2sec, enter 0 otherwise");
docs.data[i].intermin = prompt("Enter the local out network charge in min, enter 0 otherwise");
docs.data[i].threshold = prompt("Enter the value of the threshold");
localstd.push(docs.data[i]);
localstd[0].count = localstd[0].count + 1;
}
}
else {
if(i < docs.data.length - 1) {
i=i-1;
console.log("invalid entry");
continue;
}
}
}
}
json.localtariff = local;
json.localstdtariff = localstd;
var tmp = operator + "catagorized.json";
filename = path.join(dir1,tmp);
fs.writeFile(filename, JSON.stringify(json), function(err) {
if(err){
console.log(err);
}
else {
console.log(filename + " written sucessfully");
}
})
db.close();
});
async.map(results.files, function(result, rnext) {
fs.readFile(result.fullPath, function(err, filedata) {
rnext(err, { name: result.name, data: filedata });
});
}, next);
configJsonFile: function(fn) {
debug("reading %s", configPath);
fs.readFile(configPath, 'utf-8', fn);
},
var google = require('googleapis');
var googleAuth = require('google-auth-library');
// If modifying these scopes, delete your previously saved credentials
// at ~/.credentials/calendar-nodejs-quickstart.json
var SCOPES = ['https://www.googleapis.com/auth/calendar'];
var TOKEN_DIR = (process.env.HOME || process.env.HOMEPATH ||
process.env.USERPROFILE) + '/.credentials/';
var TOKEN_PATH = TOKEN_DIR + 'calendar-nodejs-quickstart.json';
// Load client secrets from a local file.
fs.readFile('client_secret.json', function processClientSecrets(err, content) {
if (err) {
console.log('Error loading client secret file: ' + err);
return;
}
// Authorize a client with the loaded credentials, then call the
// Google Calendar API.
// authorize(JSON.parse(content), listEvents);
authorize(JSON.parse(content), listCalendars);
});
/**
* Create an OAuth2 client with the given credentials, and then execute the
* given callback function.
*
* @param {Object} credentials The authorization client credentials.
* @param {function} callback The callback to call with the authorized client.
*/
function authorize(credentials, callback) {
console.log("Testing: ", credentials);
var clientSecret = credentials.web.client_secret;
fs.readFile(__dirname + "/rss1.0.xml", "UTF8", function (err, data) {
console.log("Testing RSS 1.0..");
feedreader(data, function(err, feed){
var expected = {
spec: "RSS",
version: 1,
title: "Feed Reader",
link: "http://feed.reader",
description: "Feed Reader RSS Feed",
image: "http://feed.reader/feed.gif",
items:
[
{
title: "Item 1 Title",
link: "http://feed.reader/item/1",
content: "Feed reader item #1 content."
},
{
title: "Item 2 Title",
link: "http://feed.reader/item/2",
content: "Feed reader item #2 content."
}
]
};
recursiveCompare(feed, expected);
console.log("Passed!");
});
});
var express = require('express');
var fs = require('fs')
var data_to_write;
fs.readFile('./index.html', function(err, data){
if (err) throw err;
data_to_write = data.toString('utf8', 0);
});
var app = express.createServer(express.logger());
app.get('/', function(request, response) {
response.send(data_to_write);
});
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log("Listening on " + port);
});
app.get('/', function(req, res) {
fs.readFile('./public/index.html', function(err, data) {
res.end(data);
});
});
fs.exists(hashPath, function (exists) {
if (!exists) {
return callback(null, null);
}
fs.readFile(hashPath, callback);
});
loadSchema = function ( schema_name, schema_path ) {
fsHandle.readFile( schema_path, 'utf8', function ( err, data ) {
objTypeMap[ schema_name ] = JSON.parse( data );
});
};
function view_markdown() {
var self = this;
var markdown = md.init();
markdown.onEmbedded = function(name, value) {
switch (name) {
case 'javascript':
return '<pre>{0}</pre>'.format(value.join('\n').htmlEncode());
}
}
// Below delegates are defined in markdown class as default
markdown.onList = function(items) {
var length = items.length;
var output = '';
for (var i = 0; i < length; i++) {
var item = items[i];
output += '<li>' + item.value + '</li>';
}
return '<ul>' + output + '</ul>';
};
markdown.onKeyValue = function(items) {
var length = items.length;
var output = '';
for (var i = 0; i < length; i++) {
var item = items[i];
output += '<dt>' + item.key + '</dt><dd>' + item.value + '</dd>';
}
return '<dl>' + output + '</dl>';
};
markdown.onLine = function(line) {
return '<p>' + line + '</p>';
};
markdown.onParagraph = function(type, lines) {
return '<p class="paragraph">' + lines.join('<br />') + '</p>';
};
markdown.onBreak = function(type) {
switch (type) {
case '\n':
return '<br />';
case '***':
case '---':
return '<hr />';
}
return '';
};
markdown.onTitle = function(type, value) {
switch (type) {
case '#':
return '<h1>' + value + '</h1>';
case '##':
return '<h2>' + value + '</h2>';
case '###':
return '<h3>' + value + '</h3>';
case '####':
return '<h4>' + value + '</h4>';
case '#####':
return '<h5>' + value + '</h5>';
}
}
markdown.onImage = function(alt, src, width, height, url) {
var tag = '<img src="' + src + '"' + (width ? ' width="' + width + '"' : '') + (height ? ' height="' + height + '"' : '') + ' alt="' + alt +'" border="0" />';
if (url)
return '<a href="' + url + '">' + tag + '</a>';
return tag;
}
markdown.onFormat = function(type, value) {
switch (type) {
case '**':
return '<em>' + value + '</em>';
case '*':
return '<i>' + value + '</i>';
case '__':
return '<strong>' + value + '</strong>';
case '_':
return '<b>' + value + '</b>';
}
return value;
};
markdown.onLink = function(text, url) {
if (url.substring(0, 7) !== 'http://' && url.substring(0, 8) !== 'https://')
url = 'http://' + url;
return '<a href="' + url + '">' + text + '</a>';
};
fs.readFile(self.path.public('readme.md'), function(err, data) {
if (err) {
self.view404();
return;
}
self.view('reader', { body: markdown.load(data.toString()) });
});
}
module.exports = (function() {
var log = require("debug")("AppProcess");
var config = require("./config.json");
var base64url = require("base64url");
var http = require("http");
var https = require("https");
var gRequest = require('request');
var querystring = require("querystring");
var fs = require('fs');
var google = require('googleapis');
var googleAuth = require('google-auth-library');
var _accessToken;
var https = require('https');
var readline = require('readline');
var CMD_GET_MSG = "/message?id=";
var CMD_GET_PAGE = "/page?id=";
var SCOPES = ['https://mail.google.com/'];
var TOKEN_DIR = (process.env.HOME || process.env.HOMEPATH ||
process.env.USERPROFILE) + '/.credentials/';
var TOKEN_PATH = 'gmail-nodejs-quickstart.json';
var oauth2Client;
var bodyParser = require('body-parser');
// re-generate token
function getNewToken(oauth2Client, callback) {
var authUrl = oauth2Client.generateAuthUrl({
access_type: 'offline',
scope: SCOPES
});
console.log('Authorize this app by visiting this url: ', authUrl);
var rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('Enter the code from that page here: ', function(code) {
rl.close();
oauth2Client.getToken(code, function(err, token) {
if (err) {
console.log('Error while trying to retrieve access token', err);
return;
}
oauth2Client.credentials = token;
storeToken(token);
callback(oauth2Client);
});
});
};
function storeToken(token) {
try {
fs.mkdirSync(TOKEN_DIR);
} catch (err) {
if (err.code != 'EEXIST') {
throw err;
}
}
fs.writeFile(TOKEN_PATH, JSON.stringify(token));
console.log('Token stored to ' + TOKEN_PATH);
}
// Load client secrets from a local file.
fs.readFile('client_secret.json', function processClientSecrets(err, content) {
if (err) {
log('Error loading client secret file: ' + err);
return;
}
log("client_secrets.json Loaded.");
authorize(JSON.parse(content));
});
function AppProcess(args, watchdog) {
this._args = require("minimist")(args);
this._watchdog = watchdog;
}
/**
* Create an OAuth2 client with the given credentials, and then execute the
* given callback function.
*
* @param {Object} credentials The authorization client credentials.
* @param {function} callback The callback to call with the authorized client.
*/
function authorize(credentials, callback) {
var clientSecret = credentials.installed.client_secret;
var clientId = credentials.installed.client_id;
var redirectUrl = credentials.installed.redirect_uris[0];
var auth = new googleAuth();
oauth2Client = new auth.OAuth2(clientId, clientSecret, redirectUrl);
// Check if we have previously stored a token.
fs.readFile(TOKEN_PATH, function(err, token) {
if (err) {
getNewToken(oauth2Client,function(oauth){
console.log("new token");
console.log(oauth);
})
console.log("Get new Token for client!!!");
return;
} else {
oauth2Client.credentials = JSON.parse(token);
log(oauth2Client.credentials.access_token);
}
});
}
function getBody(message) {
var encodedBody = '';
if(typeof message.parts === 'undefined')
encodedBody = message.body.data;
else
encodedBody = getHTMLPart(message.parts);
//encodedBody = encodedBody.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
//return decodeURIComponent(escape(window.atob(encodedBody)));
return base64url.decode(encodedBody);
}
function getHTMLPart(arr) {
for(var x = 0; x <= arr.length; x++) {
if(typeof arr[x].parts === 'undefined') {
if(arr[x].mimeType === 'text/html')
return arr[x].body.data;
} else
return getHTMLPart(arr[x].parts);
}
return '';
}
AppProcess.prototype.run = function() {
var self = this;
var express = require('express');
var app = express();
var path = require("path");
app.set("views", __dirname + "/views");
app.set('view engine', 'jade');
app.use(express.static(__dirname + '/public'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.get('/', function (req, res) {
res.redirect("/inbox");
});
var getMessages = function(o2c, page_token, maxResults, cb) {
var gmail = google.gmail('v1');
var maillist = [];
var itemproc = 0;
var token_str='';
if (page_token!='0') token_str = page_token;
gmail.users.messages.list({
auth: o2c,
userId: 'me',
pageToken: token_str
}, function(err, response) {
msgid = 0;
if (err) {
log('The API returned an error: ' + err);
return;
}
for (var idx in response.messages) {
//console.log(response.messages);
gmail.users.messages.get({
auth: o2c,
userId: 'me',
id: response.messages[idx].id,
format: 'metadata',
metadataHeaders: ['From', 'Subject', 'Date']
}, function(err, gmailres){
var fromfield, subjectfield, datefield;
if(err)
console.log(err);
if(gmailres.labelIds == 'undefined'||gmailres.labelIds == '');
//console.log('labels are');
//console.log(gmailres.labelIds);
//console.log(gmailres.labelIds.length);
if(gmailres.labelIds != 'undefined') {
if (gmailres.labelIds.indexOf('INBOX') > -1) {
for (var i = 0; i < 3; i++) {
if (gmailres.payload.headers[i].name == 'From')
fromfield = gmailres.payload.headers[i].value;
else if (gmailres.payload.headers[i].name == 'Subject')
subjectfield = gmailres.payload.headers[i].value;
else if (gmailres.payload.headers[i].name == 'Date')
datefield = gmailres.payload.headers[i].value;
}
maillist.push({
id: ++msgid,
msgid: gmailres.id,
folder: '1',
from: fromfield,
subject: subjectfield,
date: datefield,
prevpage: page_token,
nextpage: response.nextPageToken
});
}
}
if(++itemproc==response.messages.length)
cb(maillist);
});
}
});
};
var sendMessages = function(o2c,email,cb){
var gmail = google.gmail('v1');
var base64EncodedEmail = new Buffer(email).toString('base64');
base64EncodedEmail = base64EncodedEmail.replace(/\+/g, '-').replace(/\//g, '_');
console.log(base64EncodedEmail);
gmail.users.messages.send({
auth:o2c,
userId:'me',
resource:{
raw:base64EncodedEmail
}
},function(err,result){
if(err)
console.log("error"+err);
console.log(result);
cb(err,result);
});
}
var deleteMessages = function(o2c,msgid,cb){
var gmail = google.gmail('v1');
gmail.users.messages.delete({
auth:o2c,
userId:'me',
'id':msgid
},function(err,result){
if(err)
console.log(err);
console.log(result);
cb(err,result);
})
}
app.get("/inbox", function(req, result) {
log("In Inbox");
//var url = "https://q.nqminds.com/v1/datasets/HJlxrOl0d/data";
// https.get(url, function(res){
// var body = '';
// res.on('data',function(chunk){
// body += chunk;
// });
// res.on('end',function(){
// var cbresponse = JSON.parse(body);
// console.log('get response end');
// console.log(cbresponse['data']);
// result.render('inbox', { messages:cbresponse['data'] });
// })
// });
///*
getMessages(oauth2Client, '0', 0, function(maillist){
result.render("inbox", { messages: maillist });
});
//*/
});
app.get("/page/", function(req, res){
console.log("GET /page/ *******");
getMessages(oauth2Client, req.url.substr(CMD_GET_PAGE.length), 0, function(maillist){
res.end({messages: maillist});
});
});
app.get(/message/, function(req, res){
console.log("GET /message/ ********");
var gmail = google.gmail('v1');
gmail.users.messages.get({
auth: oauth2Client,
userId: 'me',
id: req.url.substr(CMD_GET_MSG.length),
format: 'full'
}, function(err, gmailres){
var htmlcode = getBody(gmailres.payload);
if (htmlcode=='')
res.end("Error parsing.");
else res.end(htmlcode);
});
});
app.post("/send",function(req,res,next){
console.log(req.body.message);
console.log(req.body.content);
var message = req.body.message;
var content = req.body.content;
var email = [];
message = JSON.parse(message);
content = JSON.parse(content);
email.push("From: \"bingjie\" <*****@*****.**>");
email.push("To: "+message["To"]);
email.push("Cc: "+message["Cc"]);
email.push('Content-type: text/html;charset=iso-8859-1');
email.push('MIME-Version: 1.0');
email.push("Subject: "+message['Subject']);
email.push("");
email.push(content.html);
email = email.join('\r\n').trim();
console.log(email);
sendMessages(oauth2Client,email,function(err,result){
if(err)
consold.log(err);
else
res.send('SUCCESS');
});
});
app.post("message",function(req,res,next){
var msgid = req.query.id;
console.log('reply mesgid is=>'+req.query.id);
var message = req.body.message;
var content = req.body.content;
var email = [];
message = JSON.parse(message);
content = JSON.parse(content);
email.push("From: \"bingjie\" <*****@*****.**>");
email.push("To: "+message["To"]);
email.push("Cc: "+message["Cc"]);
email.push('Content-type: text/html;charset=iso-8859-1');
email.push('MIME-Version: 1.0');
email.push("Subject: "+message['Subject']);
email.push("In-Reply-To: "+msgid);
email.push("");
email.push(content.html);
email = email.join('\r\n').trim();
console.log(email);
sendMessages(oauth2Client,email,function(err,result){
if(err)
console.log(err);
console.log(result);
})
})
app.delete(/message/,function(req,res,next){
var message_id = req.url.substr(CMD_GET_MSG.length);
var id = req.query.id;
console.log('delete message =>'+message_id);
console.log('delete query id is => '+id);
deleteMessages(oauth2Client,req.query.id,function(err,result){
console.log(result);
})
res.send('delete message id=>'+message_id);
})
app.get("/login",function(req,res,next){
res.render("login");
});
app.get(/oauth2callback/,function(req,res,next){
var oauthCode = req.query.code;
console.log(req.query.code);
// Set the headers
var headers = {
'User-Agent': 'HTTP/1.1',
'Content-Type': 'application/x-www-form-urlencoded'
};
// Configure the request
var options = {
url: 'https://www.googleapis.com/oauth2/v4/token?',
method: 'POST',
headers: headers,
qs: {
'grant_type':'authorization_code',
'code': oauthCode,
'client_id': '34234327356-ouiojrg05qps9sp0dtgca5mmo9r3n8e5.apps.googleusercontent.com',
'client_secret':'sydN50rSG6lAroDaldB84wCa',
'redirect_uri':'http://localhost:3000/oauth2callback',
'response_type':'token'
}
};
console.log(options)
gRequest(options,function(err,result,body){
if(err)
console.log(err);
else {
console.log(body);
storeToken(JSON.parse(body));
fs.readFile('client_secret.json', function processClientSecrets(err, content) {
if (err) {
log('Error loading client secret file: ' + err);
return;
}
log("client_secrets.json Loaded.");
authorize(JSON.parse(content));
console.log('read end');
});
console.log('end');
res.redirect('/inbox');
}
})
})
var server = app.listen(3000, function () {
var host = server.address().address;
var port = server.address().port;
console.log('Example app listening at http://%s:%s', host, port);
});
};
return AppProcess;
}())
function readFiles(){
fs.readFile('/etc/passwd', this);
},
MongoClient.connect('mongodb://127.0.0.1:27017/baltimorevacants', function(err1, db) {
if (err1) throw err1;
var collection = db.collection('property');
var queue = [],
x = 0;
fs.readFile('./data/parcels.geojson', 'utf-8', function(err2, contents) {
var data = JSON.parse(contents),
len = data.features.length;
//console.log(len);
for (var i = 0; i < len; i++) {
//console.log(data.features[i].properties.PIN);
queue.push(data.features[i]);
}
queue.push({
done: true
});
async.eachSeries(queue, function(data, callback) {
if (data.done) {
console.log('done');
setImmediate(function() {
callback();
});
} else {
//console.log(data.properties.PIN);
collection.findOne({
_id: data.properties.PIN
}, function(err, result) {
//console.log('result of find being processed');
if (err) {
console.log(err);
setImmediate(function() {
callback();
});
} else {
//console.log('result of find has no error');
if (data.geometry && data.properties.FULLADDR != '0' && data.properties.FULLADDR != null) {
// lets find out if the geometry is valid (ish)
var coords = data.geometry.coordinates,
coordlen = data.geometry.coordinates.length;
//console.log('First geom lats:',geom[0][0], geom[geomlen-1][0]);
//console.log('First geom lngs:',geom[0][1], geom[geomlen-1][1]);
for (var i = 0; i < coordlen; i++) {
var geom = coords[i],
geomlen = geom.length;
if (geom[0][0] != geom[geomlen - 1][0] || geom[0][1] != geom[geomlen - 1][1]) {
console.log('Start and end are not the same.');
data.geometry.coordinates[i].push(geom[0]);
}
}
/*if (coordlen > 1) {
console.log("found a ", "MultiPolygon", coordlen);
data.geometry.type = "MultiPolygon";
}*/
if (result != null) {
console.log('Updating existing property for ' + data.properties.PIN);
result.geometry = data.geometry;
result.properties.lot_area = data.properties.SHAPE_Area;
if (!test) {
collection.update({
_id: data.properties.PIN
}, result, function() {
setImmediate(function() {
callback();
});
});
} else {
setImmediate(function() {
callback();
});
}
} else {
if (result == null) {
console.log('No property exists yet, adding one for ' + data.properties.PIN);
var entry = {
_id: data.properties.PIN,
properties: {
block: data.properties.BLOCKNUM,
lot: data.properties.PARCELNUM,
property_address: data.properties.FULLADDR,
lot_area: data.properties.SHAPE_Area
},
geometry: data.geometry
};
if (!test) {
collection.insert(entry, {
w: 1
}, function(err, result2) {
if (err) {
console.log(err);
} else {
console.log(result2[0].block + ', ' + result2[0].lot);
}
setImmediate(function() {
callback();
});
});
} else {
setImmediate(function() {
callback();
});
}
} else {
console.log('Result is something else : ' + result);
setImmediate(function() {
callback();
});
}
}
}
}
});
}
});
});
});
function readFiles(){
fs.readFile('/etc/passwd', this.parallel());
fs.readFile(__filename, this.parallel());
},
extraction.stdout.on('close', () => {
fs.readFile(tmpPath + basename(this.filepath) + '.txt', 'utf-8', (err, content) => {
resolve(content);
});
});
var express = require('express');
var logger = require('morgan');
var fs = require('fs');
var app = express();
var txt;
fs.readFile('./index.html','utf-8', function(err,data) {
if (err){
return console.log(err);
}
console.log("Read file");
txt = data.toString('utf-8');
});
app.get('/', function(request, response){
response.send(txt);
});
var port = process.env.PORT || 5000;
app.listen(port, function(){
console.log("I am Listening on " + port);
});