userMgr.findProviderByUserId(userId, TUMBLR_PROVIDER, undefined, function (err, user, provider) {
if (err) {
log.error(err, meta);
return res.status(500).send(err);
}
var client = tumblr.createClient({
consumer_key: clientConfig.clientID,
consumer_secret: clientConfig.clientSecret,
token: provider.token,
token_secret: provider.tokenSecret
});
client.blogInfo(blog_id, function(error, response) {
if (error) {
log.error(error, meta);
res.status(400).send(error);
return;
}
var botPostCount;
try {
botPostCount = new botFormat.BotPostCount(TUMBLR_PROVIDER, response.blog.name, response.blog.posts);
}
catch(e) {
log.error(e, meta);
log.error(response, meta);
return res.status(500).send(e);
}
res.send(botPostCount);
});
});
process.nextTick(function () {
console.log('tumblr token: ' + token);
console.log('tumblr tokenSecret: ' + tokenSecret);
tumblrClient = tumblr.createClient({
consumer_key: secrets.TUMBLR_CONSUMER_KEY,
consumer_secret: secrets.TUMBLR_SECRET_KEY,
token: token,
token_secret: tokenSecret
});
console.log('tumblrClient:');
console.dir(tumblrClient);
console.log('profile:');
console.dir(profile);
// To keep the example simple, the user's Tumblr profile is returned to
// represent the logged-in user. In a typical application, you would want
// to associate the Tumblr account with a user record in your database,
// and return that user instead.
return done(null, profile);
});
constructor() {
this.client = tumblrLib.createClient({
consumer_key: credentials.tumblr.consumer_key,
consumer_secret: credentials.tumblr.consumer_secret,
token: credentials.tumblr.token,
token_secret: credentials.tumblr.token_secret
});
}
getCredential('tumblr_consumer_secret', l(function (consumerSecret) {
console.log('Creating tumblr client');
var credentials = {
consumer_key: consumerKey,
consumer_secret: consumerSecret,
token: token.token,
token_secret: token.secret
};
console.log('Tumblr credentials: ' + JSON.stringify(credentials));
cb(null, tumblr.createClient(credentials));
}));
fetchPosts(acct, res){
var tumblr = Tumblr.createClient(this.makeCredentials(acct))
tumblr.posts(acct.get('username'), (err, resp) => {
if(err) res.status(500).send(JSON.stringify(err))
else{
var items = resp.posts.map(post => this.makeItem(post,acct.get('username')))
res.send(JSON.stringify(items))
}
})
}
function reply(post, index){
var twitter = new Twitter(config.twitter);
var client = tumblr.createClient(config.tumblr[index]);
client.posts(post.blog_name+'.tumblr.com', {id: post.id, notes_info: 'True'}, function(err,r){
if(err){
console.error(err);
return;
}
if(!r){
return;
}
var postData = r.posts[0];
var notes = postData.notes;
if(notes){
if(notes.length == 0 && notes[0] && notes[0].blog_name == post.blog_name){
return;
}
for(i=0;i<notes.length;i++){
if(config.tumblrAccounts.indexOf(notes[i].blog_name) !== -1){
return;
}
}
}else{
return;
}
if(config.blacklist.indexOf(post.blog_name) !== -1){
return;
}
if(countInArray(usernameCacheProtection, post.blog_name) > 4){
return;
}
var comment = config.responses[Math.floor(Math.random()*config.responses.length)].replace('{{username}}', '@'+post.blog_name);
client.reblog(config.tumblrAccounts[index]+'.tumblr.com', { id: post.id, reblog_key: post.reblog_key, comment: comment }, function (err, data) {
if(err){
if(config.tumblr[index+1]){
return reply(post, index+1);
}else{
return;
}
}
usernameCacheProtection.push(post.blog_name);
console.log("[TumblrBot "+index+"] Successfully Replied to "+post.blog_name)
var status = '"'+config.responses[Math.floor(Math.random()*config.responses.length)]+'" '+post.short_url;
var finalStatus = status.replace('{{username}}', post.blog_name);
twitter.post('statuses/update', {status: finalStatus}, function(error, response, body){});
});
})
};
userMgr.findProviderByUserId(userId, TUMBLR_PROVIDER, undefined, function (err, user, provider) {
if (err) {
log.error(err, meta);
return res.status(500).send(err);
}
var client = tumblr.createClient({
consumer_key: clientConfig.clientID,
consumer_secret: clientConfig.clientSecret,
token: provider.token,
token_secret: provider.tokenSecret
});
var options = {id: post_id, reblog_info: true, notes_info: true};
client.posts(blog_id, options, function (error, response) {
if (error) {
log.error(error, meta);
res.status(400).send(error);
return;
}
var botPostList;
try {
botPostList = new botFormat.BotPostList(TUMBLR_PROVIDER, response.blog.name);
_pushPostsFromTumblr(botPostList.posts, response.posts, 0);
}
catch(e) {
log.error(e, meta);
log.error(response, meta);
return res.status(500).send(e);
}
if (botPostList.posts.length > 0 && botPostList.posts[0].type === 'link') {
blogBot.getTeaser(botPostList.posts[0].contentUrl, function (err, botTeaser) {
if (err) {
log.error(err, meta);
}
else {
botPostList.posts[0].teaser = botTeaser;
}
res.send(botPostList);
});
}
else {
res.send(botPostList);
}
});
});
exports.getTumblr = function(req, res) {
var token = _.findWhere(req.user.tokens, { kind: 'tumblr' });
var client = tumblr.createClient({
consumer_key: secrets.tumblr.consumerKey,
consumer_secret: secrets.tumblr.consumerSecret,
token: token.accessToken,
token_secret: token.tokenSecret
});
client.posts('goddess-of-imaginary-light.tumblr.com', { type: 'photo' }, function(err, data) {
res.render('api/tumblr', {
title: 'Tumblr API',
blog: data.blog,
photoset: data.posts[0].photos
});
});
};
app.get('/api/tumblr', passportConf.isAuthenticated, passportConf.isAuthorized, function (req, res) {
var token = _.find(req.user.tokens, { kind: 'tumblr' });
var client = tumblr.createClient({
consumer_key: config.tumblr.key,
consumer_secret: config.tumblr.secret,
token: token.token,
token_secret: token.tokenSecret
});
client.posts('danielmoyerdesign.tumblr.com', { type: 'photo' }, function (err, data) {
res.render('api/tumblr', {
url: '/apilocked',
blog: data.blog,
photoset: data.posts[0].photos
});
});
});
exports.getTumblr = function(req, res, next) {
var token = _.find(req.user.tokens, { kind: 'tumblr' });
var client = tumblr.createClient({
consumer_key: secrets.tumblr.consumerKey,
consumer_secret: secrets.tumblr.consumerSecret,
token: token.accessToken,
token_secret: token.tokenSecret
});
client.posts('withinthisnightmare.tumblr.com', { type: 'photo' }, function(err, data) {
if (err) return next(err);
res.render('api/tumblr', {
title: 'Tumblr API',
blog: data.blog,
photoset: data.posts[0].photos
});
});
};
exports.getTumblr = (req, res, next) => {
const token = req.user.tokens.find(token => token.kind === 'tumblr');
const client = tumblr.createClient({
consumer_key: process.env.TUMBLR_KEY,
consumer_secret: process.env.TUMBLR_SECRET,
token: token.accessToken,
token_secret: token.tokenSecret
});
client.posts('mmosdotcom.tumblr.com', { type: 'photo' }, (err, data) => {
if (err) { return next(err); }
res.render('api/tumblr', {
title: 'Tumblr API',
blog: data.blog,
photoset: data.posts[0].photos
});
});
};
function fetchTumblrData(){
console.log("[TumblrBot] Fetching Tumblr Data")
for(i=0;i<config.terms.length;i++){
var searchClient = tumblr.createClient(config.tumblr[0])
searchClient.tagged(config.terms[i], function (err, data) {
if(err){
console.error(err);
return;
}
if(!data){
console.error("No data found?");
return;
}
for(i=0;i<data.length;i++){
reply(data[i], 0)
}
});
}
}
userMgr.findProviderByUserId(userId, TUMBLR_PROVIDER, undefined, function (err, user, provider) {
if (err) {
log.error(err, meta);
return res.status(400).send(err);
}
var client = tumblr.createClient({
consumer_key: clientConfig.clientID,
consumer_secret: clientConfig.clientSecret,
token: provider.token,
token_secret: provider.tokenSecret
});
var options;
if (offset) {
var start_index = offset.split("-")[0];
log.debug('offset=' + start_index, meta);
options = {offset: start_index};
}
client.posts(blog_id, options, function (error, response) {
if (error) {
log.error(error, meta);
res.status(400).send(error);
return;
}
var botPostList;
try{
botPostList = new botFormat.BotPostList(TUMBLR_PROVIDER, response.blog.name);
_pushPostsFromTumblr(botPostList.posts, response.posts, after);
}
catch(e) {
log.error(e, meta);
log.error(response, meta);
return res.status(400).send(e);
}
res.send(botPostList);
});
});
function Tumburglar(credentials, options) {
var blog;
var requestIncrement = 20;
// We need API key credentials to make any useful requests
if (credentials) {
this.credentials = credentials;
this.client = tumblr.createClient({
consumer_key: credentials.consumerKey,
consumer_secret: credentials.consumerSecret
});
}
this.options = {
verbose: false
};
if (options) this.options = _.extend(this.options, options);
return this;
}
userMgr.findProviderByUserId(userId, TUMBLR_PROVIDER, providerId, function (err, user, provider) {
if (err) {
log.error(err, meta);
return res.status(500).send(err);
}
var client = tumblr.createClient({
consumer_key: clientConfig.clientID,
consumer_secret: clientConfig.clientSecret,
token: provider.token,
token_secret: provider.tokenSecret
});
client.userInfo(function (error, response) {
if (error) {
log.error(error, meta);
return res.status(400).send(error);
}
//log.debug(response, meta);
var botBlogList = new botFormat.BotBlogList(provider);
try {
var blogs = response.user.blogs;
log.debug('blogs length=' + blogs.length, meta);
for (var i = 0; i < blogs.length; i+=1) {
var botBlog = new botFormat.BotBlog(blogs[i].name, blogs[i].title, blogs[i].url);
botBlogList.blogs.push(botBlog);
}
}
catch(e) {
log.error(e, meta);
log.error(response, meta);
return res.status(500).send(e);
}
res.send(botBlogList);
});
});
userMgr.findProviderByUserId(userId, TUMBLR_PROVIDER, undefined, function (err, user, provider) {
if (err) {
log.error(err, meta);
return res.status(500).send(err);
}
var client = tumblr.createClient({
consumer_key: clientConfig.clientID,
consumer_secret: clientConfig.clientSecret,
token: provider.token,
token_secret: provider.tokenSecret
});
client.posts(blogName, function (error, response) {
if (error) {
log.error(error, meta);
return res.status(400).send(error);
}
log.debug(response, meta);
res.send(response);
});
});
var imgDir = "./images";
var imgCount;
if (!fs.existsSync(imgDir+"/img_count"))
imgCount = 0;
else
imgCount = fs.readFileSync(imgDir+"/img_count", "utf8");
// start the cover generator
writeLog("\n Maggen is going!");
gossip.gossipForMaggen();
// Tumblr Stuff
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: 'Eo8NSAeATzYe8EUPYdWZWWUcH1tSJxaXo7QEmLrrEiQlpf0vV0',
consumer_secret: 'KhaJbJMXKa8W8i4tBeSVOqXvq5s1WREbLYEPfxn5nMadiQxnzr',
token: 'TnsBQlYwEmbc2hmh045fk0feB8MaON5XTG856TRhrzEkHnBFWK',
token_secret: '82f049y0qdD0p33rzHT9EXkhIEKbHXtWFXP6rZjfiOmNHQ4Mcs'
});
var MIN_FACE_WIDTH = 100
, MIN_FACE_HEIGHT = 100
, MIN_EDGE_DISTANCE = 150 // distance from edge of face detection to closest edge
, MAX_FACE_WIDTH = 500
, MAX_FACE_HEIGHT = 500
, COVER_WIDTH = 600 // width of the final image
, COVER_HEIGHT = 800 // hieght of the final image
, LOGO_COUNT = 6
, EXTRA_FEATURE_COUNT = 21
, LOGO_POS_X = 50
, LOGO_POS_Y = 30
var fs = require('fs');
var csvFile = fs.readFileSync("friend_list.csv","utf8");
var emailTemplate = fs.readFileSync('email_template.html', 'utf8');
var ejs = require('ejs');
var tumblr = require('tumblr.js');
var mandrill = require('mandrill-api/mandrill');
var mandrill_client = new mandrill.Mandrill(/*key*/);
// Authenticate via OAuth
var client = tumblr.createClient({
// keys
});
function csvParse(csvFile) {
var contactList = csvFile.split("\n"); // split by each contact
var headers = contactList.splice(0, 1)[0].split(",");
var objArray = [];
for (var i = 0; i < contactList.length-1; i++) {
var contact = {};
var info = contactList[i].split(",");
for (var j = 0; j < info.length; j++) {
var key = headers[j];
io.emit('done', clicked);
}
io.emit('prompt', chosen);
io.emit('timer', [minutesLabel,secondsLable]);
}
http.listen(3000, function(){
console.log('listening on *:3000');
});
// Authenticate via OAuth
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: 'ItnfzBhYek1F8BIZ0wMaf8cznREXcZtW4BmAbVniCVl4W16IIP',
consumer_secret: 'ZgxK2r2GoQdW6HbadR9aH2lvK1Ac0ySxpQOLz4wiyIoZ9Xw4rd',
token: '7CLjVvn0XiuRqLTtlzMP6govNZkigBYvaKKw7AP9gqlHKczIKc',
token_secret: 'Q7ywytsG0iLAdfKiNcYSWyZkco67IBZ7jCtXPHWr7xRqoWwvJa'
});
function postStory(t, story) {
if (story == "" || story == null) {
story = "...";
}
client.text('we-story', { title: t,
body: story,
tweet: 'off',
format: 'markdown',
tags: 'story'}, function(err, success) {
console.log("success");
});
var fs = require("fs");
var ejs = require("ejs");
// Authenticate via OAuth
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: '',
consumer_secret: '',
token: '',
token_secret: ''
});
var mandrill = require('mandrill-api/mandrill');
var mandrill_client = new mandrill.Mandrill('');
// Make the request
client.userInfo(function (err, data) {
// ...
});
var emailTemplate = fs.readFileSync("email_template.ejs", "utf8");
var csvFile = fs.readFileSync("friend_list.csv", "utf8");
var contacts = csvParse(csvFile);
getLatestPosts();
// parse the csv file
function csvParse(csv) {
var result = [];
var lines = csv.split("\n");
for (var r = 1; r < lines.length; r++) {
module.exports = function(cli) {
const options = {
blog: cli.b,
credentials: cli.c,
limit: cli.l,
type: cli.postType,
tag: cli.postTag,
id: cli.postId,
source: cli.s
}
requiredOptions.forEach(option => {
if (!options[option]) {
throw `Option '${option}' required.`
}
})
const tumblr = tumblrJs.createClient({
credentials: options.credentials,
returnPromises: true
});
let params = getInitialParams(options);
let offset = 0;
let countLeft = options.limit;
let n = 0;
// Tumblr may provide duplicates handling offset
// especially with 'tag' filter option
let dedupHash = {};
// need to accumulate posts first, because processor func could
// remove posts cause broken listing
let postsQueue = [];
async function stream (processor) {
if (typeof processor !== 'function') {
throw 'Processor function param required.';
}
while (true) {
let limit = Math.min(sliceSize, countLeft);
let slice = await tumblr[sourceMethod[options.source]](
options.blog,
Object.assign(params, {offset, limit})
);
let sliceLength = slice.posts.length;
console.log(`Requested ${limit} posts starting from ${offset}`);
let dedupCount = 0;
if (sliceLength) {
slice.posts.forEach(post => {
if (!dedupHash[post.id]) {
dedupHash[post.id] = true;
postsQueue.push(post);
dedupCount++;
}
});
}
countLeft -= sliceLength;
offset += sliceLength;
if (isFinite(countLeft) ? countLeft <= 0 || !dedupCount : !dedupCount) {
break;
}
}
console.log('Total post queued for processing: ' + postsQueue.length);
if (postsQueue.length) {
let n = 0;
for (let post of postsQueue) {
await processor.call({tumblr}, post, n++);
}
}
}
return {
get options () {
return Object.assign({}, options);
},
get params () {
return Object.assign({}, params);
},
stream
}
}
var env = require('dotenv')
var Twitter = require('twitter')
var Tumblr = require('tumblr.js')
env.load()
var twitter = new Twitter({
consumer_key: process.env.TWITTER_CONSUMER_KEY,
consumer_secret: process.env.TWITTER_CONSUMER_SECRET,
access_token_key: process.env.TWITTER_ACCESS_TOKEN_KEY,
access_token_secret: process.env.TWITTER_ACCESS_TOKEN_SECRET
})
var client = Tumblr.createClient({
consumer_key: process.env.TUMBLR_CONSUMER_KEY,
consumer_secret: process.env.TUMBLR_CONSUMER_SECRET,
token: process.env.TUMBLR_TOKEN,
token_secret: process.env.TUMBLR_TOKEN_SECRET
})
function postToSlack(message) {
request
.post(process.env.SLACK_WEBHOOK)
.send({text: message})
.set('Content-Type', 'application/json')
.end(function(err, res) {
if (err) {
console.log("Slack Error: ", err)
} else {
console.log("Hit Slack")
// console.log("Successfully sent slack message", message)
}
constructor (opts) {
this.client = tumblr.createClient(opts)
}
request.get(url, function(err, response, body) {
// If the content API returns an error, respond to the webhook with an error.
if (err) {
res.send(err, 500);
}
// Parse the Content API response into Javascript
var content = JSON.parse(body);
// Create a Tumblr client instance
var client = tumblr.createClient({
consumer_key: process.env.TUMBLR_CONSUMER_KEY,
consumer_secret: process.env.TUMBLR_CONSUMER_SECRET,
token: process.env.TUMBLR_OAUTH_TOKEN,
token_secret: process.env.TUMBLR_OAUTH_SECRET
});
// Depending on whether we're publishing (new or edited), or
// retracting a post, call the appropriate method on the
// tumblr client instance.
if (event === "publish" && content.published_id) {
// The Content API response contained a "published_id" value
// which gets set when we first publish a post to tumbler.
// therefore, let's edit that post.
client.edit(process.env.TUMBLR_BLOG_NAME, {
id: content.published_id,
title: content.heading,
body: content.content,
state: "published"
}, function(err, data) {
var webhook_response = {
published_id: data.id
};
res.send(webhook_response, 200);
});
} else if (event === "publish") {
// Create a new post
client.text(process.env.TUMBLR_BLOG_NAME, {
title: content.heading,
body: content.content,
state: "published"
}, function(err, data) {
// Return the Tumblr post id back to Camayak
// so it will get sent in any subsequent API
// responses and we can use it to edit or retract
var webhook_response = {
published_id: data.id
};
res.send(webhook_response, 200);
});
} else if (event === "retract" && content.published_id) {
// If we're retracting, make the post offline by setting
// the status in Tumblr to "private". This way, we can
// make it live again if we want.
client.edit(process.env.TUMBLR_BLOG_NAME, {
id: content.published_id,
state: 'private'
}, function(err, data) {
var webhook_response = {
published_id: data.id
};
res.send(webhook_response, 200);
});
} else {
// Something unusual happened. For instance, a retract event
// with no published_at.
res.send(500);
};
});
arrayOfObjects.push(newObj);
})
return arrayOfObjects;
}/////////////////////////end of csvParse function
var friendList = csvParse(csvFile); //get array of contacts
//Tumbler API
// Authenticate via OAuth
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: 'Z6Mv14vBMoBpXp9SagfYvAp3C4qw6ZgDOt6YR6yWJFcxtUzDlT',
consumer_secret: 'DSQElw5iCJsl783aIvnZ1xexhmcdtYy540fesFvqGzQhGIKSx1',
token: '3q1gbV8fm3g6C3wIYIPB3ffp5Ajwdv9sPXoVB4b4Tv0BBeIWis',
token_secret: 'RhD0WSrYWEop0lTJpj8TOj4e0EU7oHaL1Oc2KcKTDlBFQFbtnh'
});
client.posts('jsflow.tumblr.com', function(err, blog){
var latestPosts = []; //array to store posts
var pastWeek= moment().subtract(7,'days').calendar(); //used Moment to get date from week ago.
//iterate through each blog post
blog.posts.forEach(function(post){
var postWritten=moment(post.date,'YYYY-MM-DD hh:mm:ss');
// code to test if it is a week old, if less than week old, push it in the latestPost array.
if (moment(postWritten).isAfter(pastWeek)){
latestPosts.push(post);
}
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: 'HVTTfY2BZe3wKULcwGqAs8o4foLihYiGrewWhOF32Q81i66I2Q',
consumer_secret: 'LQAPmknyimqIa4k79LMKWQkvOkeUdLcxlFo6MtApzzYah1DlRd',
token: 'Rh0wGtJYEVXVNEaGfpZUzGJTzZ8VLa91apnhjZNd1iXuuvsD6k',
token_secret: 'ANe4xXLSzhsIgQno7VHiPOJfQEylKmuPzbz4vEQRGXfSv8vXGG'
});
client.posts("theolipeles.tumblr.com", function(err, blog){
console.log(blog);
})
const express = require('express');
const proxy = require('express-http-proxy');
const util = require('util');
const WebpackDevServer = require('webpack-dev-server');
const webpack = require('webpack');
const webpackConfig = require('./webpack.config');
const credentials = require('./credentials.json');
const tumblr = require('tumblr.js');
const client = tumblr.createClient(credentials);
// Frontend server
const server = new WebpackDevServer(webpack(webpackConfig), {
contentBase: '/public',
hot: true,
compress: true,
stats: {
colors: true,
},
proxy: {
'/': {
target: 'http://localhost:8080',
secure: false,
},
'/posts': {
target: 'http://localhost:8080',
secure: false,
},
},
});
var fs = require('fs');
var ejs = require('ejs');
var mandrill = require('mandrill-api/mandrill');
var mandrill_client = new mandrill.Mandrill('DYyv-jfQlNoYKOJu0okUBg');
var csvFile = fs.readFileSync("friend_list.csv","utf8");
var emailTemplate = fs.readFileSync('email_template.ejs', 'utf-8');
var tumblr = require('tumblr.js');
var client = tumblr.createClient({
consumer_key: 'RCNp0AWuwr1w36cSF1lu72FNh4v0jE6mq8VIfaVuMGinVW2l7G',
consumer_secret: '1k7W0k2lBfdaZJ76DkjDR1TakW7L01XwzqfPhwGKUp5rXbE8gJ',
token: '88swWdV4jLSDSGFRjviF0gzOR8UftMW5GOLufy9jaq4tqc1d15',
token_secret: 'G0lTdrnVrsKaR3J0XIv88HRXvMV99bEs4zheADB4MYG1Sa15ID'
});
var csvParse = function(csv){
var answer = [];
var split = csv.split("\n");
var columns = split.shift().split(",");
split.forEach(function(contact){
var contactProp = contact.split(",");
var newObj = {};
for(var k = 0; k < columns.length; k++){
newObj[columns[k]] = contactProp[k];
}
answer.push(newObj);
});
return answer;
var sqlite3 = require("sqlite3").verbose() //is there a way to only condiitonally include this as all users won't need it?
//var diskspace = require('diskspace')
// Parameters:
// -tumblrName (required)
// -diskSpaceMinimum (optional)
// -sqliteDatabaseFile (optional)
// -mariaHost, mariaUser, mariaPassword, mariaDatabase (optional) but all are needed for successful connection
// -mariaClient - instantiated mariaDB connection
function TumblrConnection(parameters){
this.tumblrName=parameters['tumblrName']
if (typeof parameters['tumblrName'] === 'undefined'){
throw Error('Missing required parameter: tumblrName.');
}
this.tumblrURL=this.tumblrName+".tumblr.com" //naive url grabbing
if ( typeof process.env.TUMBLR_CONSUMER_KEY !== 'undefined'
&& typeof process.env.TUMBLR_SECRET_KEY !== 'undefined'
&& typeof process.env.TUMBLR_TOKEN !== 'undefined'
&& typeof process.env.TUMBLR_TOKEN_SECRET!== 'undefined'
){
this.client = tumblr.createClient({
consumer_key: process.env.TUMBLR_CONSUMER_KEY,
consumer_secret: process.env.TUMBLR_SECRET_KEY,
token: process.env.TUMBLR_TOKEN,
token_secret: process.env.TUMBLR_TOKEN_SECRET
});
} else {
throw Error("Missing one or more Tumblr Api keys")
}
// disk space minimum in gigabytes to check for and key off of
// this really belongs in a parent class along with the mariadb connection as it doesn't change on a per username basis
this.diskSpaceMinimum = (parameters['diskSpaceMinimum']) ? parameters['diskSpaceMinimum']*1000000000 : 1000000000
this.checkDiskSpace()
// file specifiying the sqlite database
this.sqliteDatabaseFile = (parameters['sqliteDatabaseFile']) ? parameters['sqliteDatabaseFile'] : ''
// sqlite database connector variable
if(this.sqliteDatabaseFile !== ''){
// console.log(this.sqliteDatabaseFile)
this.sqliteDB = new sqlite3.Database(this.sqliteDatabaseFile)
// console.log(this.sqliteDB)
// this.sqliteDB = {}
} else {
// console.log("sqliteDB not initialized")
}
// mariadb parameters
if (parameters['mariaHost']
&& parameters['mariaUser']
&& parameters['mariaPassword']
&& parameters['mariaDatabase'] ) {
//console.log("setting up maria")
var that = this;
this.mariaHost = parameters['mariaHost']
this.mariaUser = parameters['mariaUser']
this.mariaPassword = parameters['mariaPassword']
this.mariaDatabase = parameters['mariaDatabase']
this.mariaClient = new mariasql()
this.mariaClient.connect({host:this.mariaHost,
user:this.mariaUser,
password:this.mariaPassword,
db:this.mariaDatabase})
this.mariaClient.on('connect', function() {
//console.log('Client connected');
})
.on('error', function(err) {
console.log('Client error: ' + err);
})
.on('close', function(hadError) {
console.log('Client closed');
});
}
//maria client passed in to prevent too many connections being made
// if (typeof parameters['mariaClient'] !== 'undefined'){
if (parameters['mariaClient']){
process.stdout.write("using mariaclient")
this.mariaClient = parameters['mariaClient']
}
}
}
// load bot config
console.log('requiring config in file: ' + process.argv[2]);
var config = require(process.argv[2]);
// primary bot config
var bot_name = config.bot_name;
// init new instance of the slack real time client
// second param is autoReconnect, which seems to be broken, so setting to FALSE
var slack = new slack_client(config.api_token, false, false);
var tumblr = tumblr_client.createClient({
consumer_key: config.tumblr_consumer_key,
consumer_secret: config.tumblr_consumer_secret,
token: config.tumblr_token,
token_secret: config.tumblr_token_secret
});
slack.on('open', function() {
console.log(bot_name + ' is online, listening...');
connected = true;
});
slack.on('error', function(err) {
console.error('there was an error with slack: ');
console.error(err);
});
slack.on('message', function(message) {