function options(player) {
let commands = {
help: function() {
console.log('Possible commands are "use", "health", "move", "look", "take", "bagcheck", "die".')
options(player)
},
health: function() {
player.checkHealth()
options(player)
},
take: function() {
prompt.start()
console.log('What do you take?')
prompt.get(promptSchema, function(err, result) {
player.addItem(result.answer)
options(player)
})
},
look: function() {
player.location.look()
options(player)
},
die: function() {
player.health = 0
console.log('You die')
process.exit()
},
bagcheck: function() {
player.checkInventory()
options(player)
},
move: function() {
prompt.start()
console.log('Where do you go?')
prompt.get(promptSchema, function(err, result) {
player.move(result.answer)
player.location.look()
options(player)
})
},
use: function() {
prompt.start()
console.log('What do you use?')
prompt.get(promptSchema, function(err, result) {
player.useItem(result.answer)
options(player)
})
}
}
prompt.start()
console.log('What do you do? (type "help" for help)')
prompt.get(promptSchema, function(err, result) {
try {
commands[result.answer]()
}
catch(err) {
console.log('I\'m sorry, I didn\'t understand that')
options(player)
}
})
}
const version = require('../package.json').version;
const path = require('path');
/*********
* Build Clarity for release
*/
console.log(colors.green(`Building Clarity v${version}`));
shell.exec('npm run build');
/*********
* Set up and start the publish process
*/
prompt.message = colors.red(`Are you ready to publish Clarity v${version} to npm?`);
prompt.delimiter = colors.green('><');
prompt.start();
/*********
* Ask user if they are ready to publish this version of clarity
*/
prompt.get(['confirmation'], function (err, result) {
if(/yes/i.test(result.confirmation) || /y/i.test(result.confirmation)) {
const npm = path.join(process.cwd(), 'node_modules', '.bin', 'npm');
shell.exec(`${npm} publish dist/clr-ui; ${npm} publish dist/clr-angular/clr-angular-${version}.tgz; ${npm} publish dist/clr-icons`);
console.log(colors.green(`Clarity v${version} successfully published to npm!`));
} else {
console.log(colors.red('Nah, just kidding for now!'));
}
});
var quad = require("./quadratic");
var prompt = require("prompt");
prompt.get(['a', 'b', 'c'], function(err, result) {
if(err) {
return onErr(err);
}
console.log('Command-line input received:');
console.log('a: ' + result.a);
console.log('b: ' + result.b);
console.log('c: ' + result.c);
quad(result.a, result.b, result.c, function(err, quadsolve) {
if(err) {
console.log("Error: ", err);
} else {
console.log("Roots are " + quadsolve.root1() + " " + quadsolve.root2());
}
});
});
return new Promise((resolve, reject) => {
prompt.start()
prompt.get(keys, parsePromptResults(resolve, reject, instance))
})
var prompt = require('prompt');
prompt.colors = false;
prompt.start();
prompt.get(['first', 'second'], function(err, result) {
console.log('Command-line input received:');
console.log(' first: ' + result.first);
console.log(' second: ' + result.second);
});
var enterCardNumber = function(done) {
console.log("Enter your card number:");
prompt.get(['cardnum'], function(err, result) {
input('#cardNumber', result.cardnum, done);
});
};
var enterCardName = function(done) {
console.log("Enter the name on the card:");
prompt.get(['name'], function(err, result) {
input('#nameOnCard', result.name, done);
});
};
function createAdmin(callback) {
var User = require('./user'),
Groups = require('./groups');
winston.warn('No administrators have been detected, running initial user setup');
var questions = [{
name: 'username',
description: 'Administrator username',
required: true,
type: 'string'
}, {
name: 'email',
description: 'Administrator email address',
pattern: /.+@.+/,
required: true
}],
passwordQuestions = [{
name: 'password',
description: 'Password',
required: true,
hidden: true,
type: 'string'
}, {
name: 'password:confirm',
description: 'Confirm Password',
required: true,
hidden: true,
type: 'string'
}],
success = function(err, results) {
if (!results) {
return callback(new Error('aborted'));
}
if (results['password:confirm'] !== results.password) {
winston.warn("Passwords did not match, please try again");
return retryPassword(results);
}
nconf.set('bcrypt_rounds', 12);
User.create({username: results.username, password: results.password, email: results.email}, function (err, uid) {
if (err) {
winston.warn(err.message + ' Please try again.');
return callback(new Error('invalid-values'));
}
Groups.join('administrators', uid, callback);
});
},
retryPassword = function (originalResults) {
// Ask only the password questions
prompt.get(passwordQuestions, function (err, results) {
if (!results) {
return callback(new Error('aborted'));
}
// Update the original data with newly collected password
originalResults.password = results.password;
originalResults['password:confirm'] = results['password:confirm'];
// Send back to success to handle
success(err, originalResults);
});
};
// Add the password questions
questions = questions.concat(passwordQuestions);
if (!install.values) {
prompt.get(questions, success);
} else {
var results = {
username: install.values['admin:username'],
email: install.values['admin:email'],
password: install.values['admin:password'],
'password:confirm': install.values['admin:password:confirm']
};
success(null, results);
}
}
required: true
},
projectName: {
pattern: /^[a-zA-Z\-]+$/,
message: 'Name must be only letters or dashes.',
description: 'Projects name:',
required: true
},
projectDescription: {
description: 'Projects description:',
required: false
}
}
};
console.log('\nWelcome to the bootstrap script.');
console.log('\nPlease enter the following data.\n');
prompt.get(config, function (err, result) {
if (err) {
console.log('\nError found. Operation ' + err.message + '.');
} else {
bfm.initReadme(result.responsibleUsername, result.responsibleFullName, result.projectName, result.projectDescription);
bfm.initPackageBower(result.responsibleFullName, result.projectName, result.projectDescription);
bfm.initAngularModule(result.projectName);
bfm.removeScripts();
}
});
var prompt = require('prompt'),
config = require(__dirname + '/configs/network');
prompt.start();
prompt.get(config, function(e, result) {
if (e) throw e;
console.log(result);
});
const _str = require('underscore.string')
const yaml = require('js-yaml')
const fs = require('fs')
prompt.start()
/*eslint-disable */
prompt.get(['title'], (err, result) => {
'use strict'
const dir = `./pages/${ moment().format('YYYY-MM-DD') }-${ _str.slugify(result.title) }`
mkdirp.sync(dir)
let postFileStr = '---\n'
const frontmatter = {
title: result.title,
date: moment().toJSON(),
layout: 'post',
draft: true,
}
postFileStr += yaml.safeDump(frontmatter)
postFileStr += '---\n'
fs.writeFileSync(`${ dir }/index.md`, postFileStr, {
encoding: 'utf-8',
})
return console.log(dir)
})
IonicTask.prototype.upload_cert = function(self) {
var project = IonicProject.load();
if (!project.get('app_id')) {
console.log("You need to upload your app first!".bold.red);
return false;
}
var promptProperties = {};
var prodCert = '0';
if (argv['ios-dev-cert']) {
promptProperties['ios-push-cert'] = {
name: 'ios-push-cert',
description: 'iOS Dev Push Certificate File (.p12)'.yellow.bold,
required: true,
conform: fileExists,
isFile: true
};
} else if (argv['ios-prod-cert']) {
promptProperties['ios-push-cert'] = {
name: 'ios-push-cert',
description: 'iOS Prod Push Certificate File (.p12)'.yellow.bold,
required: true,
conform: fileExists,
isFile: true
};
prodCert = '1';
}
prompt.start();
prompt.get({properties: promptProperties}, function(err, promptResult) {
if (err) {
return self.ionic.fail('Error: ' + err);
}
var url = self.ionic.IONIC_DASH + self.ionic.IONIC_API + 'app/' + project.get('app_id') + '/push/upload-push-cert';
var params = parseUrl(url);
var form = new FormData();
form.append('csrfmiddlewaretoken', self.getCsrfToken(self.jar));
try {
inputFile = promptResult['ios-push-cert'].replace(/\\ /g, ' ').trim();
form.append('ios_push_cert', fs.createReadStream( resolvePath(inputFile) ) );
} catch(e) {
return self.ionic.fail("Error loading " + resolvePath(inputFile));
}
// Set the flag for if this is a production or dev cert
form.append('prod_cert', prodCert);
form.submit({
protocol: params.protocol,
hostname: params.hostname,
port: params.port,
path: params.path,
headers: form.getHeaders({
cookie: self.jar.map(function(c) {
return c.key + "=" + encodeURIComponent(c.value);
}).join("; ")
})
},
function (err, response) {
if (err) {
return self.ionic.fail('Error uploading certificate: ' + err);
}
response.setEncoding('utf8');
response.on("data", function(data) {
if (err) {
return self.ionic.fail('Error uploading certificate: ' + err);
}
try {
var d = JSON.parse(data);
if (d.errors && d.errors.length) {
for (var j = 0; j < d.errors.length; j++) {
console.log((d.errors[j]).bold.error);
}
return self.ionic.fail('Unable to upload certificate');
}
console.log("Successfully uploaded certificate");
} catch (parseEx) {
return self.ionic.fail('Error response: ' + parseEx);
}
});
}
);
});
}
IonicTask.prototype.send_push = function(self) {
var project = IonicProject.load();
if (!project.get('app_id')) {
console.log("You need to upload your app first!".bold.red);
return false;
}
// So, we need the push API key to send notifications.
var promptProperties = {};
promptProperties['push-api-key'] = {
name: 'push-api-key',
description: 'Your private API key'.yellow.bold,
required: true,
isFile: false
};
promptProperties['device-token'] = {
name: 'device-token',
description: 'Device token'.yellow.bold,
required: true,
isFile: false
}
promptProperties['alert'] = {
name: 'alert',
description: 'Notification alert message'.yellow.bold,
required: false,
isFile: false
};
promptProperties['badge'] = {
name: 'badge',
description: 'Badge count'.yellow.bold,
required: false,
isFile: false
}
promptProperties['sound'] = {
name: 'sound',
description: 'Sound file name'.yellow.bold,
required: false,
isFile: false
}
prompt.start();
prompt.get({properties: promptProperties}, function(err, promptResult) {
if (err) {
return self.ionic.fail('Error: ' + err);
}
var api_key = promptResult['push-api-key'];
var notification = {
platform: 'ios',
tokens: [promptResult['device-token']],
notification: {
alert: promptResult['alert'],
ios: {
badge: promptResult['badge'],
sound: promptResult['sound']
}
}
}
var options = {
url: 'https://push.ionic.io/api/v1/push',
method: 'POST',
json: true,
headers: {
'X-Ionic-Application-Id': project.get('app_id'),
'authorization': 'Basic ' + new Buffer(api_key + ':').toString('base64')
},
body: notification
};
request(options, function(err, response, body) {
if (!err && response.statusCode == 202) {
console.log("Successfully queued push notification");
} else {
console.log("Error queueing push notification", err);
}
});
});
};
var Dropbox = require('../../src/dropbox');
var fs = require('fs');
var prompt = require('prompt');
prompt.start();
prompt.get({
properties: {
accessToken: {
description: 'Please enter an API V2 access token'
},
sharedLink: {
description: 'Please enter a shared link to a file'
}
}
}, function (error, result) {
var dbx = new Dropbox({ accessToken: result.accessToken });
dbx.sharingGetSharedLinkFile({ url: result.sharedLink })
.then(function (data) {
fs.writeFile(data.name, data.fileBinary, 'binary', function (err) {
if (err) { throw err; }
console.log('File: ' + data.name + ' saved.');
});
})
.catch(function (err) {
throw err;
});
});
connection.connect(function(err){
if (err) {
console.error("error connecting");
return;
}
console.log("connected as Bamazon Executive");
console.log("");
console.log("1) View Product Sales by Department");
console.log("2) Create New Department");
console.log("");
var schema = {
properties: {
option: {
description: "Please select an option:",
type: "integer",
message: "Please type the number of the option you wish to select.",
required: true
}
}
};
prompt.message = "";
prompt.delimiter= "";
prompt.start();
prompt.get(schema,function (err, result) {
if (result.option === 1) {
connection.query("SELECT * FROM Departments;", function (err, res) {
if (err) throw err;
console.log(res);
console.log("Products Sales by Department:");
console.log("");
for (i=0; i<res.length; i++) {
console.table([
{
DepartmentID: res[i].DepartmentID,
DepartmentName: res[i].DepartmentName,
OverheadCosts: res[i].OverheadCosts,
ProductSales: res[i].TotalSales,
TotalProfit: (res[i].TotalSales-res[i].OverheadCosts)
},
]);
}
});
}
else if (result.option === 2) {
console.log("Create a New Department:")
var schema2 = {
properties: {
departmentNameInput: {
description: "Please enter the name of the new department:",
type: "string",
message: "Please enter the name of the new department:",
required: true
},
overheadCostInput: {
description: "Please enter the overhead cost of new department:",
type: "integer",
message: "Please enter the overhead cost of new department:",
required: true
},
}
};
prompt.message = "";
prompt.delimiter= "";
prompt.start();
prompt.get(schema2, function (err, result) {
connection.query("INSERT INTO Departments (DepartmentName,OverheadCosts) VALUES ('"+result.departmentNameInput+"','"+result.overheadCostInput+"');", function (err, res) {
console.log("Department Added!");
console.log("");
});
connection.query("SELECT * FROM Departments WHERE DepartmentName='"+result.departmentNameInput+"';",
function (err, res) {
console.table([
{
DepartmentID: res[0].DepartmentID,
DepartmentName: res[0].DepartmentName,
OverheadCosts: res[0].OverheadCosts,
ProductSales: res[0].TotalSales,
},
]);
});
});
}
});
});
'use strict'
const prompt = require('prompt')
const generator = require('./array-generator')
prompt.start()
// Cambiar la cantidad de elementos que contendrá el arreglo
const ARRAY_LENGTH = 10
// Indicar el prefijo de las variables de entrada generadas en el arreglo
const ARRAY_PREFIX = "numero"
const arreglo = generator(ARRAY_PREFIX, ARRAY_LENGTH)
/*
* Ejemplo de uso:
* Calcular el promedio de los números ingresados mediante terminal
*/
prompt.get(arreglo, function (err, result) {
let suma = 0
for (let i = 0; i < ARRAY_LENGTH; i++) {
suma += parseInt(result[ARRAY_PREFIX + (i+1)])
}
let promedio = suma/ARRAY_LENGTH
console.log("Promedio: " + promedio)
})
It's hot out! Let's make a converter based on the steps here:
http://www.mathsisfun.com/temperature-conversion.html
- Store a celsius temperature into a variable.
- Convert it to fahrenheit and output "NN°C is NN°F".
- Now store a fahrenheit temperature into a variable.
- Convert it to celsius and output "NN°F is NN°C."
*/
// write your solution here...
var prompt = require('prompt');
prompt.start();
prompt.get(['celsius', 'farenheit'], function (err, result) {
var celsius = result.celsius;
//Multiply by 9, then divide by 5, then add 32
var farenheit = ((celsius * 9) / 5) + 32;
console.log(celsius + " ºC is " + farenheit + "ºF");
farenheit = result.farenheit;
//Deduct 32, then multiply by 5, then divide by 9
celsius = ((farenheit - 32) * 5) / 9;
console.log(farenheit + " ºF is " + celsius + "ºC");
});
function onErr(err) {
console.log(err);
return 1;
}
daemontools.svstat(dir, function(err, stats) {
if (err && err.code == 'ENOENT') {
prompt.start();
prompt.get([{
name: 'service',
description: 'New Service Name',
type: 'string',
default: service,
}, {
name: 'host',
description: 'New Service Bind Host',
type: 'string',
default: '127.0.0.1',
}, {
name: 'port',
description: 'New Service Port',
type: 'number',
default: '3000',
}, {
name: 'bin',
description: 'New Service Interpretter',
type: 'string',
default: 'node',
}, {
name: 'DIR',
description: 'Directory which contains script to execute. Use "." if using Server.js script.',
type: 'string',
default: '.',
}, {
name: 'script',
description: 'Service Start Script, relative to above directory. Server.js will result in a new node script created for you.',
type: 'string',
default: 'Server.js',
}, {
name: 'user',
description: 'New Service User',
type: 'string',
default: 'nobody',
}, ], function(e, result) {
dir = '/service/' + result.service;
mkdirp(dir, function(err) {
if (err && (err.code == 'EACCES' || err.code == 'ENOENT')) {
console.log(cls.red('Failure to create directory ' + dir));
process.exit();
} else if (err) throw err;
setTimeout(function() {
mkdirp(dir + '/log/main', function(err) {
var run = '#!/bin/sh\n' +
'export PORT="' + result.port + '"\n' +
'export HOST="' + result.host + '"\n' +
'export USER="******"\n' +
'export BIN="' + result.bin + '"\n' +
'export CUSTOMDATA="{\\"test\\":123}"\n' +
'export DIR="/service/' + result.service + '/' + result.DIR + '"\n' +
'export SCRIPT="' + result.script + '"\n' +
'cd ${DIR}\n' +
'exec setuidgid ${USER} ${BIN} ./${SCRIPT} 2>&1';
var log = '#!/bin/sh\n' +
'export RUN_AS="root"\n' +
'mkdir ./main 2>/dev/null\n' +
'exec setuidgid ${RUN_AS} multilog t n20 s10000000 ./main\n';
var bin = '#!/usr/bin/env node\n' +
'var fs = require(\'fs\');\nconsole.log(\'Testing...\');\nsetTimeout(function(){}, 5000);\n';
var cfg = '[' + result.service + ']\n' +
'run_log = /service/' + result.service + '/log/main/current';
fs.writeFileSync(dir + '/.supervise_web.cfg', cfg, {
mode: '0644'
});
fs.writeFileSync(dir + '/run', run, {
mode: '0755'
});
fs.writeFileSync(dir + '/log/run', log, {
mode: '0755'
});
console.log(cls.green('Installed to ' + dir + '\n\n'));
if (result.script == 'Server.js') {
fs.writeFileSync(dir + '/' + result.script, bin, {
mode: '0755'
});
}
});
}, 250);
});
});
} else {
console.log(stats);
}
});
var enterCardCode = function(done) {
console.log("Enter the card security code (on back):");
prompt.get(['code'], function(err, result) {
input('#securityCode', result.code, done);
});
};
connectDB().then(function() {
oauth
.version('0.0.1')
.option('-c, --create', 'Create a new client')
.option('-t, --test', 'Test Authentication')
.parse(process.argv);
if (oauth.create)
{
var userData = {};
prompt.start();
prompt.get([
{ name: 'username', required: true },
{ name: 'password', required: true, hidden: true },
{ name: 'firstname', message: 'First Name' },
{ name: 'lastname', message: 'Last Name' },
{ name: 'email', message: 'E-Mail' }
], function(err, res){
userData.username = res.username;
userData.password = res.password;
userData.email = res.email;
userData.firstname = res.firstname;
userData.lastname = res.lastname;
model.createUser(userData, function(err, user){
if (err)
{
console.log(err);
process.exit(true);
}
else
{
console.log(user);
console.log(chalk.green("User has been created!"));
process.exit(true);
}
});
});
}
if (oauth.test)
{
prompt.start();
prompt.get([
{ name: 'username', required: true },
{ name: 'password', required: true, hidden: true }
], function(err, res){
// var url = 'http://127.0.0.1:' + config.port + '/oauth/authorize?response_type=code&redirect_uri=' + encodeURI('http://127.0.0.1:8803') + '&client_id=' + res.username;
var url = 'http://127.0.0.1:' + config.port + '/oauth/token';
console.log(chalk.bold.underline('Url: %s'), url);
request
.post(url)
.set('Content-Type', 'application/x-www-form-urlencoded')
.send({
grant_type: 'password',
client_id: 'xxx',
client_secret: res.password,
client_user: res.username,
password: res.password
})
.end(function (res) {
console.log(res);
process.exit(true);
});
});
}
});
vm_server_controller.list_servers(session_id, function(error, server_list) {
self.log(server_list);
var schema = {
properties: {
description: {
description: 'Description',
type: 'string',
required: false
},
server: {
description: 'Server',
enum: server_list,
required: true
},
hypervisor: {
description: 'Hypervisor',
enum: ['vbox'],
required: true
},
platform: {
description: 'Platform (x64, x32)',
enum: ['x64', 'x32'],
required: true
},
mem_size: {
description: 'Memory (MB)',
default: 512,
type: 'integer',
required: true
},
cpu_count: {
description: '# of CPUs',
default: 1,
type: 'integer',
required: true
},
display: {
description: 'Display',
enum: ['local', 'rdp', 'vnc'],
required: true
}
}
};
prompt.message = "VM Create";
prompt.start();
prompt.get(schema, function (err, result) {
vm_controller.create_vm(session_id, result.server, result.hypervisor, args.name, function(i_error, config, done) {
config.set_mem_size(result.mem_size);
config.set_cpu_count(result.cpu_count);
config.set_platform(result.platform);
config.set_display(result.display);
done(function(s_error, result) {
if (!error) {
self.log(SUCCESS('VM successfully created!'));
} else {
self.log(ERROR('Error: ' + s_error.message + ''));
}
callback();
});
});
});
});
}
}
};
nConf.argv().env().file({ file: 'confs/config.json' });
var twitterClient = new twitterMaster({
consumer_key: nConf.get('CONSUMER_KEY'),
consumer_secret: nConf.get('CONSUMER_SECRET'),
access_token_key: nConf.get('ACCESS_TOKEN_KEY'),
access_token_secret: nConf.get('ACCESS_TOKEN_SECRET')
});
console.log('\n----------------------------\nTwitterTinker - Tweeter\n----------------------------');
cPrompt.get(twitterInput, function (err, result) {
twitterClient.post('statuses/update', {status: result.STATUS}, function(error, tweet, response){
if(error)
{
//throw error;
console.log('\n----------------------------\nError, tweet was not sent\n----------------------------');
}
else
{
console.log('\n----------------------------\nSuccess, tweet was sent\n----------------------------');
}
//console.log(tweet); // Tweet body.
//console.log(response); // Raw response object.
});
});
const calculateAnagrams = require('../js/calculateAnagrams.js');
const Results = require('../js/results.js');
let phrase;
prompt.start();
console.log('Welcome to the anagram generator!');
console.log('When prompted, please enter the phrase you wish to see anagrams for')
console.log('You can enter any phrase, but we will scrub newlines (\\n) out so all our code doesn\'t break');
prompt.get(['phrase'], function(err, res) {
phrase = res.phrase.split('\n')
.map( word => word.trim() )
.join('');
console.log('Please wait while we calculate all anagrams... this can take a while :(');
let anagrams = calculateAnagrams(phrase);
return new Promise( (resolve, reject) => {
return Results.storeResult(phrase, anagrams)
.then( () => {resolve();})
})
.then( () => {
console.log('Success! Please see the results folder for a list of your anagrams');
})
})
var wordCount = require('./wordCount.js').wordCount;
var prompt = require('prompt');
prompt.start();
prompt.get('body', function(err, result) {
var output = wordCount(result.body);
output.forEach(function(element) {
console.log(element);
});
});
var flm = require('./favoriteListModules');
var ts = timestamp('DD.MM.YYYY:hh:mm:ss');
var key_counter = timestamp('DDMMYYYYhhmmss');
console.log("----------------------Favourite List Menu-------------------------");
console.log("1 - Mark Favourite Item");
console.log("2 - Show Favourite List");
console.log("3 - Delete Favourite List Item");
console.log("4 - Delete Favourite Complete List");
prompt.start();
prompt.get("option", function (err, result) {
if (err) {
console.log(err);
} else {
switch (result.option) {
case "1": flm.create_favoriteList("US0002", key_counter, "ES002", ts, 49.4040995, 8.68697580000002, 40.0540984, 7.5974980290087, client);
break;
case "2": flm.read_favoriteList("US0001", client);
break;
case "3": flm.delete_favoriteListItem("US0005", 2, client);
break;
case "4": flm.delete_favoriteList("US0005", client);
break;
default: console.log("Please enter valid option!");
}
}
});
prompt.start();
prompt.get({
properties: {
package: {
message: `PACKAGE to install?`,
required: true,
},
version: {
message: `VERSION to install?`,
required: true,
}
}
}, function (err, result) {
// Log the results.
console.log('Command-line input received:');
console.log('package: ' + result.package);
console.log('version: ' + result.version);
// const lib = '@jenkins-cd/design-language';
// const version = '0.0.79-unpublishedthor1';
async.mapSeries(directories, function (elem, callback) {
console.log('Current element', elem);
removeAndInstall(elem, result.package, result.version, callback);
}, function (err, result) {
if (err) {
console.error('Something went wrong', err);
}
const ellapsed = new Date().getTime() - start;
console.log(`Install look good! took ${ellapsed}ms`);
process.exit(0);
});
});
// process.stdin.setEncoding('utf8');
// var util = require('util');
//
// process.stdin.on('data', function (text) {
// console.log('received data:', util.inspect(text));
// if (text === 'quit\n') {
// done();
// }
// });
//
// function done() {
// console.log('Now that process.stdin is paused, there is nothing more to do.');
// process.exit();
// }
var prompt = require('prompt');
prompt.start();
prompt.get(['username', 'email'], function (err, result) {
if (err) { return onErr(err); }
console.log('Command-line input received:');
console.log(' Username: '******' Email: ' + result.email);
});
function onErr(err) {
console.log(err);
return 1;
}
const SrvClient = require('../lib/srvClient.js');
const prompt = require('prompt'); // eslint-disable-line node/no-unpublished-require
let client;
prompt.start();
prompt.get(['host'], function (err, result) {
if (err) throw err;
client = new SrvClient({
host: result.host
});
client.connect(function(){
awaitCmd();
});
});
function handleCmd(cmd){
switch(cmd){
case 'z':
client.laserOn();
awaitCmd();
break;
case 'Z':
client.laserOff();
awaitCmd();
break;
case 'f':
client.forward();
awaitCmd();
prompt.get(prompts, function(err, result) {
request.post({
uri: cas.options.casHost + cas.options.casBasePath + '/tickets',
body: 'username='******'&password='******'&service=' + cas.options.service + '&allow=sfu'
}, function(err, response, body) {
assert.equal(response.statusCode, 201);
var ticketurl = cas.options.casHost + response.headers.location;
request.post({
uri: cas.options.casHost + response.headers.location,
body: 'service=' + cas.options.service
}, function(err, response, ticket){
assert.equal(response.statusCode, 200);
cas.validate(ticket, function(err, loggedIn, casResponse) {
assert(loggedIn);
assert.equal(casResponse.user, result.username);
var apacheuser = '******'
, apachepass = '******';
request.post({
uri: cas.options.casHost + cas.options.casBasePath + '/tickets',
body: 'username='******'&password='******'&service=' + cas.options.service + '&allow=' + cas.options.allow
}, function(err, response, body) {
assert.equal(response.statusCode, 201);
var ticketurl = cas.options.casHost + response.headers.location;
request.post({
uri: cas.options.casHost + response.headers.location,
body: 'service=' + cas.options.service
}, function(err, response, ticket){
assert.equal(response.statusCode, 200);
cas.validate(ticket, function(err, loggedIn, casResponse) {
assert(loggedIn);
cas.authenticateApacheUser(casResponse, function(err, loggedIn, casResponse) {
assert(loggedIn);
});
});
});
});
});
});
});
});
function(callback)
{
if(!fs.existsSync('./config.js'))
{
var listsrooms;
var lookup = {};
var roomvar = '';
schema = {
properties: {
VeraIP: {
description: 'IP address for your Vera device',
pattern: /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/,
message: 'VeraIP must be a valid IP number',
required: true,
conform: function(value) {
url = "http://" + value + ":3480/data_request?id=lu_sdata";
try
{
res = request('GET', url, {json:true, timeout:1500});
data = JSON.parse(res.body.toString('utf8'));
}
catch (ex)
{
data = null;
}
if(typeof data === 'object' && data !== null)
{
listsrooms = data.rooms;
return true;
}
else
{
console.log('Your VeraIP ('+value+') has no connection, please check that it is a correct one')
return false;
}
}
},
happort: {
description: 'Port for your Vera device (hit enter to use default)',
pattern: /^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$/,
message: 'happort must be a valid port number',
default: '6200',
required: true
},
bridged: {
description: 'Bridged mode (Set to false to use single server for each device instead of one for each room)',
type: 'boolean',
message: 'Enter "true" or "false"',
default: 'true',
required: true,
conform: function(){
listsrooms.sort(function(a,b) {return (a.id > b.id) ? 1 : ((b.id > a.id) ? -1 : 0);} );
for(var i = 0; i < listsrooms.length;i++)
{
roomvar += listsrooms[i].id+' - '+listsrooms[i].name+"\n";
lookup[listsrooms[i].id] = listsrooms[i];
}
console.log('Room list: \n'+roomvar);
return true;
}
},
Rooms: {
description: "List of rooms to ignore, comma separated (default is empty)",
default: '',
allowEmpty: true,
message: 'Only numbers and comma allowed',
conform: function(response) {
found = [];
if(response !== '')
{
if ( response.match( /^[0-9, ]+$/ ) )
{
response = response.split(' ').join('');
value = response.split(",");
for(var i = 0; i < value.length;i++)
{
if(typeof lookup[value[i]] !== 'undefined')
{
found.push(value[i]);
}
if(i+1 >= value.length)
{
if(found.length > 0)
{
return true;
}
else
{
console.log('Please check your list of items');
return false;
}
}
}
}
else
{
return false;
}
}
else
{
return true;
}
}
}
}
};
prompt.start();
prompt.get(schema, function (err, result)
{
console.log('Command-line input received:');
console.log('\tVeraIP: ' + result.VeraIP);
console.log('\thapport: ' + result.happort);
console.log('\tbridged: ' + result.bridged);
roomarr = '';
if(result.Rooms.length > 0)
{
found = [];
if ( result.Rooms.match( /^[0-9, ]+$/ ) )
{
result.Rooms = result.Rooms.split(' ').join('');
value = result.Rooms.split(",");
for(var i = 0; i < value.length;i++)
{
if(typeof lookup[value[i]] !== "undefined")
{
found.push(value[i]);
}
if(i+1 >= value.length && found.length > 0)
{
roomarr = found.join(',');
}
}
}
}
console.log('\tignorerooms: ' + roomarr);
data = "module.exports = {\n\tveraIP: '"+result.VeraIP+"',\n\thapport: "+result.happort+",\n\tcardinality: 0,\n\tbridged: "+result.bridged+",\n\tignorerooms: ["+roomarr+"],\n\tincludesensor: true,\n\tpincode: '031-45-154',\n\tdimmertest: false,\n\tmainHNpath: './node_modules/hap-nodejs'\n};";
fs.writeFile('./config.js', data, { flag: 'wx' }, function (err) {
if (err) throw err;
console.log("Configuration saved!");
callback();
});
});
}
else
{
callback();
}
},