export async function disambiguatePipeline(pipelineIDOrName: any, command: Command) {
const headers = {Accept: 'application/vnd.heroku+json; version=3.pipelines'}
if (isUUID(pipelineIDOrName)) {
const {body: pipeline} = await command.heroku.get<Heroku.Pipeline>(`/pipelines/${pipelineIDOrName}`, {headers})
return pipeline
} else {
const {body: pipelines} = await command.heroku.get<Heroku.Pipeline>(`/pipelines?eq[name]=${pipelineIDOrName}`, {headers})
switch (pipelines.length) {
case 0:
command.error('Pipeline not found')
break
case 1:
return pipelines[0]
default:
let choices = pipelines.map(function (x: Heroku.Pipeline) { return {name: new Date(x.created_at!), value: x} })
let questions = [{
type: 'list',
name: 'pipeline',
message: `Which ${pipelineIDOrName} pipeline?`,
choices
}]
return prompt(questions)
}
}
}
export async function postGenerator() {
console.log("\n😳 😳 🤖 😳 LET'S MAKE A BLOG POST! 😳 😳 🤖 😳 \n")
const config = load(fs.readFileSync("./blog.config.yml", "utf8")) || {}
const { author = "", title = "" } = await prompt([
q.postTitle,
{ ...q.postAuthor, default: config.author || "" },
]) as IPost
const id = title
.replace(",", "")
.replace(/[^a-zA-Z0-9_.@()-]/g, "-")
.toLowerCase()
const permalink = join("posts", `${id}.md`)
const now = new Date()
const postData = { author, id, permalink, title, created: now, updated: now }
const frontmatter = `---\n${dump(postData)}---\n`
await writeFile(permalink, frontmatter + `# ${title}\n`)
console.log(`
Congratulations! 🎉 🎉 🎉
You generated a blog post!
`)
}
.then((respuestas) => {
if (respuestas.opciones === 'Crear'){
const preguntasFormulario = [
{ type: 'input', name: 'nombreDelJuego', message: 'Ingrese nombre del Juego:' },
{ type: 'input', name: 'precioDelJuego', message: 'Ingrese el precio del Juego:' },
{ type: 'list', name: 'tipoDelJuego', message: 'Escoga el tipo de Juego:', choices: tiposDeJuegos },
{ type: 'input', name: 'nombreDeLaEmpresaDelJuego', message: 'Ingrese nombre de la Empresa:'},
{ type: 'list', name: 'clasificacion', message: 'Escoga la clasficación del Juego:', choices: tipoDeClasificacion},
];
inquirer
.prompt(preguntasFormulario)
.then((respuestasFormulario) => {
console.log(respuestasFormulario)
funcionEscritura(respuestasFormulario.nombreDelJuego,JSON.stringify(respuestasFormulario));
}
);
}if(respuestas.opciones == 'Borrar'){
const preguntaParaBorrar = [
{ type: 'input', name: 'nombreDelJuego', message: '¿Qué Juego quiere borrar?' }];
inquirer
.prompt(preguntaParaBorrar)
.then((respuestaParaBorrar) => {
funcionBorrar(respuestaParaBorrar.nombreDelJuego);
}
)
}
});
async function promptKey (conf:KeypairConfDTO, program:any) {
const changeKeypair = !conf.pair || !conf.pair.pub || !conf.pair.sec;
const answersWantToChange = await inquirer.prompt([{
type: "confirm",
name: "change",
message: "Modify your keypair?",
default: changeKeypair
}]);
if (answersWantToChange.change) {
const obfuscatedSalt = (program.salt || "").replace(/./g, '*');
const answersSalt = await inquirer.prompt([{
type: "password",
name: "salt",
message: "Key's salt",
default: obfuscatedSalt || undefined
}]);
const obfuscatedPasswd = (program.passwd || "").replace(/./g, '*');
const answersPasswd = await inquirer.prompt([{
type: "password",
name: "passwd",
message: "Key\'s password",
default: obfuscatedPasswd || undefined
}]);
const keepOldSalt = obfuscatedSalt.length > 0 && obfuscatedSalt == answersSalt.salt;
const keepOldPasswd = obfuscatedPasswd.length > 0 && obfuscatedPasswd == answersPasswd.passwd;
const salt = keepOldSalt ? program.salt : answersSalt.salt;
const passwd = keepOldPasswd ? program.passwd : answersPasswd.passwd;
conf.pair = await Scrypt(salt, passwd)
}
}
(respuesta: RespuestaUsuario)=>{
if (respuesta.respuestaUsuario1.queEsUsted==='Vendedor'){
switch (respuesta.respuestaVenta.menuVendedor) {
case 'Ingresar Usuarios':
return rxjs.from(inquirer.prompt(ingresarUser)).pipe(
map(
(usuario)=>{
respuesta.usuario=usuario;
return respuesta;
}
)
);
case 'Ingresar más productos':
return rxjs.from(inquirer.prompt(ingresarProductos)).pipe(
map(
(productos)=>{
respuesta.producto=productos;
return respuesta;
}
)
);
}
}
else if(respuesta.respuestaUsuario1.queEsUsted === 'Comprador'){
switch (respuesta.respuestaCompra.menuComprador) {
case 'Escojer producto a comprar':
//leer base
const productos=[];
respuesta.respuestaBDD.bdd.productos.forEach(
(elemento)=>{
productos.push(elemento.nombre)
}
);
const listaProductos={
name: 'productos',
type: 'list',
message: 'Escoja una opción:\nProducto: ',
choices: productos,
default: 0,
};
return rxjs.from(inquirer.prompt(listaProductos)).pipe(
map(
(respuestaProductos)=>{
return{
respuestaUsuario1:respuesta.respuestaUsuario1,
respuestaCompra: respuesta.respuestaCompra,
respuestaBDD: respuesta.respuestaBDD,
respuestaProducto:respuestaProductos
}
}
)
);
//enlistar los productos
//escojemos la opcion
case 'Productos a comprar':
}
}
}
async function start() {
events = [];
const { url } = await inquirer.prompt<{ url: string }>([
{
type: 'input',
name: 'url',
message:
'Enter the url you want to record, e.g https://react-redux.realworld.io: ',
},
]);
console.log(`Going to open ${url}...`);
await record(url);
console.log('Ready to record. You can do any interaction on the page.');
const { shouldReplay } = await inquirer.prompt<{ shouldReplay: boolean }>([
{
type: 'confirm',
name: 'shouldReplay',
message: `Once you want to finish the recording, enter 'y' to start replay: `,
},
]);
emitter.emit('done', shouldReplay);
const { shouldStore } = await inquirer.prompt<{ shouldStore: boolean }>([
{
type: 'confirm',
name: 'shouldStore',
message: `Persistently store these recorded events?`,
},
]);
if (shouldStore) {
saveEvents();
}
const { shouldRecordAnother } = await inquirer.prompt<{
shouldRecordAnother: boolean;
}>([
{
type: 'confirm',
name: 'shouldRecordAnother',
message: 'Record another one?',
},
]);
if (shouldRecordAnother) {
start();
} else {
process.exit();
}
}
.consoleHandler = async function () {
console.log(`Getting payment methods ...`);
let store = await session.getStore();
let choices = [];
if (store.information.has_cash_on_delivery)
choices.push('Cash');
if (store.information.has_credit)
choices.push('Credit card');
let input = await inquirer.prompt([{
name: 'method',
message: 'Select a payment method',
type: 'list',
choices
}]);
if(input.method == 'Cash') {
session.setPayment({
paymentMethod: 'cash',
paymentToken: null,
paymentHashcode: null
});
}
if (input.method == 'Credit card') {
let cards = await session.getCreditCards();
let input = await inquirer.prompt([{
name: 'card',
message: 'Select a card',
type: 'list',
choices: cards.map(c => `[${c.card_type}] ${c.card_number}`)
}]);
let selectedCard = cards.filter(c => `[${c.card_type}] ${c.card_number}` == input.card)[0];
session.setPayment({
paymentMethod: 'piraeus.creditcard',
paymentToken: selectedCard.id,
paymentHashcode: selectedCard.hashcode
});
}
console.log(c.green(`Done.`));
};
.then(opcionMenu => {
//console.log(opcionMenu.Menu);
switch (opcionMenu.Menu) {
case 'Agregar libro':
console.log('1');
inquirer.prompt([
{
type: 'input', name: 'Titulo', message: 'Ingrese el tituo del Libro'},
{
type: 'input', name: 'Autor', message: 'Ingrese el autor del Libro'},
{
type: 'input', name: 'Genero', message: 'Ingrese el genero del Libro'}
])
.then(respuestasNuevoLibro => {
const libroNuevo: libroInterface = {
titulo: respuestasNuevoLibro.Titulo,
autor: respuestasNuevoLibro.Autor,
genero: respuestasNuevoLibro.Genero
};
agregarLibro(libros, libroNuevo);
console.log('Libro ingresado con exito.!');
start();
});
break;
case 'Listar libros':
listarLibros();
start();
break;
case 'Prestamo libro':
listarLibros();
//console.log('Escoja un libro de la lista');
inquirer.prompt([
{
type: 'input', name: 'Titulo', message: 'Ingrese el tituo del Libro'}
])
.then(respuestasNuevoPrestamo=> {
const nuevoPrestamo: prestamosInterface = {
fecha: fechaActual.getDate()+'/'+(fechaActual.getMonth()+1)+'/'+fechaActual.getFullYear(),
nombreLibro: respuestasNuevoPrestamo.Titulo,
fechaEntrega: fechaActual.getDate()+'/'+(fechaActual.getMonth()+2)+'/'+fechaActual.getFullYear()
};
crearPrestamo(prestamosLibros, nuevoPrestamo);
console.log('Prestamo registrado con exito.!');
start();
});
break;
case 'Salir':
break;
}
});
function getFields(entry: Entry): void {
inquirer.prompt([{
type: 'list',
name: 'newField',
message: 'Create another field?:',
choices: [
{name: 'Yes', value: true},
{name: 'No', value: false}
]
}, {
type: 'input',
name: 'name',
message: 'Name:',
validate: util.noBlanks,
when: answers => answers.newField
}, {
type: 'input',
name: 'value',
message: 'Value:',
validate: util.noBlanks,
when: answers => answers.newField
}], (answers: Answer) => {
if (!answers.newField) {
iter.next(entry);
} else {
entry[answers.name] = answers.value;
getFields(entry);
}
});
}
function makePassphrase(entry: Entry): void {
if (entry.password !== undefined) {
iter.next(entry);
} else {
const password = diceware.generate();
log(password);
inquirer.prompt([{
type: 'list',
name: 'accept',
message: 'Accept?:',
choices: [
{name: 'Yes', value: true},
{name: 'No, generate another', value: false}
]
}], (answers: Answer) => {
if (answers.accept) {
entry.password = password;
iter.next(entry);
} else {
makePassphrase(entry);
}
});
}
}
