Ejemplos de Macros

var macro = createMacro(function*(){
  'use strict';

  // El objeto "ui" ofrece funciones para preguntar información al usuario y para mostrar información

  // Declarar variables para uso posterior
  var username;
  var password;
  var flavor;
  var scoops;

  //Inicio Macro Generada
  var ps = session.getPresentationSpace();

  try {
    // Pedir al usuario que ingrese su nombre de usuario y guardarlo en una variable.
    // Recuerde que la palabra clave 'yield' es necesaria para bloquear la ejecución mientras se espera a la entrada del usuario.
    username = yield ui.prompt(‘Introduzca su nombre de usuario');

    // Pide al usuario ingresar un valor predeterminado que se le ha facilitado.
    flavor = yield ui.prompt('¿Cuál es su helado favorito?', 'Chocolate');

    // Pide al usuario ingresar información privada cuando se utiliza la opción 'mask' y el campo de entrada se enmascarará mientras escribe.
    // Si el parámetro no se utiliza, se puede utilizar 'cero' para especificar que no se desea utilizar.
    // Aquí lo ilustramos especificando que no necesitamos mostrar un valor predeterminado.
    password = yield ui.prompt('Introduzca su contraseña', null, true);

    // La función de preguntar devuelve cero si el usuario hace clic en el botón 'Cancelar' en lugar de en el botón 'Aceptar'.
    // Una forma de tratar este caso es ajustar la llamada a un bloque try/catch.
    scoops = yield ui.prompt('¿Cuántas cucharadas quiere?');
    if (scoops === null) {
      // Se sale de la macro.
      return;
      // Alternativamente podría arrojar un Error y capturarlo en el "catch" situado a continuación
     }
     // Utilizar los valores coleccionados para pedir nuestro ice cream 
    ps.sendKeys(username + ControlKey.TAB + password + ControlKey.ENTER); 
    yield wait.forCursor(new Position(5, 1)); 
    ps.sendKeys(flavor + ControlKey.TAB + scoops + ControlKey.ENTER);

     // Mostrar un mensaje al usuario. Utilizando la palabra clave 'yield' enfrente de la llamada bloquea
     // la ejecución de la macro hasta que el usuario hace clic en el botón 'Aceptar'.
    yield ui.message('Orden correcta. Enjoy your ' + scoops + ' scoops of ' + flavor + ' ice cream ' + username + '!');
    } catch (error) {
     // Aquí utilizamos el objeto ui para mostrar un mensaje de que ha ocurrido un error
    yield ui.message(error.message);
    }
    //Fin Macro Generada

});

return macro();

 // Función Crear una nueva macro.
var macro = createMacro(function*(){
  'use strict';

  // Crear variable(s) para uso posterior
  var password;
  var accountNumber;
  'var transactionCount = 0;
  var row = 0;

  // Obtener una referencia para el objeto PresentationSpace.
  var ps = session.getPresentationSpace(); 

  try {
    // Introducir nombre de usuario y contraseña para iniciar sesión en la aplicación. 
    yield wait.forCursor(new Position(19, 48)); 
    ps.sendKeys('bjones' + ControlKey.TAB); 

    yield wait.forCursor(new Position(20, 48));
    password = yield ui.prompt('Contraseña:', null, true); 
    ps.sendKeys(password); 
    ps.sendKeys(ControlKey.ENTER);

    // Introducir un comando de aplicación. 
    yield wait.forCursor(new Position(20, 38)); 
    ps.sendKeys('4'); 
    ps.sendKeys(ControlKey.ENTER);

    // Ir a la lista de transacciones para una lista. 
    yield wait.forCursor(new Position(13, 25)); 
    ps.sendKeys('2');
    // Ingresar un número de cuenta. Codificación fija aquí para simplificar. 
    yield wait.forCursor(new Position(15, 25));
    accountNumber = yield ui.prompt('Número de cuenta:', '167439459'); 
    ps.sendKeys(accountNumber); 
    ps.sendKeys(ControlKey.ENTER);

    // Esperar hasta que esté en pantalla de perfil de cuenta 
    yield wait.forText('ACCOUNT PROFILE', new Position(3, 33));

    // Buscar texto que indique que la última página de la grabación se ha alcanzado mientras
    while (ps.getText(new Position(22, 12), 9) !== 'LAST PAGE') {

      // Mientras que la página de la grabación no se haya alcanzado, ir a la siguiente página de grabaciones. 
      ps.sendKeys(ControlKey.PF2); 
      yield wait.forCursor(new Position(1, 1));

      // Si la posición del cursor no cambia entre las pantallas de grabación y no hay texto
      // en la pantalla, puede verificar si una pantalla se ha actualizado, puede esperar durante un
      // periodo de tiempo fijo después de que una tecla de ayuda haya sido enviada hasta el establecimiento de la pantalla.
      // Por ejemplo:
      // yield wait.forFixedTime(1000);

      // Para cada una de las pantallas, incremente la variable de recuento si contiene datos.
      for (row = 5; row <= 21; row++) {

        // Hay 2 columnas en la pantalla. Comprobar datos en columna 1.
        // En este ejemplo, sabemos que si hay un espacio en una posición
        // específica, se trata de una transacción.
        if (ps.getText(new Position(row, 8), 1) !== ' ') {
          transactionCount++;
        }
        // Comprobar datos en columna 2.
        if (ps.getText(new Position(row, 49), 1) !== ' ') {
          transactionCount++;
        }
      }
    }

    // Después de haber pasado por todas las páginas de grabación, mostrar el número de grabaciones en un cuadro de mensaje.
    yield ui.message('Encontradas ' + transactionCount + ' grabaciones para cuenta ' + accountNumber + '.');

    // Salir de la aplicación 
    ps.sendKeys(ControlKey.PF13); 
    ps.sendKeys(ControlKey.PF12);

    // La try / catch permite capturar todos los errores y notificarlos a una ubicación central
  } catch (error) {
    // Aquí utilizamos el objeto ui para visualizar un mensaje que indica que se ha producido un error
    yield ui.message(error.message);
  }
});

// Aquí ejecutamos la macro y devolvemos los resultados al Ejecutor de macros
// La instrucción return es necesaria, ya que la aplicación aprovecha
// esto para saber si la macro se ha ejecutado correctamente y cuándo ha finalizado
return macro();

 var macro = createMacro(function*() {
  'use strict';

  // Crear unas cuantas variables para usuario posterior
  var username;
  var password;
  var accountNumber;
  var accountDetails;

  // Crear una función que hará una llamada AJAX / REST a un servicio web VHI.
  // Se podría ajustar para llamar cualquier servicio web, no sólo VHI.
  // Si no se utiliza CORS, la solicitud tendría que pasar por un
  // proxy en el servidor de sesión. Véanse notas de ejemplo para más información.
  /**
   * Función de auxiliar de cifrado manual para encapsular parámetros AJAX / REST, invocar el servicio
   * REST y devolver los resultados dentro de una Promise.
   * @param {Number} acctNum para enviar a la consulta REST.
   * @param {String} nombre de usuario para acceder al servicio REST.
   * @param {String} contraseña para acceder al servicio REST.
   * @return {Promise} que contiene resultados $.post() compatibles con yield.
   */
  var getAccountDetails = function (acctNum, username, password) {
    var url = "proxy1/model/CICSAcctsDemo/GetAccountDetail";
    var args = {"filters": {"AcctNum": acctNum}, "envVars": {"Username": username, "Password": password}};

    // Ajustar una llamada jQuery AJAX / HTTP POST en una nueva Promise.
    // La promise que se devuelve aquí permite a la macro yield / esperar
    // hasta que se complete.
    return Promise.resolve($.post(url, JSON.stringify(args)))
      .catch(function (error) {
      // Se han producido errores de asignación en la llamada jQuery a nuestra Promise.
      throw new Error('REST API Error: ' + error.statusText);
    });
  };

  // Inicio Macro Generada
  var ps = session.getPresentationSpace();
  try {
    // Podría interactuar con el host aquí, iniciar sesión en app de host, etc...
    // Recuperar nombre de usuario y contraseña
    username = yield ui.prompt('Nombre de usuario:');
    password = yield ui.prompt('Contraseña:', null, true);
    accountNumber = yield ui.prompt('Número de cuenta:');
    if (!username || !password || !accountNumber) {
      throw new Error('Username or password not specified');
    }

    // Invocar servicio REST externo, y yields / esperar a que se complete la llamada.
    accountDetails = yield getAccountDetails(accountNumber, username, password);

    // Ahora tenemos los datos de nuestro servicio externo.
    // Puede integrar los datos en nuestra app de host local o simplemente mostrarlos al usuario.
    // En este ejemplo sólo mostramos los detalles de la cuenta resultantes.
    if (accountDetails.result && accountDetails.result.length > 0) {
      yield ui.message(accountDetails.result[0].FirstName + ' $' + accountDetails.result[0].AcctBalance);
    } else {
      yield ui.message('Ninguna grabación encontrada para cuenta: ‘ + accountNumber);
    }
  } catch (error) {
    // Si se ha producido un error durante la llamada AJAX / REST call
    // o la recuperación del nombre de usuario / contraseña terminaremos aquí.
    yield ui.message(error.message);
  }
});

// Ejecutar nuestra macro
return macro();

var macro = createMacro(function*() {
    'use strict';

    // Obtener PresentationSpace para interactuar con el host
    var ps = session.getPresentationSpace();

    // Declarar variables para uso posterior
    var cells;
    var text;
    var attrs;

    // Establecer el tiempo de espera predeterminado para las funciones "wait"
    wait.setDefaultTimeout(10000);

    // Macro de ejemplo para trabajar con DataCells y Attributes
    try { 
        yield wait.forCursor(new Position(24, 2));

        // Obtener DataCells del espacio de presentación.
        // Fila 19, col 3 es la pregunta, 35 caracteres de longitud
        // "Seleccionar de los siguientes comandos:"
        cells = ps.getDataCells({row:19, col:3}, 35);
        text = '';

        // Puede visualizar texto utilizando getText
        yield ui.message("Screen text: " + ps.getText({row:19, col:3}, 35));

        // O puede ensamblar el texto de las DataCells en cada posición
        for(var index = 0; index < cells.length; index++) {
            text = text.concat(cells[index].getChar());
        }
        // Y visualizar el texto
        yield ui.message("Cells text: " + text);

        // Obtener los atributos de la primera DataCell (cell[0])
        attrs = cells[0].getAttributes();

        // Muestra si hay o no atributos en la celda de datos
        yield ui.message("Conjunto de atributos vacío: " + attrs.isEmpty());

        // Muestra cuántos atributos están configurados
        yield ui.message("Número de atributos: " + attrs.size());

        // Muestra qué atributos están configurados
        yield ui.message("Atributos: " + attrs.toString());

        // Mostrar ahora si el atributo de alta intensidad está configurado
        yield ui.message("Es de alta intensidad: " +
                         attrs.contains(Attribute.HIGH_INTENSITY));

        // Mostrar ahora si el atributo subrayado está configurado
        yield ui.message("Es subrayado: " +
                         attrs.contains(Attribute.UNDERLINE));

        // Mostrar ahora si los atributos alfanumérico, intensificado y detectable por lápiz están configurados
        yield ui.message("Es alfanumérico, intensificado y detectable por lápiz: " +
                         attrs.containsAll([Attribute.ALPHA_NUMERIC, Attribute.HIGH_INTENSITY, Attribute.PEN_DETECTABLE]));

        // Mostrar ahora si los atributos alfanumérico, intensificado y detectable por lápiz están configurados
        yield ui.message("Es alfanumérico, intensificado y detectable por lápiz: " +
                         attrs.containsAll([Attribute.UNDERLINE, Attribute.HIGH_INTENSITY, Attribute.PEN_DETECTABLE]));
    } catch (error) {
        yield ui.message(error);
    }
    //Fin Macro Generada
});

// Ejecutar la macro
return macro();

var macro = createMacro(function*() {
    'use strict';

    // Obtener PresentationSpace para interactuar con el host
    var ps = session.getPresentationSpace();

    // Declarar variables para uso posterior
    var fields;
    var field;
    var searchString = 'z/VM';

    // Establecer el tiempo de espera predeterminado para las funciones "wait"
    wait.setDefaultTimeout(10000);

    // Macro de ejemplo para trabajar con FieldList y Fields
    try {
    yield wait.forCursor(new Position(24, 2));

    // Obtener la lista de campos.
    fields = ps.getFields();

        // Ejecutar en toda la lista de campos y mostrar la información del campo.
        for(var index = 0; index < fields.size(); index++) {
            field = fields.get(index);

            yield ui.message("Field " + index + " info: " + field.toString());
        }

        yield ui.message("Ahora, encontrar un campo que contenga el texto '" + searchString + "'");
        field = fields.findField(new Position(1, 1), searchString);

        if(field !== null) {
            yield ui.message("Found field info: " + field.toString());
            yield ui.message(“¿Encontrado primer plano de campo es verde? " + (Color.GREEN === field.getForegroundColor()));
            yield ui.message("¿Encontrado primer plano de campo es predeterminado? " + (Color.BLANK_UNSPECIFIED === field.getBackgroundColor()));
        }

        // Ahora, encontrar campo de comando y modificarlo.
        field = fields.findField(new Position(23, 80));
        if(field !== null) {
             field.setText("cics");
        }

        yield ui.message("Clic para enviar 'cics' al host."); 
        ps.sendKeys(ControlKey.ENTER);

        // Esperar a nueva pantalla; obtener nuevos campos. 
        yield wait.forCursor(new Position(10, 26));
        fields = ps.getFields();

        // Encontrar campo de usuario y configurarlo.
        field = fields.findField(new Position(10, 24));
        if(field !== null) {
            field.setText("myusername");
        }

        // Encontrar campo de contraseña y configurarlo.
        field = fields.findField(new Position(11, 24));
        if(field !== null) {
            field.setText("mypassword");
        }

        yield ui.message("Clic para enviar inicio de sesión al host."); 
        ps.sendKeys(ControlKey.ENTER);

        // Esperar a nueva pantalla; obtener nuevos campos. 
        yield wait.forCursor(new Position(1, 1));
        fields = ps.getFields();

        // Encontrar campo de comando y configurar comando logoff.
        field = fields.findField(new Position(24, 45));
        if(field !== null) {
            field.setText("cesf logoff");
        }

        yield ui.message("Clic para enviar logoff al host."); 
        ps.sendKeys(ControlKey.ENTER);

    } catch (error) {
        yield ui.message(error);
    }
    //Fin Macro Generada
});

// Ejecutar la macro
return macro();

var macro = createMacro(function*() {
    'use strict';

    // Obtener PresentationSpace para interactuar con el host
    var ps = session.getPresentationSpace();

    // Variable para ticket de paso de inicio de sesión
    var passTicket;

    // ID de inicio de sesión en aplicación
    var appId = 'CICSV41A';

    // Establecer el tiempo de espera predeterminado para las funciones "wait"
    wait.setDefaultTimeout(10000);

    // Inicio Macro Generada
    try { 
        yield wait.forCursor(new Position(24, 2));

        // Obtener un ticket de paso de DCAS.
        passTicket = yield autoSignon.getPassTicket(appId); 

        ps.sendKeys('cics'); 
        ps.sendKeys(ControlKey.ENTER); 

        yield wait.forCursor(new Position(10, 26));

        // Sustituir nombre de usuario generado por sendUserName(passTicket) ... 
        yield autoSignon.sendUserName(passTicket);

        // ps.sendKeys('bvtst01' + ControlKey.TAB + ControlKey.TAB); 
        ps.sendKeys(ControlKey.TAB + ControlKey.TAB); 

        yield wait.forCursor(new Position(11, 26));

        // Sustituir contraseña generada por sendPassword(passTicket) ... 
        yield autoSignon.sendPassword(passTicket);

        // var userInput3 = yield ui.prompt('Contraseña:', '', true);
        // if (userInput3 === null) {
            // throw new Error('Password not provided');
        // }
        // ps.sendKeys(userInput3);
        ps.sendKeys(ControlKey.ENTER);

        yield wait.forCursor(new Position(1, 1));
        yield ui.message('Logged in. Log me off.'); 
        ps.sendKeys('cesf logoff'); 
        ps.sendKeys(ControlKey.ENTER);
    } catch (error) {
        yield ui.message(error);
    }
    //Fin Macro Generada
});

// Ejecutar la macro
return macro();

var macro = createMacro(function*() {
    'use strict';

    try {
        var fileTransfer = fileTransferFactory.getInd$File();
        var hostFiles = yield fileTransfer.getHostFileListing();

        yield ui.message('Found ' + hostFiles.length + ' files');
        if (hostFiles.length > 0) {
            var firstFile = hostFiles[0];
            var msg1 = 'El nombre del catálogo es ' + firstFile.getParent() + '. ';
            var msg2 = 'The first file is ' + firstFile.getName();
            yield ui.message(msg1 + msg2);
        }
    } catch (error) {
        yield ui.message(error);
    }
});

// Run the macro
return macro();

var hostEnvironment = 'CMS';  // 'TSO'
// Construct file path, ie catalog/file.name or catalog/partition/file
function getPath (fileNode) {
    var prefix = fileNode.getParent() ? fileNode.getParent() + '/' : '';
    return prefix + fileNode.getName();
}

var macro = createMacro(function*() {
    'use strict';

    try {
        var fileTransfer = fileTransferFactory.getInd$File();

        // Las opciones de transferMethod son 'binario' y 'ascii'
        fileTransfer.setTransferOptions({transferMethod: 'ascii'});

        // Esta demostración recupera el primer archivo devuelto en la lista
        var hostFiles = yield fileTransfer.getHostFileListing();
        var firstHostFile = hostFiles[0];

        if (hostEnvironment === 'CMS') { 
           yield wait.forText('Ready', new Position(1,1), 5000);
        }

        // Download
        // Si ya conoce la ruta al archivo que desea, pásela a getDownloadURL()
        var downloadUrl = fileTransfer.getDownloadURL(getPath(firstHostFile));

        // Esto cambia la ubicación del navegador. Puede obtener resultados diferentes en navegadores diferentes
        window.location = downloadUrl;

        // Si desea leer el contenido del archivo en una variable en lugar de descargarlo,
        // puede utilizar jQuery
        // var fileContents = yield $.get(downloadUrl);

    } catch (error) {
        yield ui.message(error);
    }
});

// Run the macro
return macro();

var hostEnvironment = 'CMS';  // 'TSO'
// Abre la función programada de diálogo de selección de archivos del navegador
function promptForFileToUpload () {
    return new Promise(function (resolve, reject) {
        // No se nos notifica si el usuario camcela el ciálogo selector de archivos, por tanto se rechaza después de 30 segundos
        var timerId = setTimeout(reject.bind(null, 'Tiempo de espera agotado esperando la selección del archivo'), 30000);
        var fileSelector = document.createElement('input');
        fileSelector.setAttribute('type', 'file');
        fileSelector.onchange = function (evt) {
            var file = evt.target.files[0];
            clearTimeout(timerId);
            resolve(file);
        };
        fileSelector.click();
    });
}

var macro = createMacro(function*() {
    'use strict';

    try {
        var fileTransfer = fileTransferFactory.getInd$File();

        // Las opciones de transferMethod son 'binario' y 'ascii'
         fileTransfer.setTransferOptions({transferMethod: 'ascii'});

         var localFile = yield promptForFileToUpload();

         // Recuperar el catálogo actual y añadirle el nombre de archivo seleccionado
         var hostFiles = yield fileTransfer.getHostFileListing();
         var destination = hostFiles[0].getParent() + '/' + localFile.name;

         if (hostEnvironment === 'CMS') { 
           yield wait.forText('Ready', new Position(1,1), 5000);
         }

         var result = yield fileTransfer.sendFile(localFile, destination);

    } catch (error) {
         yield ui.message(error);
    }
});

// Run the macro
return macro();