Onekin.Euskotren.init = function(){
// Create slack bot instance
Onekin.Euskotren.slackbotController = Botkit.slackbot();
// Retrieve slack bot token from properties file
var properties = PropertiesReader('configuration.properties');
Onekin.Euskotren.bot = Onekin.Euskotren.slackbotController.spawn({
token: properties.get('onekin.slack.token')
});
Onekin.Euskotren.bot.startRTM(function(err,bot,payload) {
if (err) {
throw new Error('Could not connect to Slack');
}
});
// Retrieve stations name and code correspondence
Onekin.Euskotren.stations = {};
request('http://www.euskotren.eus/es/horarios', function(error, response, html){
if(!error){
let $ = cheerio.load(html);
$('#edit-destino').find('option').each((id, val) => {
let stationCode = val.attribs.value;
if(stationCode){
let stationName = val.children[0].data;
Onekin.Euskotren.stations[stationName.toLowerCase()] = stationCode;
}
});
}
});
};
exports.loadProperties = function(filename) {
try {
properties = propertiesReader(filename);
}
catch(err) {
}
}
async function main(argv) {
const script = require(argv[2]);
const nightmare = Nightmare(script.nightmare_props);
let atlasLoginInfo = {};
let chartsLoginInfo = {};
if (argv[3] !== undefined) {
const properties = PropertiesReader(argv[3]);
atlasLoginInfo = {
username: properties.get('atlasUser.login.username'),
password: properties.get('atlasUser.login.password')
}
chartsLoginInfo = {
email: properties.get('chartsUser.login.email'),
password: properties.get('chartsUser.login.password')
}
}
const screenshotNames = await script.run({
nightmare: nightmare,
screenshot_dir: './screenshots-temp/',
loginToAtlas: function() {
nightmare.goto('https://cloud.mongodb.com/user#/atlas/login')
nightmare.wait('input[name="username"]');
if (atlasLoginInfo.username && atlasLoginInfo.password) {
nightmare.type('input[name="username"]', atlasLoginInfo.username);
nightmare.type('input[name="password"]', atlasLoginInfo.password);
}
else {
throw new Error("No login information specified");
}
nightmare.click('.login-form-submit-button');
},
loginToCharts: function() {
nightmare.goto('http://charts.mongodb.parts/login')
nightmare.wait('input#email');
if (chartsLoginInfo.email && chartsLoginInfo.password) {
nightmare.type('input#email', chartsLoginInfo.email);
nightmare.type('input#password', chartsLoginInfo.password);
}
else {
throw new Error("No login information specified");
}
nightmare.click('[data-test-id="login-form-submit-button"]');
}
});
// Compare the images
for (const image of screenshotNames) {
await util.compareImages(image);
}
}
function readApiOptions() {
var options = null;
var propertiesFile = appRoot + '/atsd.properties';
logger.info('API', 'Using properties file: %j', propertiesFile);
try {
if (checkPath(propertiesFile)) {
var properties = PropertiesReader(propertiesFile);
options = {
url: properties.get('atsd.url'),
user: properties.get('atsd.user'),
password: properties.get('atsd.password')
};
return options;
}
} catch (e) {
logger.info('Error', 'Error on reading api properties %j', e);
throw e;
}
return options;
}
//
// Contains server configuration.
//
'use strict';
var gFs = require('fs');
var gPropertiesReader = require('properties-reader');
var properties = gPropertiesReader(process.env.configFileLocation);
// Construct configuraiton object.
module.exports = {
'frontend': {
'port': properties.get('frontend.webserver.port')
},
'storage': {
'pipelines': properties.get('storage.pipelines.directory').replace('\\:', ':'),
'components': properties.get('storage.components.directory').replace('\\:', ':'),
'domain': properties.get('domain.uri'),
'jarPathPrefix' : properties.get('storage.components.path.prefix')
},
'executor': {
'monitor': {
'url': properties.get('executor-monitor.webserver.uri')
},
'ftp': {
'uri': properties.get('executor-monitor.ftp.uri')
}
}
};
exports.init = function(name, dir, options) {
var reset = options.reset,
extjsPath = options.extjs,
siestaPath = options.siesta,
extVersion = options.extversion,
appName = name,
dirName = dir,
ext4Src = 'http://cdn.sencha.com/ext/gpl/ext-4.2.1-gpl.zip',
ext5Src = 'http://cdn.sencha.com/ext/gpl/ext-5.1.0-gpl.zip',
extSrc,
siestaSrc = 'http://www.bryntum.com/download/?product_id=siesta-lite',
remove = (reset ? true : false),
directories = ['test', 'specification', 'webui', 'screenshots',
'screenshots/chrome', 'screenshots/firefox', 'screenshots/iexplorer'
],
success = true,
extProperties,
extZipPath, siestaZipPath;
if (extVersion) {
switch (extVersion) {
case '4':
extSrc = ext4Src;
break;
case '5':
extSrc = ext5Src;
break;
default:
logHandler.err('Wrong ExtJS version: ' + extVersion);
process.exit(1);
}
} else {
extSrc = ext5Src;
extVersion = '5';
}
if (!dirName) {
directories.forEach(function(directory) {
success = success && generator.createDirectoryTree(directory, [], remove);
});
dirName = '';
} else {
success = generator.createDirectoryTree(dirName, directories, remove);
dirName += '/';
}
if (success) {
extZipPath = dirName + 'ext.zip';
siestaZipPath = dirName + 'siesta.zip';
logHandler.finishLog('directories created');
generator.copyFile('gui.yml', mainDir + '/generator', dirName + 'specification');
try {
// ExtJS
if (!extjsPath) {
downloadFramework(extSrc, extZipPath, function() {
decompressFramework(extZipPath, dirName + 'webui', function() {
execute('mv * ./extSDK', dirName + 'webui', null, null, function() {
execute('sencha -sdk ./extSDK generate app ' + appName + ' .', dirName + 'webui',
'gui-tool project initialized', true);
});
});
});
} else {
execute('sencha -sdk ' + path.resolve(extjsPath) + ' generate app ' + appName + ' .', dirName + 'webui',
'gui-tool project initialized', true);
extProperties = PropReader(path.resolve(extjsPath) + '/version.properties');
extVersion = extProperties.get('version.major');
}
generator.processTemplate({
version: extVersion,
specification: 'gui.yml',
appname: appName
}, {
sourceBaseDir: templatePath + '/guitool',
targetBaseDir: './' + dirName,
template: 'guitool.json'
});
// Siesta
if (!siestaPath) {
downloadFramework(siestaSrc, siestaZipPath, function() {
decompressFramework(siestaZipPath, dirName + 'test', function() {
execute('mv * ./siesta', dirName + 'test');
});
});
} else {
execute('cp -r ' + siestaPath + ' ./test');
}
} catch (err) {
logHandler.err(err);
}
} else {
logHandler.err('directory contains already initialized gui-tool project!');
}
};
/**
* @since Dec 23, 2015 1:01:50 PM (creation date)
* @author Peter Withers <*****@*****.**>
*/
/*
* This script is intended to query the Frinex Designer webservice and build each experiment that has been set to the published state but has not yet been built.
*
* Prerequisites for this script:
* npm install request
* npm install maven
* npm install properties-reader
*/
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('publish.properties');
// var request = require('request');
var execSync = require('child_process').execSync;
// var http = require('http');
// var fs = require('fs');
//var configServer = properties.get('webservice.configServer');
var stagingServer = properties.get('staging.serverName');
var stagingServerUrl = properties.get('staging.serverUrl');
var stagingGroupsSocketUrl = properties.get('staging.groupsSocketUrl');
//var productionServer = properties.get('production.serverName');
//var productionServerUrl = properties.get('production.serverUrl');
//var productionGroupsSocketUrl = properties.get('production.groupsSocketUrl');
// it is assumed that git update has been called before this script is run
//buildFromListing = function () {
var aws = require('aws-sdk');
var redis = require("redis");
var crypto = require('crypto');
var express = require('express');
var PropertiesReader = require("properties-reader");
var router = express.Router();
//var redisClient = redis.createClient();
var properties = PropertiesReader('properties.file');
// properties
var AWS_ACCESS_KEY_ID = properties.get('aws.access.key');
var AWS_SECRET_ACCESS_KEY = properties.get('aws.secret.key');
var FACEBOOK_APP_ID = properties.get('facebook.app.id');
var FACEBOOK_ACCESS_TOKEN = properties.get('facebook.access.token');
var AWS_BUCKET_LOGS = properties.get('aws.s3.bucket.logs');
// set AWS configuration for future requests
aws.config.update({"accessKeyId": AWS_ACCESS_KEY_ID, "secretAccessKey": AWS_SECRET_ACCESS_KEY, "region": "eu-west-1"});
aws.config.apiVersions = {
dynamodb: '2012-08-10'
};
/* GET event. */
router.get('/events/:id', function(req, res, next) {
if (req.params.hub.mode == "subscribe") {
redisClient.get("facebookEvent#" + req.params.id, function (err, reply) {
if (reply != null && reply == req.query.hub.verify_token) {
// request is safe to come from Facebook - subscription confirmed
redisClient.del("facebookEvent#" + req.params.id);
res.send(req.params.hub.challenge);
var schedule = require('node-schedule');
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('default.properties');
var handbrakeAction = require('./handbrakeAction.js');
module.exports.scheduleJob = function () {
if (properties.get('auto.start') === true) {
console.log("Auto start!");
handbrakeAction.startJob(properties.get('videos.jobCount.que'));
} else {
var cronString = properties.get('jobTime.second') + " "
+ properties.get('jobTime.minute') + " "
+ properties.get('jobTime.hour') + " "
+ properties.get('jobTime.day.of.month') + " "
+ properties.get('jobTime.month') + " "
+ properties.get('jobTime.day.of.week');
console.log("starting job at " + cronString);
var j = schedule.scheduleJob(cronString, function () {
var targetFiles = handbrakeAction.gatherTargetFiles();
if (targetFiles.length < properties.get('videos.jobCount.max')) {
console.log("We're not backed up!");
return;
}
handbrakeAction.startJob(properties.get('videos.jobCount.que'));
});
}
};
var bodyParser = require('body-parser');
var cookieParser = require('cookie-parser');
var passPort = require('passport');
var localStrategy = require('passport-local').Strategy;
var session = require('express-session');
var async = require("async");
// Added by Srinivas Thungathurti for ASQ upgrade 2.0.
var mailer = require("nodemailer");
var propertiesReader = require("properties-reader");
var moment = require("moment");
var connectFlash = require('connect-flash');
var path = require('path');
var templatesDir = path.resolve(__dirname + '/views/templates');
var pageDir = path.resolve(__dirname + '/views/partials');
// Added by Srinivas Thungathurti for ASQ upgrade 2.0.
var properties = propertiesReader('applicationResources.file');
var crypto = require("crypto");
var app = express();
//Updated by Srinivas Thungathurti for moving hardcode port value to property file.
//var port = process.env.PORT || 1337;
var port = properties.get('process.env.port');
app.use(express.static(__dirname + '/views'));
//Updated by Srinivas Thungathurti for moving hardcode port value to property file.
//mongoose.connect('mongodb://localhost:27017/Quiz');
var mongodbUrl = properties.get('mongodb.connect.url');
console.log("mongoDB URL is "+mongodbUrl);
mongoose.connect(mongodbUrl);
var conn = mongoose.connection;
conn.on('error', console.error.bind(console, 'connection error:'));
conn.once('open', function() {
/**
* @author kokoweite <*****@*****.**>
* @file core_test.js
* 2015-10-21T7:28:00
*/
var assert = require('assert')
var Core = require('../app/js/objects/core')
var fs = require('fs')
var os = require('os')
var mkdirp = require('mkdirp')
var should = require('should')
var propertiesReader = require('properties-reader')
var properties = propertiesReader('secret.properties')
var bunyan = require('bunyan')
var botCore
before(function () {
mkdirp(os.homedir() + '/' + 'csfdcbot' + '/debug/test/log', function (err) {
if (err) {
console.error(err)
}
})
})
beforeEach(function () {
// Initialize logger
var log = bunyan.createLogger({
name: 'Unit Test',
streams: [
{
var path = require("path");
var fs = require("fs");
var vm = require("vm");
var myfile = path.join("www","index.html");
var cheerio = require("cheerio");
var PropertiesReader = require('properties-reader');
//rewriting to use https://www.npmjs.org/package/inquirer
var rl = require('inquirer');
//instantiate the properties reader ...
var properties = PropertiesReader(__dirname + '/text/cordova-jquery-npm.properties');
var builtInTemplates = PropertiesReader(__dirname + '/templates/built-in');
//prompt messages
var sureQuestion = properties.get('text.sureQuestion') ;
var whatNextPrompt = properties.get('text.whatNextPrompt');
var templatePromptMsg = properties.get('text.templatePromptMsg');
var externalPanelPromptMsg = properties.get('text.externalPanelPromptMsg');
var externalPanelPositionPromptMsg = properties.get('text.externalPanelPositionPromptMsg');
function cordovaJQuery() {
var fs = require('fs');
if(fs.existsSync(myfile) === false) {
console.log("File does not exist - " + myfile + " you must run cordova-jquery against a valid cordova project within the root directory. Exiting...");
return;
}
var content = fs.readFileSync(myfile, 'utf8');
$ = cheerio.load(content);
'use strict';
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('./config/server_info.properties');
var log = require('loglevel');
log.setLevel(properties.get('config.log_level'));
var dbManager = require('./models/dbManager.js');
var passEncrypt = require('./models/passEncrypt.js');
var msgTypes = require('./messageTypes.js');
var logger = require.main.require('./game/log/logger.js');
module.exports = function(app, passport, con) {
app.get('/', function(req, res) {
res.send('<h1>Hello world</h1>');
});
app.post('/', function(req, res) {
log.info(req.body);
var guid = req.body.guid;
switch(req.body.msgID) {
case msgTypes.C_LOGIN_REQUEST:
var inputPasswd = '';
var saltedPasswd = '';
if (req.body.password) {
inputPasswd = req.body.password;
} else {
// default password
inputPasswd = 'password'
// Error
// res.send('password is required');
if (typeof module === 'object' && module.exports) {
var expect = require('expect.js');
var propertiesReader = require('properties-reader');
var ArtikCloud = require('../src/index');
var sinon = require('sinon');
}
var apiClient = ArtikCloud.ApiClient.instance;
var properties = propertiesReader('./test/artik.properties');
describe('ApiClient', function() {
describe('properties', function() {
it('should have artik.properties', function() {
expect(properties.get('user1.id')).to.be('04ddbd35d57d4d7b8f07f219c44457b2');
});
});
describe('defaults', function() {
it('should have correct default values with the default API client', function() {
expect(apiClient).to.be.ok();
expect(apiClient.basePath).to.be('https://api.artik.cloud/v1.1');
expect(apiClient.authentications).to.eql({
artikcloud_oauth: {type: 'oauth2'}
});
});
it('should have correct default values with new API client and can customize it', function() {
var newClient = new ArtikCloud.ApiClient;
expect(newClient.basePath).to.be('https://api.artik.cloud/v1.1');
expect(newClient.buildUrl('/users', {})).to.be('https://api.artik.cloud/v1.1/users');
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var ejs = require('ejs');
var request = require('request');
var routes = require('./routes/index');
var users = require('./routes/users');
var web = require('./routes/web');
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('apiKey.properties');
var stormpath = require('express-stormpath');
var id = properties.get('apiKey.id');
var secret = properties.get('apiKey.secret');
var app = express();
// view engine setup
app.engine('html', ejs.renderFile);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
this._init = function() {
var propertiesObj = propsReader(filePath);
var allProperties = propertiesObj.getAllProperties();
var scriptString = "'use strict';" +
"var result = ";
/**
* Cache all require rules
*/
var requieredKeys = [];
for(var ruleKey in propRules) {
var rule = propRules[ruleKey];
if(rule['required'] === true) {
requieredKeys.push(ruleKey);
}
}
/**
* Loop all properties
*/
for(var propsKey in allProperties) {
var oldValue = allProperties[propsKey];
var newValue = undefined;
if(oldValue == undefined || oldValue === "") {
/**
* In case value is undefined or empty say the new value is string
* No need to pull the correct type from vm
*/
newValue = "";
} else {
/**
* GET THE CORRECT VARIABLE BY TYPE 'false'/'true' will be
* converted to false/true '100' will be converted to 100
*/
var context = new vm.createContext(sandbox);
try{
// Primitive OR sandbox function OR javascript exprection
var script = new vm.Script(scriptString + oldValue + ";");
script.runInContext(context);
} catch(e) {
// String
var script = new vm.Script(scriptString + "\"" + oldValue + "\"" + ";");
script.runInContext(context);
}
newValue = sandbox["result"];
}
//Fetch props rule by key string
var propsValidate = propRules[propsKey];
if(!propsValidate) {
/**
* Case key not found by string means it could be an regex
* run on all rules and find the maching one
*/
for(var validateKey in propRules) {
if( propsKey.match(new RegExp(validateKey, "i")) ) {
propsValidate = propRules[validateKey];
break;
}
}
}
if(propsValidate) {
/**
* Validate the rule type
*/
var type = typeof(newValue);
if(type != propsValidate.type) {
throw new Error("Config file contain invalid value for [" + propsKey + "], Expected:[" + propsValidate.type + "], Got:[" + type + "]");
}
/**
* Validate is the rule is required , update and remove from the required list
*/
if(propsValidate['required']) {
for(var requireIndex in requieredKeys) {
if(propsKey.match(new RegExp(requieredKeys[requireIndex], "i"))) {
break;
}
}
if(requireIndex) {
requieredKeys.splice(requireIndex, 1);
}
}
if(propsValidate['onDetect']) {
var detectResult = propsValidate.onDetect(propsKey, newValue);
if(detectResult === false) {
throw new Error("Config file contain invalid value for [" + propsKey + "], Expected:[" + propsValidate.type + "], Got:[" + type + "] (Fail on detection)");
}
}
}
/**
* All passed, update the prop
*/
this.properties[propsKey] = newValue;
}
if(requieredKeys.length > 0) {
var missingKeys = requieredKeys.join(", ");
throw new Error("Config file is missing requiered fields [" + missingKeys + "]");
}
};
const PropertiesReader = require('properties-reader');
const properties = PropertiesReader('./config/webapp.properties');
const dbUrl = properties.get('db.url');
const libraryDir = properties.get('library.dir');
const toolsDir = properties.get('tools.dir');
module.exports = {
dbUrl,
libraryDir,
toolsDir
};
// ### Configurações ###
var properties = null;
var logger = null;
// Inicializações necessárias
logger = log4js.getLogger();
log4js.configure('log_configuration.json', { reloadSecs: 300 });
process.on('uncaughtException', function(err) {
logger.error(err.stack);
});
properties = propertiesReader(__dirname + '/configuration.properties');
databaseConfig.user = getPropertyValue('com.synchronizer.database.user');
databaseConfig.password = getPropertyValue('com.synchronizer.database.password');
databaseConfig.server = getPropertyValue('com.synchronizer.database.host');
databaseConfig.database = getPropertyValue('com.synchronizer.database.databaseName');
key = getPropertyValue('com.synchronizer.trello.key');
secret = getPropertyValue('com.synchronizer.trello.secret');
domain = getPropertyValue('com.synchronizer.server.domain', 'localhost');
port = getPropertyValue('com.synchronizer.server.port', 8090);
intervalTime = getPropertyValue('com.synchronizer.server.interval', 5);
host = "http://" + domain + ":" + port;
var fs = require('fs');
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('thermostat.properties');
exports.get = function() {
var path = properties.get("target.path");
console.log("target.get" + path);
var pos = path.indexOf("/");
if (pos >= 0) {
// The temperature is a raw double value in a file
return fs.readFileSync(path, {encoding: 'utf-8'}).trim();
}
return null;
}
exports.set = function(value) {
var path = properties.get("target.path");
console.log("target.set value:" + value + " at " + path);
var pos = path.indexOf("/");
if (pos >= 0) {
// The temperature is a raw double value in a file
fs.writeFileSync(path, value, {encoding: 'utf-8'});
}
return this.get();
}
exports.getById = function(id) {
console.log("target.getById:" + id);
return this.get();
};
var propertiesReader = require('properties-reader');
var environment = 'dsv';
if (process.argv[2] === 'prd') {
environment = 'prd';
}
var properties = propertiesReader('properties/' + environment + '.properties');
var password_filepath = properties.get('mongoose.password.filepath');
var secret = propertiesReader(password_filepath);
exports.get = function() {
return properties;
};
exports.secret = function() {
return secret;
};
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('properties');
function getS3() {
var AWS = require('aws-sdk');
AWS.config.update({accessKeyId: properties.get('s3UserAccessKey'), secretAccessKey: properties.get('s3secretAccessKey')});
return new AWS.S3({params: {Bucket: properties.get('bucketName')}});
}
function migrateImageToS3(s3, imageUrl, imageKey, success, error) {
var http = require("http");
http.get(imageUrl, function(http_IncomingMessage) {
var bufs = [];
//console.log(http_IncomingMessage.statusCode + " " + http_IncomingMessage.statusMessage);
//console.log(http_IncomingMessage.rawHeaders);
http_IncomingMessage.on('data', (chunk) => {
bufs.push(chunk);
});
http_IncomingMessage.on('end', () => {
var buf = Buffer.concat(bufs);
var params = {
Body: buf,
Key: imageKey,
ContentType: "image/jpeg"
};
s3.upload(params, function(err, data) {
if (err) {
console.log("Error:", err);
error();
} else {
//console.log("S3 sucess.");
var express = require('express');
var app = module.exports = express();
var path = require('path');
var http = require('http');
var routes = require('./routes/routes');
var path = require('path');
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader(path.join(__dirname + '/properties/config.properties'));
var passport = require('passport'),
authentication = require('./routes/authentication');
// to render html
app.set('views', path.join(__dirname + '/../client/public/views'));
app.engine('.html', require('ejs').renderFile);
app.set('view engine', 'html');
app.use(express.logger('dev'));
app.use(express.cookieParser());
app.use(express.bodyParser());
app.use(express.session({ secret: properties.get("app.secret") }));
app.use(express.methodOverride());
// setup passport authentication - before routes, after express session
app.use(passport.initialize());
app.use(passport.session());
passport.use(authentication.localStrategy);
passport.serializeUser(authentication.serializeUser);
passport.deserializeUser(authentication.deserializeUser);
var width = process.env['BROWSER_WIDTH'];
var height = process.env['BROWSER_HEIGHT'];
var capabilities = require('../data/capabilities.json');
var webdriver = require('selenium-webdriver');
var chrome = require('selenium-webdriver/chrome');
var test = require('selenium-webdriver/testing');
var propertiesReader = require('properties-reader');
var basedir = './target/endtoend/screenshots/';
var seleniumtimeout = process.env['seleniumtimeout'];
var driverconfig = propertiesReader('./driverconfig.properties');
var users = require('./users');
var driver;
var chai = require('chai');
var chaiAsPromised = require('chai-as-promised');
chai.use(chaiAsPromised);
chai.config.truncateThreshold = 0;
global.webdriver = webdriver;
global.chaiAsPromised = chaiAsPromised;
global.expect = chai.expect;
global.test = test;
var EM = {};
module.exports = EM;
var nodemailer = require('nodemailer');
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('./kyrosview.properties');
EM.dispatchResetPasswordLink = function(account, callback)
{
console.log("-->"+account);
console.log("-->"+account.email);
console.log("-->"+properties.get('mail.user'));
console.log("-->"+EM.composeEmail(account));
var nodemailer = require('nodemailer');
// create reusable transporter object using the default SMTP transport
//var transporter = nodemailer.createTransport('smtps://user%40gmail.com:pass@smtp.gmail.com');
var transporter = nodemailer.createTransport({
service: 'Gmail',
auth: {
user: properties.get('mail.user'),
pass: properties.get('mail.pass')
}
});
// setup e-mail data with unicode symbols
var mailOptions = {
var Imap = require("browserbox");
var propertiesReader = require("properties-reader");
var Promise = require("es6-promise").Promise;
var props = propertiesReader(__dirname + "/.properties");
function getTousDossiers(dossiers) {
var tousDossiers = [];
dossiers.forEach(function(item) {
var path = item.path;
var nom = item.name == "INBOX" ? "Boite de réception" : item.name;
tousDossiers.push({
label: nom,
value: path
});
if (item.children && item.children.length > 0) {
tousDossiers = tousDossiers.concat(getTousDossiers(item.children));
}
});
return tousDossiers;
}
var imap = new Imap(props.get("imap.host"), props.get("imap.port"), {
auth: {
user: props.get("imap.user"),
pass: props.get("imap.password")
},
const
log = require('npmlog'),
request = require('request'),
express = require('express'),
passport = require('passport'),
app = express(),
redisClient = require('redis').createClient(),
RedisStore = require('connect-redis')(express),
GoogleStrategy = require('passport-google-oauth2').Strategy,
PropertiesReader = require('properties-reader'),
properties = PropertiesReader(__dirname + '/google-credentials.properties');
redisClient
.on('ready', function() {
log.info('REDIS', 'ready');
})
.on('error', function(err) {
log.error('REDIS', err.message);
});
passport.serializeUser(function(user, done) {
done(null, user.id);
});
passport.deserializeUser(function(id, done) {
done(null, { identifier: id });
var relay = require('./relay');
var relays = [];
var PropertiesReader = require('properties-reader');
var properties = PropertiesReader('relays.properties');
exports.getAll = function() {
var count = properties.get("count");
console.log("Count:" + count);
var i = 0;
while (i < count) {
relays[i] = this.getById(i);
i++;
}
return relays;
};
exports.getById = function(id) {
console.log("relays getById:" + id);
var path = properties.get(id + ".path");
console.log("path:" + path);
var isClosed = relay.getByPath(path);
console.log("isClosed?" + isClosed);
return {
"id" : id,
"name" : properties.get(id + ".name"),
"path" : path,
"value" : isClosed
};
};
* example :
*{
* "my instructions with $oneParame or $moreParameters" : {
* parameters : [ "$oneParame", "$moreParameters"],
* regexMatcher : "my instructions with (.*) or (.*)"
* codeLines : [
* "driver.doSomething(),
* "myOtherCustom instruction $oneParam",
* "driver.doSomethingElse($moreParameters)"
* ]
* }
* }
*/
var tastyCode = {};
var properties = propertiesReader();
////utility methods
function _replaceTastyParameters (codeLine, parametersArray, matcherArray) {
parametersArray.forEach(function(element, i) {
var joiner = matcherArray[i+1];
if(joiner && !joiner.startsWith("$")){
joiner = "'"+joiner+"'";
}
codeLine = codeLine.split(element).join(joiner);
});
return codeLine;
}
function _extractSeleniumCode (isMatchingInstruction){
var seleniumCode = [];
, redis = require('redis')
, http = require('http')
, bcrypt = require('bcrypt')
, session = require('express-session')
, PropertiesReader = require('properties-reader')
, path = require('path')
, helmet = require('helmet')
, crypto = require('crypto')
, algorithm = '' /*--removed for security reasons ---*/
, password = '' /*--removed for security reasons ---*/;
var request = require('request');
var SALT_WORK_FACTOR = 1; /* -- changed for security Reasons ---*/
var app = express();
var property = PropertiesReader('configuration/app-prod.properties');
// all environments
app.set('port', process.env.PORT || 4000);
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(express.static(__dirname + '/public'));
app.use(helmet());
app.use(bodyparser.json());
app.use(bodyparser.urlencoded({extended:false}));
//app.use(cookieParser());
var session=require('express-session');
var expiryDate = new Date( Date.now() + 60 * 60 * 500 ); // 0.5 hour
app.use(
var models = require("../models");
var sequelize = models.sequelize;
var PropertiesReader = require('properties-reader');
var sqlQuery = PropertiesReader(__dirname+'/../sql_queries/Tablets_Default_Activity_SQL.properties');
module.exports.create_Tablets = function(Tablets,callback) {
var create_query = sqlQuery._properties.create_Tablets;
sequelize.query(create_query, {
replacements: {
name : Tablets.name,
age : Tablets.age,
created_by : 0,
updated_by : 0
},
type : sequelize.QueryTypes.INSERT,
model: models.Tablets
}).then(function(tablets) {
callback(tablets);
});
}
module.exports.update_Tablets = function(Tablets,callback) {
var update_query = sqlQuery._properties.update_Tablets;
sequelize.query(update_query, {
replacements: {
id : Tablets.id,
name : Tablets.name,
age : Tablets.age,
updated_by : 0
},
type : sequelize.QueryTypes.BULKUPDATE,
model: models.Tablets
}).then(function(tablets) {