diff --git a/docs/_navbar.md b/docs/_navbar.md new file mode 100644 index 0000000..17cfde8 --- /dev/null +++ b/docs/_navbar.md @@ -0,0 +1,4 @@ + +- Translations + - [:us: English](/) + - [:es: Spanish](/es/) \ No newline at end of file diff --git a/docs/es/README.md b/docs/es/README.md new file mode 100644 index 0000000..4bb1fab --- /dev/null +++ b/docs/es/README.md @@ -0,0 +1,51 @@ +# Código para IBM i + +## Extensión de desarrollo para IBM i en VS Code + +Mantén y compila tu código RPGLE, CL, COBOL, C/CPP en IBM i directamente desde Visual Studio Code. + +![intro_01.png](../assets/intro_01.png) + +## Requisitos + +- El demonio SSH debe estar iniciado en IBM i. + - (El programa con licencia 5733-SC1 proporciona soporte para SSH.) + - `STRTCPSVR *SSHD` inicia el demonio. + - El usuario `QSSHD` está habilitado. +- Algo de familiaridad con VS Code. Puedes encontrar una introducción [aquí](https://code.visualstudio.com/docs/getstarted/introvideos). + +Opcionalmente, asegúrate de saber cómo conectarte a PASE desde una terminal. Consulta la [documentación oficial de IBM i OSS](https://ibmi-oss-docs.readthedocs.io/en/latest/user_setup/README.html#step-1-install-an-ssh-client). + +## Instalación + + + + + +Desde el Marketplace de Visual Studio Code: [Code for IBM i](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.code-for-ibmi) + +O desde la vista de Extensiones dentro de Visual Studio Code. + + + +![../assets/install_01,png](../assets/install_01.png) + + + +### Extensiones Recomendadas + +Se recomienda instalar también el [Paquete de Desarrollo IBM i](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.ibm-i-development-pack), un conjunto seleccionado de extensiones construidas sobre o que añaden valor a Code for IBM i. Esto incluye herramientas de base de datos, herramientas RPGLE, herramientas COBOL y más. + +## Desarrollo de Extensiones + +¡Consulta nuestra [documentación para desarrolladores](./pages/dev/getting_started.md)! + +## Primeros Pasos + +Para trabajar en esta documentación: + +- clona el repositorio +- instala Docsify ```npm i docsify-cli -g``` +- ejecuta localmente con ```docsify serve docs/``` +- por defecto, se ejecuta en http://localhost:3000 +- Lee más sobre [Docsify](https://docsify.js.org/#/) diff --git a/docs/es/_sidebar.md b/docs/es/_sidebar.md new file mode 100644 index 0000000..ec8ef56 --- /dev/null +++ b/docs/es/_sidebar.md @@ -0,0 +1,42 @@ +- [Código para IBM i](./es/README.md) + - [Inicio de Sesión](es/pages/login.md) +- Desarrollo + - [Edición y Compilación](es/pages/developing/editing-compiling.md) + - [Fechas de Origen](es/pages/developing/sourcedates.md) + - [Acciones](es/pages/developing/actions/index.md) + - [Ejecución](es/pages/developing/actions/execution.md) + - [Variables Personalizadas](es/pages/developing/actions/custom-vars.md) + - [Depuración](es/pages/developing/debug/debug.md) + - [ILEDocs](es/pages/developing/iledocs.md) + - Desarrollo Local + - [Git](es/pages/developing/local/git.md) + - [Primeros Pasos](es/pages/developing/local/getting-started.md) + - [Estructura del Proyecto](es/pages/developing/local/structure.md) + - [Acciones Locales](es/pages/developing/local/actions.md) + - [Migración a Git](es/pages/developing/local/migrate.md) + - [Azure DevOps](es/pages/developing/local/azure.md) +- [Navegadores](es/pages/browsers/index.md) + - [Lista de Bibliotecas de Usuario](es/pages/browsers/user-library-list.md) + - [Navegador de Objetos](es/pages/browsers/object-browser.md) + - [Navegador de IFS](es/pages/browsers/ifs-browser.md) +- Consejos + - [Inicio Rápido](es/pages/tips/quickstart.md) + - [Trucos](es/pages/tips/tricks.md) + - [Terminales](es/pages/tips/terminals.md) + - [CCSID](es/pages/tips/ccsid.md) + - [Configuración](es/pages/tips/setup.md) +- Configuraciones + - [Perfiles](es/pages/settings/profiles.md) + - [Conexión](es/pages/settings/connection.md) + - [Global](es/pages/settings/global.md) +- Extensiones + * RPGLE + - [Introducción](es/pages/extensions/rpgle/index.md) + - [Linter](es/pages/extensions/rpgle/linter.md) + - [Preguntas Frecuentes](es/pages/extensions/rpgle/faq.md) + - [Db2 for i](es/pages/extensions/db2i/index.md) +- Desarrollo + - [Primeros Pasos](es/pages/dev/getting_started.md) + - [Alcance](es/pages/dev/scope.md) + - [API](es/pages/dev/api.md) + - [Variables](es/pages/dev/variables.md) diff --git a/docs/es/pages/browsers/ifs-browser.md b/docs/es/pages/browsers/ifs-browser.md new file mode 100644 index 0000000..63b33a9 --- /dev/null +++ b/docs/es/pages/browsers/ifs-browser.md @@ -0,0 +1,7 @@ +Esto muestra directorios y archivos en el IFS. Haz clic en un archivo fuente para abrirlo en el editor. + +Agrega atajos adicionales según sea necesario: + +![Agregar atajo](../../../assets/BrowserIFS_01.png) + +![Atajos añadidos](../../../assets/BrowserIFS_02.png) diff --git a/docs/es/pages/browsers/index.md b/docs/es/pages/browsers/index.md new file mode 100644 index 0000000..61a46f3 --- /dev/null +++ b/docs/es/pages/browsers/index.md @@ -0,0 +1,7 @@ +En la barra lateral hay varios navegadores para mostrar e interactuar con diversas partes del IBM i: + +![Navegadores](../../../assets/Browser_01.png) + +Cada uno de estos navegadores se puede expandir haciendo clic en él. Haz clic o pasa el mouse sobre el título del navegador para ver sus íconos de acción. Pasa el mouse sobre cada ícono para ver qué hace. + +![Íconos del navegador](../../../assets/Browser_02.png) diff --git a/docs/es/pages/browsers/object-browser.md b/docs/es/pages/browsers/object-browser.md new file mode 100644 index 0000000..0283649 --- /dev/null +++ b/docs/es/pages/browsers/object-browser.md @@ -0,0 +1,120 @@ +El Navegador de Objetos te permite interactuar con bibliotecas, archivos, archivos fuente, programas y otros tipos de objetos. Filtra los objetos con los que deseas trabajar creando un filtro o filtros. + +### Crear el Primer Filtro + + + + + +Haz clic en la indicación **+ Crear nuevo filtro** para crear tu primer filtro (o haz clic en el icono de filtro): + + + +![Crear Nuevo filtro](../../../assets/Browser_03.png) + + + +--- + + + + + +Completa el diálogo del nuevo filtro. El texto explicativo en el diálogo Crear Filtro explica las opciones. + +**Haz clic en 'Guardar configuración' para crear el nuevo filtro.** + + + +![Diálogo de Nuevo Filtro](../../../assets/Browser_04.png) + + + +--- + + + + + +El ejemplo de filtro anterior enumera todos los archivos fuente en la biblioteca `LENNONS1`: + +> [!NOTE] +> El nombre del filtro tiene la definición del filtro a la derecha. + + + +![Filtro Expandido](../../../assets/Browser_05.png) + + + +--- + +### Crear Filtros Adicionales + + + + + +Para crear otro filtro, haz clic en el icono de filtro para abrir el nuevo diálogo de filtro. + + + +![Filtros Adicionales](../../../assets/Browser_06.png) + + + +--- + +### Crear Filtros Rápidos + + + + + +Para crear rápidamente filtros sin tener que completar el diálogo de filtro, haz clic en el icono **Crear Filtro Rápido**. Cuando se te solicite, ingresa un filtro que coincida con uno de los siguientes formatos: + +- `LIB*` +- `LIB/OBJ/MBR.MBRTYPE (OBJTYPE)` + + + +![Crear Filtro Rápido](../../../assets/Browser_11.png) + + + +> [!NOTE] +> Todos los parámetros excepto la biblioteca son opcionales. Para los parámetros que no se proporcionen, se utilizarán los mismos valores predeterminados que en el diálogo de filtro. + +### Mantener Filtros + + + + + +Cambiar la definición de un filtro es rápido y fácil. Simplemente haz clic derecho en el filtro y elige **Mantener filtro** para abrir el diálogo del filtro. O elige **Eliminar filtro** para quitar la definición del filtro. + + + +![Mantener filtro](../../../assets/Browser_10.png) + + + +--- + +### Ejemplos de Filtros + +**Filtro de un Solo Archivo** + +![Filtro de un solo archivo](../../../assets/Browser_07.png) + +**Ejemplo de miembro fuente subset** + +Un solo archivo fuente que subconjunta solo algunos miembros: + +![Subset de Miembros](../../../assets/Browser_08.png) + +**Ejemplo que no es de fuente** + +Algunos programas en una biblioteca: + +![Filtro de programas](../../../assets/Browser_09.png) diff --git a/docs/es/pages/browsers/user-library-list.md b/docs/es/pages/browsers/user-library-list.md new file mode 100644 index 0000000..7e2089e --- /dev/null +++ b/docs/es/pages/browsers/user-library-list.md @@ -0,0 +1,3 @@ +La Lista de Bibliotecas del Usuario se establece inicialmente desde tu perfil de usuario. Agrega bibliotecas según sea necesario utilizando el icono "**+**". Elimina una biblioteca de la lista haciendo clic derecho sobre ella. + +La Lista de Bibliotecas del Usuario se utiliza cuando se ejecutan *Acciones* (ver más abajo). diff --git a/docs/es/pages/dev/api.md b/docs/es/pages/dev/api.md new file mode 100644 index 0000000..ed876c9 --- /dev/null +++ b/docs/es/pages/dev/api.md @@ -0,0 +1,382 @@ +Es posible escribir extensiones de VS Code basadas en Code for IBM i. Esto significa que tu extensión puede utilizar la conexión que el usuario crea en tu extensión. Esto no es un tutorial de extensiones, sino una introducción sobre cómo acceder a las API disponibles dentro de Code for IBM i. + +Por ejemplo, podrías ser un proveedor que produce listas o HTML que te gustaría que estén accesibles desde Visual Studio Code. + +# Exportaciones + +Además del API básico de comandos de VS Code, puedes acceder al API de Code for IBM i con el API `getExtension` de VS Code. + + +``` +const { instance } = vscode.extensions.getExtension(`halcyontechltd.code-for-ibmi`).exports; +``` +## Tipos + +Proporcionamos definiciones de tipos en TypeScript para facilitar el uso de la API de Code for IBM i. Pueden ser instalados mediante `npm`: + + +```terminal +npm i @halcyontech/vscode-ibmi-types +``` + +Luego se puede importar y utilizar en combinación con `getExtension`: + +```ts +import type { CodeForIBMi } from '@halcyontech/vscode-ibmi-types'; + +//... + +const ext = vscode.extensions.getExtension('halcyontechltd.code-for-ibmi'); +``` +> [!ATTENTION] +> A medida que Code for IBM i se actualiza, es posible que la API cambie. Se recomienda mantener siempre actualizados los tipos empaquetados a medida que se actualiza la extensión, en caso de que cambien las interfaces de la API. Planeamos estabilizar las interfaces de la API de comandos de VS Code para que no se rompan tan a menudo después de su lanzamiento. + +## Ejemplo de importación + +Este ejemplo se puede utilizar como una forma sencilla de acceder a la instancia de Code for IBM i. + + +```ts +import { CodeForIBMi } from "@halcyontech/vscode-ibmi-types"; +import Instance from "@halcyontech/vscode-ibmi-types/api/Instance"; +import { Extension, extensions } from "vscode"; + +let baseExtension: Extension|undefined; + +/** + * This should be used on your extension activation. + */ +export function loadBase(): CodeForIBMi|undefined { + if (!baseExtension) { + baseExtension = (extensions ? extensions.getExtension(`halcyontechltd.code-for-ibmi`) : undefined); + } + + return (baseExtension && baseExtension.isActive && baseExtension.exports ? baseExtension.exports : undefined); +} + +/** + * Used when you want to fetch the extension 'instance' (the connection) + */ +export function getInstance(): Instance|undefined { + return (baseExtension && baseExtension.isActive && baseExtension.exports ? baseExtension.exports.instance : undefined); +} +``` +## Escucha de eventos + +La API de Code for IBM i proporciona un escucha de eventos. Esto permite que tu extensión dispare un evento cuando sucede algo en Code for IBM i. + + +```js +const instance = getInstance(); + +instance.onEvent(`connected`, () => { + console.log(`It connected!`); +}); +``` + +### Eventos disponibles + +| ID | Evento | +|-------------|-------------------------------------------------| +| `connected` | Cuando Code for IBM i se conecta a un sistema | +| `disconnected` | Cuando Code for IBM i se desconecta de un sistema | +| `deployLocation` | Cuando cambia la ubicación de implementación | +| `deploy` | Cuando se completa exitosamente una implementación | + +# APIs + +## Ejecutar comandos con la lista de bibliotecas del usuario + +Code for IBM i proporciona una API (a través de un comando de VS Code) que puede ser utilizada por una extensión para ejecutar un comando remoto en IBM i. + +Tiene un parámetro que es un objeto con algunas propiedades: + + +```ts +interface CommandInfo { + /** describes what environment the command will be executed. Is optional and defaults to `ile` */ + environment?: `pase`|`ile`|`qsh`; + /** set this as the working directory for the command when it is executed. Is optional and defaults to the users working directory in Code for IBM i. */ + cwd?: string; + command: string; +} +``` + +- El comando también puede utilizar [campos con posibilidad de ingresar datos](https://halcyon-tech.github.io/vscode-ibmi/#/?id=prompted). +- Cuando ejecutas un comando en el entorno `ILE` o `QSH`, utilizará la lista de bibliotecas de la conexión actual. + +El comando devuelve un objeto: + + +```ts +interface CommandResult { + stdout: string; + stderr: string; + code: number; +} +``` + +```js +const result: CommandResult = await vscode.commands.executeCommand(`code-for-ibmi.runCommand`, { + environment: `pase`, + command: `ls` +}); + +// or + +const result = await vscode.commands.executeCommand(`code-for-ibmi.runCommand`, { + environment: `pase`, + command: `ls` +}); +``` +También puedes proporcionar una lista de bibliotecas personalizada y la biblioteca actual al ejecutar un comando en el entorno `ILE`: + +```js +const detail: CommandResult = { + environment: `ile`, + command: `CRTBNDRPG...`, + env: { + // Space delimited library list + '&LIBL': 'LIBA LIBB LIBC' + '&CURLIB': 'LIBD' + } +} +``` + +## Ejecución de consultas SQL + +Code for IBM i tiene un comando que te permite ejecutar declaraciones SQL y obtener un resultado. + + +```ts +const instance = getInstance(); + +const rows = await instance.getContent().runSQL(`select * from schema.yourtable`); +``` + +## Obtener miembros y archivos de flujo + +Es posible para las extensiones utilizar los sistemas de archivos proporcionados por Code for IBM i. + +`openTextDocument` devuelve un [`TextDocument`](https://code.visualstudio.com/api/references/vscode-api#TextDocument). + +#### Obteniendo un miembro + + +```js +//Member located on *SYSBAS +const doc = await vscode.workspace.openTextDocument(vscode.Uri.from({ + scheme: `member`, + path: `/${library}/${file}/${name}.${extension}` +})); + +//Member located on an iASP +const doc = await vscode.workspace.openTextDocument(vscode.Uri.from({ + scheme: `member`, + path: `/${iasp}/${library}/${file}/${name}.${extension}`, + query: 'readonly=true' //Optional: open in read-only mode +})); +``` + +#### Obteniendo un archivo de flujo +```js +const doc = await vscode.workspace.openTextDocument(vscode.Uri.from({ + scheme: `streamfile`, + path: streamfilePath, + query: 'readonly=true' //Optional: open in read-only mode +})); +``` +#### Opciones del sistema de archivos +Tanto los sistemas de archivos `member` como `streamfile` admiten los siguientes parámetros de consulta: + +| Nombre | Tipo | Descripción | +|-------------|-----------|--------------------------------------------------------------| +| `readonly` | `boolean` | Abre el editor de texto en modo de solo lectura. Por defecto, es `false`. | + + +## Conectarse a un sistema + +Es posible que tu API automatice la conexión a un sistema IBM i en lugar de que el usuario utilice la vista de conexión. + + +```ts +const connectionData: ConnectionData = {...}; + +const connected: boolean = await vscode.commands.executeCommand(`code-for-ibmi.connectDirect`, connectionData); + +if (connected) { + // do a thing. +} else { + // something went wrong. +} +``` + +# Integración con VS Code + +## Opciones del menú contextual (clic derecho) + +Es posible que tu extensión añada opciones al menú contextual (clic derecho) para: + +- objetos en el Explorador de Objetos +- miembros en el Explorador de Objetos +- directorios en el Explorador de Sistemas de Archivos (IFS) +- archivos de flujo en el Explorador de Sistemas de Archivos (IFS) +- y mucho más + +Registrarías un comando como normalmente esperarías, pero espera un parámetro para el nodo elegido desde la vista de árbol. Aquí tienes un ejemplo para eliminar un archivo de flujo en el Explorador de Sistemas de Archivos (IFS). + +```js +context.subscriptions.push( + // `node` is the object passed in directly from the IFS Browser. + vscode.commands.registerCommand(`code-for-ibmi.deleteIFS`, async (node) => { + if (node) { + //Running from right click + let result = await vscode.window.showWarningMessage(`Are you sure you want to delete ${node.path}?`, `Yes`, `Cancel`); + + if (result === `Yes`) { + // directory using the connection API. + const connection = instance.getConnection(); + + try { + // Run a pase command + await vscode.commands.executeCommand(`code-for-ibmi.runCommand`, { + command: `rm -rf "${node.path}`, + environment: `pase`, + }); + + vscode.window.showInformationMessage(`Deleted ${node.path}.`); + + this.refresh(); + } catch (e) { + vscode.window.showErrorMessage(`Error deleting streamfile! ${e}`); + } + } + } else { + // If it's reached this point, it usually + // indicates that it's running from the command palette + } + }) +); +``` + +Después de eso, necesitamos registrar el comando para que tenga una etiqueta. Hacemos esto en `package.json` + +```json +{ + "command": "code-for-ibmi.deleteIFS", + "title": "Delete object", + "category": "Your extension" +} +``` + +Finalmente, lo agregamos a un menú contextual: + +```json +"menus": { + "view/item/context": [ + { + "command": "code-for-ibmi.deleteIFS", + "when": "view == ifsBrowser", + "group": "yourext@1" + }, + ] +} +``` + +**Al agregar tu comando a un contexto de menú**, hay muchas posibles valores para tu cláusula `when`: + +- `view` puede ser `ifsBrowser` o `objectBrowser`. +- `viewItem` puede ser diferente dependiendo de la vista: + - para `ifsBrowser`, puede ser `directory` o `streamfile`. + - para `objectBrowser`, puede ser `member` (miembro fuente), `object` (cualquier objeto), `SPF` (archivo fuente) o `filter`. + +Esto permite que tu extensión proporcione comandos para tipos específicos de objetos o elementos específicos en el árbol de vista. + +[Lee más sobre la cláusula when en el sitio web de la documentación de VS Code.](https://code.visualstudio.com/api/references/when-clause-contexts) + +## Vistas + +Code for IBM i proporciona un contexto para que puedas controlar cuándo puede funcionar un comando, vista, etc. `code-for-ibmi.connected` se puede y debe usar si tu vista depende de una conexión. Por ejemplo, + +Esto mostrará una vista de bienvenida cuando no haya conexión: + + +```json + "viewsWelcome": [{ + "view": "git-client-ibmi.commits", + "contents": "No connection found. Please connect to an IBM i.", + "when": "code-for-ibmi:connected !== true" + }], +``` + +Esto mostrará una vista cuando haya una conexión: + +```json + "views": { + "scm": [{ + "id": "git-client-ibmi.commits", + "name": "Commits", + "contextualTitle": "IBM i", + "when": "code-for-ibmi:connected == true" + }] + } +``` + +# Preguntas frecuentes (FAQ) + +## Obtener la biblioteca temporal + +Recuerda que no puedes utilizar `QTEMP` entre comandos, ya que cada comando se ejecuta en un nuevo trabajo. Consulta `instance.getConfig().tempLibrary` para obtener la biblioteca temporal del usuario. + +## ¿Existe una conexión? + +Puedes utilizar `instance.getConnection()` para determinar si hay una conexión: + + +```ts +async getChildren(element) { + const connection = instance.getConnection(); + + let items: TreeItem[] = []; + + if (connection) { + //Do work here... + + } else { + items = [new vscode.TreeItem(`Please connect to an IBM i and refresh.`)]; + } + + return items; +} +``` +## Contexto `connected` + +Si te refieres a la sección **Vistas**, puedes configurar la vista para que solo se muestre cuando estás conectado. Esto significa que, cuando se utiliza la vista, debería existir una conexión. + +```json +"views": { + "explorer": [{ + "id": "yourIbmiView", + "name": "My custom View", + "contextualTitle": "Extension name", + "when": "code-for-ibmi:connected == true" + }] +} +``` + +```json +"activationEvents": [ + "onView:yourIbmiView" +] +``` + +## Ejemplos + +Consulta los siguientes repositorios de código para obtener ejemplos extensos de extensiones que utilizan Code for IBM i: + +* [Extensión de VS Code para gestionar servicios IWS en IBM i](https://github.com/halcyon-tech/vscode-ibmi-iws) +* [Extensión Git para IBM i](https://github.com/halcyon-tech/git-client-ibmi) + +# Variable de entorno vscode-ibmi + +Proporcionamos variables de entorno para que Code for IBM i pueda ser controlado por entornos gestionados. Consulta [Variables](./variables.md). diff --git a/docs/es/pages/dev/getting_started.md b/docs/es/pages/dev/getting_started.md new file mode 100644 index 0000000..447c5e5 --- /dev/null +++ b/docs/es/pages/dev/getting_started.md @@ -0,0 +1,48 @@ +Es muy fácil trabajar con la extensión vscode-ibmi. + +### Desarrollo y depuración + +1. Clona el repositorio. +2. `npm i` +3. Ejecuta 'Run extension' desde la depuración de VS Code. + +### Crear un archivo `.vsix` + +Para construir un archivo `.vsix` de la extensión, puedes usar: + +```terminal +npm run package +``` +### Ejecutar casos de prueba + +Para ejecutar las pruebas, inicia la depuración de la configuración **Extension Tests** y conéctate a un sistema para que se ejecuten las pruebas. + +![test debug](../../../assets/dev_01.png) + +Después de que se lance el Extension Host, conéctate a un sistema; este sistema es donde se ejecutarán las pruebas. Las pruebas no deben alterar ninguna configuración del sistema ni archivos existentes. + + + + + +Después de conectarte, las pruebas se iniciarán automáticamente. Puedes ver qué pruebas se están ejecutando en la vista Test Cases. + + + +![test cases view](../../../assets/dev_02.gif) + + + +--- + + + + + +Si una prueba falla, puedes ver el resultado al pasar el mouse sobre la prueba fallida. + + + +![test case fail](../../../assets/dev_03.png) + + diff --git a/docs/es/pages/dev/scope.md b/docs/es/pages/dev/scope.md new file mode 100644 index 0000000..9cdd65d --- /dev/null +++ b/docs/es/pages/dev/scope.md @@ -0,0 +1,33 @@ +## Alcance del Proyecto + +Hasta el año 2023, el proyecto Code for IBM i ha crecido considerablemente. Mientras que Code for IBM i generalmente puede referirse a muchas extensiones, en realidad se refiere a vscode-ibmi. La extensión vscode-ibmi es la extensión Code for IBM i que sirve de base para muchas otras extensiones. + +![](../../../assets/scope.png) + +## Code for IBM i + +vscode-ibmi generalmente proporciona la experiencia de usuario base para el desarrollo de aplicaciones en IBM i, lo cual incluye: + +* Gestionar conexiones y mantener la conexión para el usuario. +* Abrir y explorar objetos/archivos en QSYS.LIB o en el IFS. +* Mantener y ejecutar Acciones para ejecutar comandos en el servidor, generalmente para compilar código fuente y mostrar errores de compilación. +* Mantener la lista de bibliotecas del usuario, la biblioteca actual y los perfiles que se utilizarán cuando se ejecuten Acciones. +* Proporcionar una interfaz de usuario para el depurador IBM i para objetos ILE y OPM. + +vscode-ibmi gestiona la conexión, pero proporciona una API que otras extensiones pueden utilizar para realizar muchas tareas: + +* Ejecutar comandos ILE o PASE en el servidor de conexión. +* Analizar y mostrar resultados de archivos EVFEVENT de la mayoría de los compiladores ILE (C, C++, COBOL, RPGLE, etc.). +* Ejecutar consultas SQL en el servidor. +* Listar directorios en múltiples sistemas de archivos (incluyendo QSYS.LIB y el IFS), así como descargar/subir archivos y/o gestionar su contenido. + +**vscode-ibmi no está destinado** a proporcionar herramientas para un lenguaje, tiempo de ejecución o característica específicos. Toda la funcionalidad actual es lo más genérica posible, manteniendo una experiencia liviana. + +## ¿Qué hago si quiero agregar una nueva característica? + +Considera dónde realmente pertenece tu característica. + +* ¿Estás construyendo una característica para un lenguaje específico? Tal vez pertenezca a una de las muchas extensiones de lenguaje (vscode-rpgle, vscode-clle, etc.). +* ¿Estás construyendo una característica de UX para la base de datos? Entonces probablemente pertenezca a la extensión vscode-db2i. +* ¿Quieres poder ver el contenido de un objeto como un `BNDDIR`, `MSGF`, etc.? Entonces probablemente pertenezca a la extensión vscode-ibmi-fs. +* ¿Quieres corregir un error en la base, o agregar una característica que sea genérica para IBM i y se aplique a todos los lenguajes? Entonces tal vez pertenezca a la base (vscode-ibmi). diff --git a/docs/es/pages/dev/variables.md b/docs/es/pages/dev/variables.md new file mode 100644 index 0000000..bbfced8 --- /dev/null +++ b/docs/es/pages/dev/variables.md @@ -0,0 +1,21 @@ +Proporcionamos algunos valores de contexto y variables de entorno para que las extensiones y entornos gestionados puedan controlar Code for IBM i. + +| Tipo | Nombre | Valores | Comentario | +| ------------------- | ------------------------------------------- | ------------ | -------------------------------------------------------------- | +| Valor de contexto | `code-for-ibmi:libraryListDisabled` | booleano | | +| Valor de contexto | `code-for-ibmi:connectionBrowserDisabled` | booleano | | +| Valor de contexto | `code-for-ibmi:helpViewDisabled` | booleano | | +| Valor de contexto | `code-for-ibmi:objectBrowserDisabled` | booleano | | +| Valor de contexto | `code-for-ibmi:ifsBrowserDisabled` | booleano | | +| Variable de entorno | `DEBUG_CA_PATH` | ruta de cadena | PR pendiente, solo se usa cuando `DEBUG_MANAGED` es true | +| Variable de entorno | `DB2I_DISABLE_CA` | booleano | Específico de la extensión Db2 for i para deshabilitar la asistencia de contenido | + +## Variables de entorno de Sandbox + +Cuando se establecen estas variables, Code for IBM i se conectará automáticamente utilizando estas variables de entorno. + +| Nombre | Valores | +| ----------------- | ------ | +| `SANDBOX_SERVER` | cadena | +| `SANDBOX_USER` | cadena | +| `SANDBOX_PASS` | cadena | diff --git a/docs/es/pages/developing/actions/custom-vars.md b/docs/es/pages/developing/actions/custom-vars.md new file mode 100644 index 0000000..0586a3b --- /dev/null +++ b/docs/es/pages/developing/actions/custom-vars.md @@ -0,0 +1,69 @@ + + + + +Puedes crear variables personalizadas para usar en tus cadenas de "Comando a ejecutar". Para acceder a las variables personalizadas: + +Usa F1, luego busca "IBM i Custom variables": + + + + ![F1 + Variable Personalizada IBM i](../../../../assets/actions_custom_01.png) + + + +--- + + + + + + O desde el navegador de Lista de Bibliotecas del Usuario: + + + +![Navegador de Lista de Bibliotecas](../../../../assets/actions_custom_01a.png) + + + +--- + + + + + +En la pestaña **Trabajar con Variables**, haz clic en **Nueva Variable** para agregar tu variable. + +Haz clic en una variable personalizada para cambiarla o eliminarla. + + + +![Lista de Variables después de Guardar](../../../../assets/actions_custom_04.png) + + + +--- + + + + + +Aquí estamos agregando una variable llamada `&TARGET_RLSE`. + +Presiona Guardar y se mostrará la lista de variables personalizadas. + + + +![Añadiendo TARGET_RLSE](../../../../assets/actions_custom_03.png) + + + +--- + +#### *Ejemplo de Uso* + +En todas las acciones CRTBNDxxx, agrega TGTRLS(&TARGET_RLSE), así: + +`?CRTBNDCL PGM(&OPENLIB/&OPENMBR) SRCFILE(&OPENLIB/&OPENSPF) OPTION(*EVENTF) DBGVIEW(*SOURCE) TGTRLS(&TARGET_RLSE)` + +Ahora, un solo cambio a la variable personalizada TARGET_RLSE puede afectar a todas las acciones CRTBNDxxx. diff --git a/docs/es/pages/developing/actions/execution.md b/docs/es/pages/developing/actions/execution.md new file mode 100644 index 0000000..ccfbf8f --- /dev/null +++ b/docs/es/pages/developing/actions/execution.md @@ -0,0 +1,145 @@ +Hay cuatro variedades de Acciones: + +- si el tipo es `file` y 'deploy first' está habilitado, despliega el espacio de trabajo, luego: +- ejecutar inmediatamente, +- o pueden mostrarse para su modificación, +- o pueden solicitarse a través de la interfaz de usuario. + +## Ejecutar Inmediatamente + +Si tenemos un comando "**Llamar programa**" con una cadena "Comando a ejecutar" como esta: + +`CALL &LIBRARY/&NAME` + +Se ejecutará inmediatamente al seleccionarlo. + +## Mostrar para Modificación + + + + + + +Si la cadena "Comando a ejecutar" tiene un `?` al principio, como `?CALL &LIBRARY/&NAME`, entonces el comando se muestra y es editable antes de ejecutarse. + + + +![Acción Mostrada para Modificación](../../../../assets/actions_exec_01.png) + + + + + + + +Por ejemplo, podrías querer agregar `PARM('Douglas' 'Adams')` al final. + + + +![Acción Modificada](../../../../assets/actions_exec_02.png) + + + +## Solicitado + +En lugar de usar el "?", puedes hacer que la Acción solicite valores. +La cadena "Comando a ejecutar" puede tener cadenas de solicitud incrustadas para invocar la solicitud. + +Una "cadena de solicitud" tiene el formato ``${NAME|LABEL|[DEFAULTVALUE]}`` donde: + +- NAME es un nombre arbitrario para el campo de solicitud, pero debe ser único para esta acción. +- LABEL es el texto para describir el campo de solicitud. +- [DEFAULTVALUE] es un valor **opcional** para prellenar el campo de solicitud. + +--- + +### *Ejemplo 1* + + + + + +Supongamos que tenemos una acción "**Llamar programa, solicitar parámetros**" con el "Comando a ejecutar" definido así: + + + +``` +CALL &LIBRARY/&NAME PARM('${AAA|First name|Your name}' '${xyz|Last Name}') +``` + +Si ejecutamos la acción, solicita así: + + + +![Ejemplo de Acción de Solicitud 1](../../../../assets/actions_exec_03.png) + + + + + + + + +Si completamos la pantalla así: + +y hacemos clic en **Ejecutar**, se ejecuta un comando como este; + + +``` +CALL LENNONS1/ATEST PARM('Douglas' 'Adams') +``` + + + +![Acción Solicitada Completada](../../../../assets/actions_exec_04.png) + + + +--- + +### *Ejemplo 2* + + + + + +También puedes usar variables en la cadena de solicitud. Si una acción está definida así: + + + +``` +CALL &LIBRARY/&NAME PARM('${AAA|Library|&CURLIB}' '${xyz|Report Name}') +``` + +&CURLIB será sustituido y la solicitud se verá así cuando se ejecute: + + + +![Ejemplo de Acción Solicitada 2](../../../../assets/actions_exec_05.png) + + + +--- + +### *Ejemplo 3* + + + + + +Aquí tienes un ejemplo más complejo de una acción "**Ejecutar CRTBNDRPG (entradas)**". +La cadena 'Comando a ejecutar" está definida así: + + +``` +CRTBNDRPG PGM(${buildlib|Build library|&BUILDLIB}/${objectname|Object Name|&NAME}) SRCSTMF('${sourcePath|Source path|&FULLPATH}') OPTION(*EVENTF) DBGVIEW(*SOURCE) TGTRLS(*CURRENT) +``` + + +Cuando se ejecuta, solicita así: + + + +![Panel a la derecha](../../../../assets/compile_04.png) + + diff --git a/docs/es/pages/developing/actions/index.md b/docs/es/pages/developing/actions/index.md new file mode 100644 index 0000000..7a6a73f --- /dev/null +++ b/docs/es/pages/developing/actions/index.md @@ -0,0 +1,74 @@ +# ¿Qué son las Acciones? + +Una acción se utiliza para realizar una tarea en un miembro, archivo de flujo u otro tipo de objeto. Un conjunto completo de acciones predeterminadas se carga directamente desde la extensión. También puedes cambiar o agregar fácilmente acciones, consulta *Ver/Cambiar/Agregar Acciones*, a continuación. + +Las acciones son comandos definidos que se utilizan para realizar tareas en miembros, archivos de flujo y otros tipos de objetos. Por ejemplo, para compilar un archivo fuente. Las acciones se pueden ejecutar desde dos lugares diferentes: + +- Mientras estás escribiendo código. Por ejemplo, para compilar un programa o módulo. +- Al hacer clic derecho en un miembro, archivo de flujo o un objeto desde el NAVEGADOR DE OBJETOS. + +Se proporciona un conjunto completo de Acciones, pero puedes agregar más o cambiar las proporcionadas. + +## Ejecutar una Acción + +Para ejecutar una Acción, abre un miembro fuente (o archivo de flujo IFS) y presiona la tecla de acceso directo: + +- Windows: Control + E +- Mac: Command + E + +Esto muestra un menú desplegable de las Acciones disponibles para el archivo abierto. Usa las teclas de flecha para seleccionar qué Acción ejecutar y presiona Enter para seleccionarla. + +Ejemplo: para ejecutar la Acción 'CRTBNDRPG', debes abrir un miembro fuente con la extensión `RPG` o `RPGLE`. Luego, cuando uses la tecla de acceso directo Ejecutar Acción (arriba), verás la lista de Acciones disponibles. + +## Ver/Cambiar/Agregar Acciones + + + + + +**Coloca el cursor sobre el nombre de tu conexión** en la barra de estado y cuando aparezca el menú, selecciona Acciones para mostrar una lista de Acciones disponibles. + +- Haz clic en una acción para cambiarla. +- Agrega acciones con Nueva Acción. +- Copia una acción existente y modifícala con Duplicar. + + + +![Interfaz de Lista de Acciones](../../../../assets/actions_01.png) + + + +--- + + + + + +Agregar o cambiar Acciones muestra la misma interfaz. + +En el ejemplo, estamos editando 'Crear programa RPG vinculado (CRTBNDRPG)'. Podemos cambiar cualquiera de las propiedades. + +- '**Comando a ejecutar**' es el comando que se ejecutará. Observa que tiene porciones de texto que comienzan con un `&` (y comercial) - ese texto es una "variable" que se sustituirá cuando se ejecute la acción. Los comandos pueden tener diferentes variables según el 'Tipo' (miembro, archivo de flujo, objeto) especificado. Además de las variables proporcionadas, puedes crear tus propias variables. Consulta "Variables personalizadas", a continuación. + +- '**Extensiones**' define la lista de extensiones que pueden usar esta Acción. Para `CRTBNDRPG`, generalmente significa solo `RPGLE` y `RPG`, por lo que ingresaríamos: `RPGLE, RPG`. + +- '**Tipos**' determina qué tipo de objeto puede ejecutar esta acción. Por ejemplo, si tu Acción solo se aplica a miembros fuente, elige 'Miembro' en el menú desplegable. + +- '**Entorno**' determina dónde se debe ejecutar el comando. En este caso, `CRTBNDRPG` debe ejecutarse en el entorno ILE ya que es un comando ILE. También tienes la opción de ejecutar comandos a través de PASE o QShell. + +Cuando hayas terminado, **haz clic en Guardar**. Si simplemente cierras la pestaña, nada se guardará. + + + +![Interfaz de edición de Acciones](../../../../assets/actions_02.png) + + + +--- + +### Almacenamiento de Acciones + +Si cambias o agregas acciones como se muestra a continuación, entonces todas las acciones se guardan en la sección `code-for-ibmi.actions` en `settings.json`. También puedes editar la sección `code-for-ibmi.actions` manualmente. Si no existe, puedes crear tu propia sección `code-for-ibmi.actions` en `settings.json`. + +> [!ADVERTENCIA] +> Cuando existe una sección `code-for-ibmi.actions` en `settings.json`, el conjunto de acciones se carga desde allí, no desde el conjunto predeterminado en la extensión. No recomendamos editar manualmente `settings.json` y en su lugar usar la vista de Acciones. diff --git a/docs/es/pages/developing/debug/debug.md b/docs/es/pages/developing/debug/debug.md new file mode 100644 index 0000000..068fe76 --- /dev/null +++ b/docs/es/pages/developing/debug/debug.md @@ -0,0 +1,228 @@ +# Depuración ILE + +Ahora es posible depurar programas ILE dentro de Visual Studio Code. Se ha agregado una interfaz de usuario para garantizar que la configuración del Servicio de Depuración sea un proceso rápido. + +## Comenzando la depuración + + + + + +Después de configurar el Servicio de Depuración, iniciar una sesión de depuración está a solo un clic de distancia. Cuando tengas un código fuente activo abierto, aparecerá un nuevo botón de Depuración en la barra de navegación. Los puntos de interrupción pueden establecerse antes o durante la sesión de depuración. + + + +![](./debug1.png) + + + +--- + + + + + +Hacer clic en el botón de Depuración mostrará un cuadro de entrada que permitirá al usuario personalizar el comando que inicia el trabajo de depuración. Esto permite al desarrollador pasar parámetros o llamar a otro programa para iniciar la sesión de depuración. + +Después de iniciar la sesión de depuración, cada sesión se detendrá al entrar. Puedes obtener más información sobre la interfaz de usuario de depuración en la [sección de acciones de depuración en la documentación de Visual Studio Code](https://code.visualstudio.com/docs/editor/debugging#_debug-actions). + + + +![](./debug2.png) + + + +--- + + + + + +Para depurar un programa desde el Explorador de Objetos, haz clic derecho en el objeto del programa y selecciona la opción **Depurar Programa**. Como antes, esto también mostrará un cuadro de entrada para modificar el comando que inicia el trabajo de depuración. + + + +![](./debug3.png) + + + +# Configurando el depurador + +## Requisitos generales + +* PTFs +* Configuración de certificados en el servidor + * creados en `/QIBM/ProdData/IBMiDebugService/bin/certs` +* Extensión de Depuración IBM i + * instalada en Visual Studio Code +* Cliente local de certificados (**opcional**) + * puede importarse con el comando 'Importar certificado local' + +## PTFs requeridos + +Para utilizar el Servicio de Depuración, necesitas los siguientes PTFs: + +* Depurador del host en 5770SS1: + * IBM i 7.5 PTF SI83666 y SI81035 + * IBM i 7.4 PTF SI83683 y SI81031 + * IBM i 7.3 PTF SI83692 y SI80858 + +Después de instalar los PTFs, la conexión dentro de Visual Studio Code deberá reiniciarse. + +## Configurando y comenzando el servicio + + + + + +Después de conectarte a un sistema en Code for IBM i, si los PTFs están instalados pero el servicio no está configurado (es decir, los certificados no existen), verás un aviso preguntando si quieres abrir el Asistente para configurar el Servicio de Depuración. Hacer clic en el botón abrirá el Asistente. + + + +![](./setup1.png) + + + +--- + +> [!CONSEJO] +> Solo debe haber una instancia del Servicio de Depuración en ejecución. Todos los desarrolladores comparten el Servicio de Depuración. + +### Generando certificados + + + + + +Este Asistente puede configurar fácilmente el Servicio de Depuración y ponerlo en marcha. Los últimos pasos tienen botones para 'Generar certificados' y 'Iniciar servicio de depuración'. Ejecutarlos en orden hará todo el trabajo para configurar el servicio. + +*Te pedirá que confirmes la inicialización.* + + + +![](./setup2_a.png) + + + +--- + +### Iniciando el servidor + + + + + +El botón 'Iniciar servicio de depuración' pondrá en marcha el Servicio de Depuración. Si el Servicio de Depuración ya está en ejecución, te preguntará si deseas finalizar la instancia existente antes de iniciar una nueva, ya que es un requisito. No se recomienda ejecutar dos instancias del Servicio de Depuración a la vez. + + + +![](./setup3_a.png) + + + + + + + +También puedes iniciar el Servicio de Depuración desde el menú de comandos: + + + +![](./setup3_b.png) + + + +--- + +## Puertos del Servicio de Depuración + +El Servicio de Depuración depende de dos puertos de forma predeterminada: + +* Puerto 8001 (puerto no seguro) + * este puerto no se utiliza para nada en relación con la depuración, aunque es necesario para iniciar y detener el Servicio de Depuración +* Puerto 8005 (puerto seguro) + * este puerto es utilizado por todos los clientes de depuración y es necesario para iniciar el Servicio de Depuración. + +Estos puertos pueden cambiarse en `/QIBM/ProdData/IBMiDebugService/bin/DebugService.env`, en `DBGSRV_PORT` y `DBGSRV_SECURED_PORT` respectivamente. + +Si se cambia `DBGSRV_SECURED_PORT`, asegúrate de: + +* reiniciar el Servicio de Depuración +* cambiar el número de puerto del Servicio de Depuración en la configuración de conexión a tu nuevo puerto (`DBGSRV_SECURED_PORT`). **Cada usuario deberá hacer este paso.** + +# Preguntas frecuentes + +### ¿Cuál es la diferencia entre el Servicio de Depuración y el Servidor de Depuración? + + + + + +Como se muestra en este diagrama, el cliente (VS Code, IBM i Debug) se conecta al Servicio de Depuración, que se comunica con el Servidor de Depuración. + +* El Servicio de Depuración se inicia dentro de Visual Studio Code como se documenta anteriormente. En el futuro, también será posible iniciarlo desde Navigator for i. +* El Servidor de Depuración se inicia con `STRDBGSVR`. Puedes recibir un mensaje de error en VS Code si intentas depurar cuando el Servidor de Depuración no está en ejecución. + + + +![](./debug4.png) + + + +### No puedo ver las variables al depurar CL + + + + + +Esto es una limitación para CL. Las variables locales no se mostrarán en la vista de Variables para CL. Puedes agregar una variable local a la vista Watch para inspeccionar su valor. La limitación de CL también existe en RDi. + +[Ver problema en GitHub aquí](https://github.com/halcyon-tech/vscode-ibmi/issues/1069). + + + +![](./debug5.png) + + + +# Problemas comunes + +## La depuración se cuelga + +Hay un [problema conocido](https://github.com/halcyon-tech/vscode-ibmi/issues/1059) que cuando inicias la depuración desde VS Code, el depurador se cuelga y no se inicia. + +La solución es verificar si tienes un trabajo de depuración anterior bloqueado en `MSGW`. Puedes hacer esto con `WRKACTJOB`, o un comando similar como `WRKSBSJOB QBATCH`. + +**Los usuarios ya no deberían enfrentar este problema** ya que ahora enviamos trabajos de depuración a `QSYSWRK` con `QSYSNOMAX`. + +## Requisito de `STRDBGSVR` + +El Servicio de Depuración que se inicia depende del Servidor de Depuración tradicional. + +![](./error_2.png) + +Si recibes este mensaje, haz lo que dice. Simplemente inicia el Servidor de Depuración con `STRDBGSVR` desde una pantalla verde. + +## IP no en la lista de certificados + +**Siempre se recomienda usar un nombre de host en la configuración de conexión para aprovechar el depurador cuando esté en modo seguro**. + +![](./error_1.png) + +*Error que se muestra al conectar al depurador si se utiliza una dirección IP.* + +Este error ocurre cuando el nombre de host utilizado para conectarse al depurador (que podría ser la dirección IP configurada en la configuración de conexión) no es el mismo que el nombre de host creado como parte del certificado. + +Si estás utilizando un sistema que no tiene un nombre de host (por ejemplo, `TUSISTEMA` o `pub400.com`), se debe agregar una entrada al archivo 'hosts' de tu dispositivo. Esta entrada debe ser la misma en todos los dispositivos de tu red para asegurar que todos estén utilizando el mismo nombre de host. + +* Windows: `c:\Windows\System32\Drivers\etc\hosts` +* Mac: `/etc/hosts` + +Tu entrada podría parecerse a esto: + + +```hosts +# IP HOSTNAME +192.168.0.20 MYIBMI +``` +Si descubres que has agregado la entrada de tu nombre de host local y el error aún ocurre, es posible que necesites eliminar los certificados existentes de `/QIBM/ProdData/IBMiDebugService/bin/certs` en el IFS y generarlos nuevamente en el Asistente. diff --git a/docs/es/pages/developing/debug/debug1.png b/docs/es/pages/developing/debug/debug1.png new file mode 100644 index 0000000..9793558 Binary files /dev/null and b/docs/es/pages/developing/debug/debug1.png differ diff --git a/docs/es/pages/developing/debug/debug2.png b/docs/es/pages/developing/debug/debug2.png new file mode 100644 index 0000000..885e5ad Binary files /dev/null and b/docs/es/pages/developing/debug/debug2.png differ diff --git a/docs/es/pages/developing/debug/debug3.png b/docs/es/pages/developing/debug/debug3.png new file mode 100644 index 0000000..99e2ef9 Binary files /dev/null and b/docs/es/pages/developing/debug/debug3.png differ diff --git a/docs/es/pages/developing/debug/debug4.png b/docs/es/pages/developing/debug/debug4.png new file mode 100644 index 0000000..0d5db5f Binary files /dev/null and b/docs/es/pages/developing/debug/debug4.png differ diff --git a/docs/es/pages/developing/debug/debug5.png b/docs/es/pages/developing/debug/debug5.png new file mode 100644 index 0000000..faa5ae3 Binary files /dev/null and b/docs/es/pages/developing/debug/debug5.png differ diff --git a/docs/es/pages/developing/debug/error_1.png b/docs/es/pages/developing/debug/error_1.png new file mode 100644 index 0000000..3b23e61 Binary files /dev/null and b/docs/es/pages/developing/debug/error_1.png differ diff --git a/docs/es/pages/developing/debug/error_2.png b/docs/es/pages/developing/debug/error_2.png new file mode 100644 index 0000000..ea8d154 Binary files /dev/null and b/docs/es/pages/developing/debug/error_2.png differ diff --git a/docs/es/pages/developing/debug/setup1.png b/docs/es/pages/developing/debug/setup1.png new file mode 100644 index 0000000..ad60a93 Binary files /dev/null and b/docs/es/pages/developing/debug/setup1.png differ diff --git a/docs/es/pages/developing/debug/setup2_a.png b/docs/es/pages/developing/debug/setup2_a.png new file mode 100644 index 0000000..c37455b Binary files /dev/null and b/docs/es/pages/developing/debug/setup2_a.png differ diff --git a/docs/es/pages/developing/debug/setup3_a.png b/docs/es/pages/developing/debug/setup3_a.png new file mode 100644 index 0000000..c7805d1 Binary files /dev/null and b/docs/es/pages/developing/debug/setup3_a.png differ diff --git a/docs/es/pages/developing/debug/setup3_b.png b/docs/es/pages/developing/debug/setup3_b.png new file mode 100644 index 0000000..fd86c54 Binary files /dev/null and b/docs/es/pages/developing/debug/setup3_b.png differ diff --git a/docs/es/pages/developing/editing-compiling.md b/docs/es/pages/developing/editing-compiling.md new file mode 100644 index 0000000..9c632d2 --- /dev/null +++ b/docs/es/pages/developing/editing-compiling.md @@ -0,0 +1,166 @@ +## Edición + +Para abrir código fuente, puedes [crear un filtro en el Navegador de Objetos](pages/browsers/object-browser.md) para explorar archivos fuente. + + + + + +Haz clic en un miembro fuente o archivo de flujo en el navegador para abrirlo. Puedes tener varios archivos abiertos. + +Ahora puedes editar el código fuente utilizando todas las funciones de VS Code. + + + + ![Ejemplo de edición](../../../assets/EditComp-01.png) + + + +--- + + + + + +Para maximizar tu pestaña de edición, prueba: + +- Ocultar/mostrar la barra lateral con **Ctrl+B**. (O utilizando el menú Ver.) +- Alternar pantalla completa con **F11** + +Consulta **Ayuda** en el menú para obtener consejos, trucos, atajos de teclado de edición y tutoriales. + + + +![Máximo espacio de edición](../../../assets/EditComp-02.png) + + + +--- + +### Fechas de origen + +El soporte para fechas de origen debe estar habilitado y está desactivado de forma predeterminada. Esto se puede cambiar en la Configuración de Conexión. Consulta más en la [página de Fechas de Origen](sourcedates.md). + +## Compilación + +Compila la **pestaña activa** con Ctrl+E. + +- Si hay cambios sin guardar, se te informará que primero debe guardarse y también se te dará la opción de siempre guardar antes de compilar. +- Si haces clic en **Guardar automáticamente**, las solicitudes de compilación subsiguientes siempre se guardarán primero si hay cambios. (En *Configuración: Conexión*, más abajo, puedes desactivar la opción de guardado automático.) +- Si hay más de una opción de compilación para tu tipo de fuente, selecciona la adecuada. + + + + + +Si la compilación se completa sin errores, verás un mensaje informativo como este: + + + +![Compilación exitosa](../../../assets/EditComp-03.png) + + + +--- + +### Errores de Compilación + + + + + +Si la compilación falla, verás un mensaje de error como este: + + + +![Compilación fallida](../../../assets/EditComp-04.png) + + + +--- + + + + + +En el código fuente, los errores se resaltarán con líneas onduladas y si pasas el ratón por encima de la línea ondulada, verás detalles del error: + + + +![Errores ondulados](../../../assets/EditComp-05.png) + + + +--- + + + + + +Puedes ir al próximo error con **F8**. **Shift+F8** para el error anterior. + + + +![F8 próximo error](../../../assets/EditComp-05A.png) + + + +--- + + + + + +Si tienes la pestaña **Problemas** abierta en el Panel, mostrará la lista de errores. Hacer clic en una línea en la pestaña **Problemas** te llevará a la línea en el código fuente. + +Ctrl+J abre el panel, Ctrt+Shift+M abre la pestaña **Problemas**. + + + +![Pestaña Problemas](../../../assets/EditComp-06.png) + + + +--- + + + + + + + +Decide qué errores, advertencias o mensajes de información mostrar usando el icono de filtro. Si has estado compilando varios fuentes, es posible que también desees marcar **Mostrar solo el archivo activo**. + + + +![Filtro de errores](../../../assets/EditComp-07.png) + + + +--- + +Puedes eliminar todas las líneas onduladas usando **F1** para abrir la paleta de comandos y buscar 'IBM i Clear Diagnostics' + +![Limpiar diagnósticos](../../../assets/EditComp-08.png) + +### Listado de Compilación + +El listado de compilación siempre se dirige a un terminal, en caso de que necesites revisarlo. + +![Listado de Compilación en Terminal](../../../assets/compile_list_01.png) + +#### Notas del Terminal + +- Por lo general, los terminales se encuentran en el panel, como se muestra arriba. En su lugar, también puedes abrirlos en un editor con esta configuración: + + `Terminal › Integrated: Default Location` controla dónde aparecerán los terminales recién creados. + +- Si estás compilando programas grandes, es posible que desees ajustar esta configuración: + + `Terminal › Integrated: Scrollback` controla el número máximo de líneas que el terminal conserva en su búfer. + +- Es posible que desees ajustar la altura de línea en el terminal, con esta configuración: + + `Terminal › Integrated: Line Height` controla la altura de línea del terminal. diff --git a/docs/es/pages/developing/iledocs.md b/docs/es/pages/developing/iledocs.md new file mode 100644 index 0000000..fc51064 --- /dev/null +++ b/docs/es/pages/developing/iledocs.md @@ -0,0 +1,80 @@ +# ILEDocs + +Code for IBM i sigue el estándar ILEDocs para escribir documentación para los lenguajes ILE. Este documento cubre principalmente cómo utilizarlo con RPGLE de formato libre. + +Code for IBM i utilizará el bloque de documentación para mejorar la asistencia de contenido y el soporte de información al pasar el cursor. + +## Formato estándar + +### Diseño + +El formato del bloque de documentación es el siguiente. + +1. Comienza con `///` - esto inicia el bloque de documentación para el procedimiento +2. El primer comentario es el **título** +3. Los siguientes comentarios definen la **descripción** +4. Después de la descripción, se pueden utilizar etiquetas. +5. Finaliza el bloque con `///` nuevamente. + + +```rpgle +/// +// TITLE +// DESCRIPTION! +// Description can be multiline +// @tag data +// @tag data +/// +Dcl-Proc ... +``` +### Puede ser utilizado en + +Los bloques de documentación se pueden utilizar en prácticamente cualquier funcionalidad de RPG: + +* Constantes +* Variables/estructuras +* Procedimientos +* Subrutinas + +### Etiquetas disponibles + +Todas las etiquetas comienzan con `@`. Las etiquetas en negrita son las más comúnmente utilizadas. + +* **param** - varias líneas - Descripción del parámetro +* **return** - varias líneas - Descripción del valor de retorno +* **deprecated** - varias líneas - Descripción de por qué no se debe utilizar un programa o procedimiento y cualquier reemplazo indicado. +* author - una línea - Autor del código fuente +* date - una línea - Fecha (cualquier formato) +* brief (title) - una línea - Debe ser la primera etiqueta en un bloque ILEDocs. La etiqueta también puede ser ignorada, ver ejemplo anterior. +* link - varias líneas - @link http://url Descripción +* rev (revision) - varias líneas - `@rev fecha autor`, las líneas siguientes son la descripción de la revisión +* project - una línea - Nombre del proyecto (para que el módulo pueda ubicarse bajo el proyecto correspondiente en la interfaz de usuario) +* warning - varias líneas +* info - varias líneas +* throws - varias líneas - Id y descripción de un mensaje de escape que el usuario del programa/procedimiento puede esperar en ciertos casos +* version - una línea - Versión del módulo + +## Conceptos básicos + +Reglas básicas: + +* Toda la documentación es opcional, pero cuanto mejor sea la documentación que proporciones, mejor será la asistencia de contenido y la documentación generada. +* Para cada parámetro en un procedimiento, debería haber tantas etiquetas `@param` que proporcionen una breve descripción de qué es el parámetro. +* La primera línea del bloque de documentación siempre es el título. + +```rpgle +/// +// Transform to lowercase +// This procedure will take a string and transform it to lowercase +// +// @param The string +// @return The lowercase value +/// +Dcl-Proc ToLower Export; + Dcl-Pi *N Char(20); + stringIn Char(20); + End-pi; + + return STRLOWER(stringIn); +End-Proc; +``` \ No newline at end of file diff --git a/docs/es/pages/developing/local/actions.md b/docs/es/pages/developing/local/actions.md new file mode 100644 index 0000000..7f02f56 --- /dev/null +++ b/docs/es/pages/developing/local/actions.md @@ -0,0 +1,149 @@ +Al igual que con otras configuraciones de repositorios, los usuarios ahora pueden almacenar Acciones como parte del Workspace. Ahora pueden crear un archivo `.vscode/actions.json` dentro de su Workspace, el cual puede contener Acciones específicas para ese Workspace. Este archivo de configuración también debe incluirse en Git para esa aplicación. + +Al ejecutar Acciones locales, se ejecutarán los comandos con el directorio de trabajo como directorio de implementación. + +Hay una herramienta que puede generar un archivo `actions.json` inicial para ti. Después de conectarte a un sistema, abre la paleta de comandos (F1) y busca 'Launch Actions Setup'. Esto mostrará una ventana de selección múltiple donde el usuario puede elegir las tecnologías que está utilizando. Según la selección, se creará un archivo `actions.json`. + +## Variables Disponibles + +Estas variables se pueden utilizar para el desarrollo local. Se pueden hacer referencias a ellas en `actions.json` o `.env`. + +### Bibliotecas + +| Variable | Descripción | +| --------------- | --------------------------------------------------------------------------------- | +| `&BUILDLIB` | Igual que `&CURLIB` | +| `&CURLIB` | La biblioteca actual definida en la vista de Lista de Bibliotecas del Usuario. También se puede usar `*CURLIB` | +| `&LIBLS` | La lista de bibliotecas con espacios entre cada elemento | +| `&BRANCHLIB` | Un nombre de biblioteca determinista construido a partir de la rama actual en git | + +### Directorios y Archivos + +| Variable | Descripción | +| --------------- | --------------------------------------------------------------------------------- | +| `&RELATIVEPATH` | La ruta relativa al archivo en el espacio de trabajo | +| `&LOCALPATH` | La ruta completa al archivo en la máquina local | +| `&FULLPATH` | La ruta completa al archivo en la máquina remota | +| `&WORKDIR` | El directorio de trabajo. Normalmente significa el directorio de implementación | +| `&PARENT` | El directorio principal local | +| `&BASENAME` | El nombre base del archivo (`nombre.ext`). También se puede usar `{filename}` | +| `&NAME` | El nombre del archivo (o usa `&NAMEL` para minúsculas) | +| `&EXT` | La extensión del archivo (o usa `&EXTL` para minúsculas) | + +### Otros + +| Variable | Descripción | +| --------------- | --------------------------------------------------------------------------------- | +| `&USERNAME` | Nombre de usuario conectado. También se puede usar `{usrprf}` | +| `&HOST` | Nombre de host conectado. También se puede usar `{host}` | +| `&HOME` | Directorio de inicio actual. Normalmente no es el mismo que el directorio de implementación. | +| `&BRANCH` | El nombre actual de la rama en git. También se puede usar `{branch}` | + +## Variables de entorno PASE + +Cuando ejecutas Acciones en el entorno PASE, todas las variables de VS Code (cosas como `&CURLIB`, `&BUILDLIB`, variables personalizadas, variables de `.env`) se heredan al shell PASE creado. + + + + + +Por ejemplo, supongamos que tenemos este script de shell y esta Acción: + +```sh +echo "Welcome" +echo "The current library is $CURLIB" +``` + +```json + { + "name": "Run my shell script", + "command": "chmod +x ./myscript.sh && ./myscript.sh", + "extensions": [ + "GLOBAL" + ], + "environment": "pase", + "deployFirst": true + } +``` + + +Verás la salida: + +``` +Current library: USERLIB +Library list: QDEVTOOLS SAMPLE +Commands: + chmod +x ./myscript.sh && ./myscript.sh + +Welcome +The current library is USERLIB +``` + + + +## Archivo de entorno + +Además de las variables personalizadas definidas en la vista de Lista de Bibliotecas del Usuario, los usuarios también pueden hacer uso del archivo `.env`. + +El archivo `.env` permite a cada desarrollador definir su propia configuración. Por ejemplo, la práctica estándar de desarrollo con Git es que cada desarrollador trabaje en su propio entorno, por lo que los desarrolladores pueden construir en sus propias bibliotecas. El archivo `.env` siempre debe estar en el archivo `.gitignore`. + +Las variables definidas en este archivo sobrescribirán cualquier variable predeterminada proporcionada. + + + + + +### `actions.json` + +```jsonc +// actions.json +[ + { + "name": "Deploy & build with ibmi-bob 🔨", + "command": "error=*EVENTF lib1=&DEVLIB makei -f &BASENAME", + "extensions": [ + "GLOBAL" + ], + "environment": "pase", + "deployFirst": true + } +] +``` + + + +### Archivos `.env` Específicos del Desarrollador + + +```sh +# developer A: +DEVLIB=DEVALIB +``` + +```sh +# developer B: +DEVLIB=DEVBLIB +``` + + + +### Biblioteca de Rama + +`&BRANCHLIB` es una variable especial para generar un nombre de biblioteca basado en el nombre de la rama. La herramienta Source Orbit también admite esta lógica de nombre de biblioteca de rama. + +La variable `&BRANCHLIB` siempre comenzará con `VS`, seguido por un conjunto determinista de 8 caracteres basados en el nombre actual de la rama. + +```jsonc +// actions.json +[ + { + "name": "Deploy & build with ibmi-bob 🔨", + "command": "error=*EVENTF lib1=&BRANCHLIB makei -f &BASENAME", + "extensions": [ + "GLOBAL" + ], + "environment": "pase", + "deployFirst": true + } +] +``` \ No newline at end of file diff --git a/docs/es/pages/developing/local/azure.md b/docs/es/pages/developing/local/azure.md new file mode 100644 index 0000000..21d9ac2 --- /dev/null +++ b/docs/es/pages/developing/local/azure.md @@ -0,0 +1,24 @@ +# Clonar un Proyecto desde Azure DevOps con Visual Studio Code y Git + +Al utilizar Visual Studio Code y Git, es posible abrir automáticamente el proyecto desde Azure DevOps. + +Encuentra el repositorio con el que deseas trabajar en Azure DevOps y presiona el botón "Clone". Asegúrate de que esté seleccionada la opción HTTPS y, antes de continuar, verifica que las credenciales de Git sean visibles, ya que se utilizarán más adelante. + + ![Azure DevOps - Paso 1](../../../../assets/azure-1.png) + +Cuando estés listo, copia la contraseña en tu portapapeles y selecciona 'Clone in VS Code'. Esto abrirá VS Code y se asegurará de que el usuario desee realizar esta acción: + + ![Azure DevOps - Paso 2](../../../../assets/azure-2.png) + +VS Code te preguntará dónde deseas clonar el repositorio. + + ![Azure DevOps - Paso 3](../../../../assets/azure-3.png) + +Cuando la clonación esté completa, te preguntará si deseas abrir la carpeta del repositorio. Seleccionar 'Open' la agregará al Workspace. + +Ahora que el código fuente está en tu máquina local, puedes continuar y conectarte a tu sistema de desarrollo. Dado que esta es una carpeta completamente nueva, se te preguntará si deseas establecer el directorio de implementación predeterminado. Se recomienda utilizar el valor predeterminado. + + ![Azure DevOps - Paso 4](../../../../assets/azure-4.png) + + +Desde aquí, puedes comenzar a desarrollar y compilar. Si es la primera vez, asegúrate de leer la documentación de [Desarrollo Local](getting-started.md) para comprender para qué se utiliza el directorio de implementación y cómo ejecutar comandos de compilación. diff --git a/docs/es/pages/developing/local/getting-started.md b/docs/es/pages/developing/local/getting-started.md new file mode 100644 index 0000000..dd37443 --- /dev/null +++ b/docs/es/pages/developing/local/getting-started.md @@ -0,0 +1,93 @@ +# Desarrollo Local y Implementación en IBM i en Visual Studio Code + +Es posible para el usuario desarrollar en una carpeta de espacio de trabajo local y realizar la implementación y compilación en IBM i. + +Si el usuario abre un espacio de trabajo antes de conectarse a un IBM i: + +1. Un nuevo mensaje de información mostrará al usuario cuál es su biblioteca actual. +2. Si es la primera vez que se conecta con este espacio de trabajo, + * solicitará al usuario que establezca un directorio de implementación predeterminado, + * si no se encuentra un archivo `actions.json`, preguntará al usuario si desea crear uno por defecto. +3. Aparecerá una nueva opción en el menú contextual para implementar en ese directorio. +4. Aparecerá un botón 'Implementar' en la barra de estado. + +## Guías + +* Esta guía paso a paso está disponible [en el libro rpg-git](https://worksofliam.github.io/rpg-git-book/7-tooling-vscode.html). +* Un [tutorial en video en YouTube](https://www.youtube.com/watch?v=XuiGyWptgDA&t=425s), que muestra la configuración desde cero. +* Fácil clonar desde [Azure DevOps](azure.md). + +## 1. Abrir una Carpeta de Espacio de Trabajo + +Abrir una carpeta en Visual Studio Code agrega esa carpeta a ese Espacio de Trabajo. Necesitas tener al menos una carpeta abierta en el espacio de trabajo de Visual Studio Code para el desarrollo local. + +## 2. Establecer la ubicación de implementación + +Si es la primera vez que se conecta con el espacio de trabajo, solicitará al usuario que establezca un directorio de implementación predeterminado. + +![](../../../../assets/local_1.png) + +Si prefiere cambiar la ubicación predeterminada, el usuario puede hacer clic derecho en cualquier directorio en el Explorador del Sistema de Archivos IFS y seleccionar la opción 'Implementar espacio de trabajo en la ubicación'. + +El usuario puede cambiar el directorio de implementación en cualquier momento utilizando la misma opción de clic derecho en otro directorio. + +## 3. El botón de Implementar / Ejecutar el proceso de implementación + +Usar el botón 'Implementar' en la barra de estado iniciará el proceso de implementación. Si el espacio de trabajo tiene más de una carpeta, el usuario deberá seleccionar qué carpeta desea implementar. + +Hay tres opciones para la implementación: + +1. Cambios en Trabajo: Esto solo funciona si la carpeta de espacio de trabajo elegida es un repositorio git. Code for IBM i examinará el estado de git para determinar los archivos que han cambiado desde el último commit (sin confirmar y confirmados) y solo cargará esos archivos. +2. Cambios Etapados: Lo mismo que la opción "Cambios en Trabajo", pero solo carga archivos etapados/indexados. +3. Todos: Cargará todos los archivos en la carpeta de espacio de trabajo elegida. Ignorará los archivos que forman parte del archivo '.gitignore' si existe. + +El usuario también puede definir Acciones que son del tipo 'file' (local) para ejecutar la implementación antes de ejecutar la Acción. + +## 4. Acciones del Espacio de Trabajo (implementar y compilar) + + + +Similar a otras configuraciones de repositorio, los usuarios ahora pueden almacenar Acciones como parte del Espacio de Trabajo. Los usuarios ahora pueden crear `.vscode/actions.json` dentro de su Espacio de Trabajo y puede contener Acciones específicas para ese Espacio de Trabajo. Ese archivo de configuración también debería incluirse en git para esa aplicación. + + + + + +Hay una herramienta que puede generar un archivo `actions.json` inicial para usted. Después de conectarse a un sistema, abra la paleta de comandos (F1) y busque 'Lanzar Configuración de Acciones'. Esto mostrará una ventana de selección múltiple donde el usuario puede elegir qué tecnologías está utilizando. Según la selección, se creará un `actions.json`. + + + +![](../../../../assets/actions_tool.png) + + + +--- + +Aquí hay un ejemplo de configuración de `actions.json`, que requiere que la implementación ocurra antes de activar BoB. VS Code mostrará sugerencias de contenido al trabajar con `actions.json`. Podría reemplazar BoB con cualquier sistema de compilación aquí (por ejemplo, make, o quizás una herramienta específica del proveedor). + +```json +[ + { + "name": "Deploy & build with ibmi-bob 🔨", + "command": "error=*EVENTF lib1=&CURLIB makei -f &BASENAME", + "extensions": [ + "GLOBAL" + ], + "environment": "pase", + "deployFirst": true + }, + { + "name": "Deploy & build with GNU Make 🔨", + "command": "/QOpenSys/pkgs/bin/gmake &BASENAME BIN_LIB=&CURLIB", + "extensions": [ + "GLOBAL" + ], + "environment": "pase", + "deployFirst": true + } +] +``` + +Ahora, cuando el usuario ejecuta una Acción contra el archivo local (con `Control/Command + E`), aparecerán en la lista. + +![imagen](https://user-images.githubusercontent.com/3708366/146957104-4a26b4ba-c675-4a40-bb51-f77ea964ecf5.png) diff --git a/docs/es/pages/developing/local/git.md b/docs/es/pages/developing/local/git.md new file mode 100644 index 0000000..5e1f1d3 --- /dev/null +++ b/docs/es/pages/developing/local/git.md @@ -0,0 +1,31 @@ +# Inicio rápido de Git en IBM i + +Esta página contiene información útil para comenzar con Git en IBM i. Los elementos marcados con 🏢 indican un proveedor (ISV/servicios) o un artículo patrocinado. + +## Git en general + +- [Usar Git con Visual Studio Code (Video tutorial oficial para principiantes)](https://www.youtube.com/watch?v=i_23KUAEtUM&list=PLj6YeMhvp2S7abEHqkUPRkCSt4N2wpTwD&index=7) +- [VS Code y Git (Lista de reproducción)](https://www.youtube.com/watch?v=3o_01F04bZ4&list=PLj6YeMhvp2S7abEHqkUPRkCSt4N2wpTwD) +- [Atlassian: Aprender Git](https://www.atlassian.com/git/tutorials/what-is-version-control) +- [Gitflow Workflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow) + +## Git en IBM i + +- [DevOps en IBM i](https://github.com/worksofliam/blog/issues/37) +- [¿Por qué Git? Introducción (con comparación de gestión de cambios)](https://github.com/worksofliam/blog/issues/19) +- [Estructura del proyecto Git en IBM i](structure.md) +- [El libro de RPG y Git](https://github.com/worksofliam/rpg-git-book/blob/main/1-introduction.md) +- [ITJungle: Integrar Git en su estrategia de modernización](https://www.itjungle.com/2023/06/26/making-git-part-of-your-modernization-strategy/) 🏢 +- [Cinco razones por las que usamos Git para gestionar el código fuente de IBM i](https://www.seidengroup.com/2019/08/14/five-reasons-we-use-git-to-manage-ibm-i-source-code/) 🏢 +- ['True Git': los enfoques correctos e incorrectos para Git en IBM i](https://www.arcadsoftware.com/news-events/blog/true-git-the-right-and-wrong-approaches-to-git-on-ibm-i/) 🏢 + +## VS Code y Git + +- [Visual Studio Code, RPGLE y Git: Tu primer repositorio](https://github.com/worksofliam/blog/issues/61) +- [Usar VS Code para escribir tu código RPGLE (video)](https://www.youtube.com/watch?v=qDjXzKP0RYg) +- [Creando tu primer proyecto IBM i (video)](https://www.youtube.com/watch?v=XuiGyWptgDA) + +## RDi y Git + +- [Cómo usar el control de fuente con RDi](https://www.ibm.com/support/pages/how-use-source-control-rdi) +- [Usar una línea de comandos Git en RDi](https://www.youtube.com/watch?v=bO6I86IoLko) diff --git a/docs/es/pages/developing/local/migrate.md b/docs/es/pages/developing/local/migrate.md new file mode 100644 index 0000000..fa8a455 --- /dev/null +++ b/docs/es/pages/developing/local/migrate.md @@ -0,0 +1,215 @@ +## Qué significa la migración + +La migración realmente significa copiar el contenido del miembro fuente al IFS. Solo una persona tiene que realizar este paso. Una vez que todo el código fuente se haya migrado a git, recomendaría que **los desarrolladores comiencen a desarrollar localmente con su nuevo repositorio git**. Si permites que alguien edite los miembros fuente mientras migras el código al IFS, tendrás que volver a copiar los miembros modificados. + + + + + +Por ejemplo, tu biblioteca, archivos físicos de origen y miembros podrían verse así: + + +``` +DEVLIB + - QRPGLESRC + - PROGRAMA.RPGLE + - PROGRAMB.RPGLE + - PROGRAMC.RPGLE + - QSQLSRC + - CUSTOMERS.SQL + - INVENTORY.SQL + - QCLLESRC + - STARTJOB.CLLE + - QCMDSRC + - STARTJOB.CMD +``` + + + +Donde la disposición resultante en el IFS podría ser muy similar: + + +``` +/home + /barry + /.git + /qrpglesrc + programa.rpgle + programb.rpgle + programc.rpgle + /qsqlsrc + customers.sql + inventory.sql + /qcllesrc + startjob.cmd + /qcmdsrc + startjob.cmd +``` + + + +Asegúrate de que al migrar el código, lo estás haciendo en un directorio que es un repositorio local (por ejemplo, que lo clonaste) para que puedas confirmar y enviar cambios a medida que los realizas. Por ejemplo, realiza tu primer commit cuando hayas migrado el código y luego realiza otro (o varios) después de corregir los 'copybooks'. + +**Notas sobre la migración al IFS**: + +1. Perderás la columna TEXT que tienen los miembros fuente, que generalmente se usa para describir qué es el fuente. Sin embargo, aún puedes colocar eso en el programa como un comentario. +2. El tipo del miembro fuente se convierte en la extensión cuando está en el IFS. +3. Los archivos y directorios de fuentes generalmente se almacenan en minúsculas. +4. Se recomienda retener el límite de 10 caracteres en programas, comandos, módulos, etc. - cualquier fuente relacionada con Db2 para i no importa tanto, ya que Db2 para i y la mayoría de los lenguajes ILE admiten 'nombres largos'. + +## Herramientas utilizadas para la migración + +La migración inicial del código fuente puede ser la parte más difícil de todo el proceso, pero una vez que se hace: ¡se hace! Hay muchas formas de hacerlo, pero aquí solo describiré dos. + +### Migración manual + +Una migración consiste simplemente en mover los miembros fuente al IFS. Para nuestra ventaja, existe el comando `CPYTOSTMF`, que se puede utilizar para copiar un miembro fuente a un archivo de flujo. Por ejemplo: + + +``` +CPYTOSTMF FROMMBR('/QSYS.lib/DEVLIB.lib/QRPGLESRC.file/PROGRAMA.mbr') TOSTMF('/home/barry/myproject/qrpglesrc/programa.rpgle') STMFOPT(*REPLACE) STMFCCSID(1208) +``` + +En base a este comando, tendrías que ejecutar este comando para cada miembro fuente que desees migrar. + +### Uso de la herramienta de migración + +Existe una herramienta de migración de código abierto, simplemente llamada 'migrate', que automatiza la copia de miembros fuente en un directorio. También crea los archivos de flujo con las extensiones correctas. + +Para usar la herramienta de migración, deberás clonarla y construirla manualmente. + + +``` +git clone https://github.com/worksofliam/migrate.git +cd migrate +gmake +``` + +La construcción de esta solución creará la biblioteca `MIGRATE` y dentro está el comando `MIGSRCPF`. `MIGSRCPF` tiene tres parámetros simples. + +![](./images/migsrcpf.PNG) + +Si tuviéramos una biblioteca con archivos físicos de origen y quisiéramos migrarlos a un nuevo directorio del proyecto, tendríamos que ejecutar el comando una vez para migrar el archivo físico de origen. Copiará el miembro fuente al IFS como un archivo de flujo de 1208 (UTF-8). Si el archivo o la carpeta que intenta crear ya existe, fallará. En el último capítulo, creamos `/home/BARRY/myproject` como un repositorio git. + +Esto crearía tres directorios en `/home/BARRY/myproject` como se muestra a continuación: + + + + + +```cl +MIGSRCPF LIBRARY(TESTPROJ) + SOURCEPF(QRPGLESRC) + OUTDIR('/home/BARRY/myproject') +MIGSRCPF LIBRARY(TESTPROJ) + SOURCEPF(QRPGLEREF) + OUTDIR('/home/BARRY/myproject') +MIGSRCPF LIBRARY(TESTPROJ) + SOURCEPF(QCLLESRC) + OUTDIR('/home/BARRY/myproject') +``` + + + +``` +/home + /BARRY + /myproject + /qrpglesrc + /somesource.rpgle + /somesource.rpgle + /qrpgleref + /whatever.rpgle + /qcllesrc + /pgm1.clle + /pgm2.clle + /pgm3.clle +``` + + + +> [!NOTE] +> Creará todos los directorios y archivos de flujo con nombres en minúsculas. + +### Herramienta de migración de IBM Project Explorer + +Consulta la documentación de IBM Project Explorer sobre cómo utilizar [su proceso de migración](https://ibm.github.io/vscode-ibmi-projectexplorer/#/pages/projectExplorer/migrate-source). + +### Otras posibles formas + +Potencialmente podrías crear un iProject en RDi basado en una biblioteca y luego tener una copia local de todo el código fuente (que luego puedes poner en un repositorio git más tarde). También puedes usar la herramienta SPF Clone en ILEditor para clonar los miembros fuente de las bibliotecas en tu máquina local (que también se puede poner en un repositorio git más tarde). + +### No olvides confirmar cambios + +Asegúrate de que, al haber terminado de migrar el código fuente a tu repositorio local de desarrollador. Por ejemplo: + + +``` +git add --all +git commit -m "Initial migration step" +git push +``` + +Querrás hacer esto nuevamente (quizás varias veces) a medida que cambies los 'copybooks' también. + +## Manejo de 'copybooks' (`/COPY` y `/INCLUDE`) + +Una vez que el código fuente ha sido migrado, otra tarea tediosa es cambiar todos los copybooks para que apunten a tus archivos de flujo recién migrados. Tenemos la suerte de que los compiladores de C, RPG y COBOL para IBM i admiten la inclusión de archivos desde el IFS. En este capítulo, usaremos RPG ya que es el público objetivo principal de este libro. + +Digamos que tenemos un programa que tiene declaraciones `/COPY` (o `/INCLUDE`) como las siguientes en la parte superior del código fuente: + + + +``` + + /COPY QRPGLEREF,OBJECTS + /COPY QRPGLEREF,OBJECT + /COPY QRPGLEREF,FORMATS + /COPY QRPGLEREF,MEMBERS + + ** -------------------------- + + D testproj PI + D pLibrary 10A Const + + ** -------------------------- + +``` + +Aunque este código fuente podría estar en el IFS, `/COPY` (o `/INCLUDE`) aún puede traer código fuente de miembros fuente en el sistema de archivos QSYS (y viceversa). Lo que el desarrollador debería hacer es cambiar las declaraciones para usar una ruta relativa desde la raíz del proyecto hasta el archivo de flujo respectivo en el IFS. Por ejemplo, `/COPY QRPGLEREF,OBJECTS` podría traducirse a `/COPY './qrpgleref/objects.rpgle'`. + + +``` + /COPY `./qrplgeref/objects.rpgle` + /COPY `./qrplgeref/object.rpgle` + /COPY `./qrplgeref/formats.rpgle` + /COPY `./qrplgeref/members.rpgle` +``` + +La razón por la que usas una ruta relativa a la raíz del proyecto es para que podamos construir desde la raíz del proyecto dentro de nuestra línea de comandos, IDE o nuestro sistema de compilación (que verás más adelante). No es necesario que lo hagas para todo tu código fuente de una vez, porque aún puedes depender de los miembros fuente existentes durante un período de migración, aunque **se recomienda que los cambies tan pronto como sea posible**. Aunque no es recomendable, puedes hacerlo de manera iterativa y cambiarlos cuando trabajes en el código fuente. Esto es peligroso porque los miembros fuente no están bajo control de cambios. + +Si estás utilizando una herramienta de terceros, como HTTPAPI, que tiene sus encabezados en miembros fuente, entonces puedes dejar esas declaraciones `/COPY` (o `/INCLUDE`) junto con tus includes que apuntan al IFS: + +``` + /COPY `./qrplgeref/objects.rpgle` + /COPY `./qrplgeref/object.rpgle` + /COPY `./qrplgeref/formats.rpgle` + /COPY `./qrplgeref/members.rpgle` + /COPY QRPGLEREF,HTTPAPI_H +``` + +## Compilación de fuentes en el IFS + +Puedes compilar la mayoría de las fuentes fuera del IFS usando tu IDE o por la línea de comandos. La siguiente lista de comandos/compiladores tienen soporte para compilar fuentes fuera del IFS en IBM i con el parámetro `SRCSTMF`: + +* `CRTBNDRPG` / `CRTRPGMOD` +* `CRTSQLRPGI` +* `CRTSRVPGM` (para fuentes de binder) - 7.2+ +* `CRTBNDCL` / `CRTCLMOD` - 7.3+ +* `RUNSQLSTM` +* `CRTBNDC` / `CRTCMOD` +* `CRTBNDCBL` / `CRTCBLMOD` + +Cuando invoques los comandos de compilación, ya sea desde una shell 5250, pase shell o IDE, asegúrate de establecer el directorio de trabajo actual de los trabajos en la raíz/directorio del proyecto con el fin de que las declaraciones `/INCLUDE` y `/COPY` de las fuentes funcionen según lo previsto (como se muestra en el capítulo sobre copybooks). + +Puedes cambiar tu directorio de trabajo en un trabajo 5250 usando `CD` o `CHGCURDIR`. También puedes cambiar tu directorio de trabajo en RDi y Code for IBM i al compilar fuentes. Al trabajar en pase, puedes usar `cd` para cambiar el directorio de trabajo. diff --git a/docs/es/pages/developing/local/structure.md b/docs/es/pages/developing/local/structure.md new file mode 100644 index 0000000..363849a --- /dev/null +++ b/docs/es/pages/developing/local/structure.md @@ -0,0 +1,98 @@ +# Estructura de Proyecto Recomendada + +Esta página describe una estructura de proyecto recomendada cuando se utiliza git con tus fuentes ILE. Code for IBM i y las extensiones subsecuentes seguirán esta estructura para el desarrollo local. + +## Nombres de Archivos y 'Texto del Miembro' + +Se recomienda que el nombre del origen coincida con el nombre del objeto creado. Por ejemplo: + +* `ord500.pgm.rpgle` se convertiría en el objeto `ORD500.PGM` +* `ord500.cmd` se convertiría en el objeto `ORD500.CMD` + +Dado que el 'texto del miembro' se asocia tradicionalmente con los miembros, ya no es posible hacerlo con el sistema de archivos jerárquico estándar. Hay dos opciones para asociar 'texto' (la descripción) con un fragmento de código fuente. + +### Uso de `%TEXT` en tu código fuente + +Puedes usar `%TEXT:` en cualquier comentario en tu código fuente. Esto funciona para cualquier lenguaje de programación que utilices. + + +```rpgle +**free + +// %TEXT: This program is for order entry + +dcl-pi ORD500; +end-pi; + +//... + +return; +``` + +```sql +-- %TEXT: Order entry table +create or replace table xyz (...); +``` + +## Uso de la Opción `TEXT` (en RPGLE) + +En la especificación H o en el código de operación `CTL-OPT`, puedes utilizar la palabra clave `TEXT` para especificar el texto. + + +```rpgle +**free + +ctl-opt text('This program is for order entry'); + +dcl-pi ORD500; +end-pi; + +//... + +return; +``` +## Nombres de archivos en minúsculas + +Se recomienda utilizar siempre nombres de archivos en minúsculas. Generalmente, es más fácil para la lectura y sigue el estándar de la mayoría de los entornos. También puedes considerar el uso de camelCase. + +- `ord500.pgm.sqlrpgle` +- `ord600.pgm.cbble` +- `qrpglesrc/faq500.rpgle` + +## Extensiones válidas + +Las extensiones utilizadas para tus fuentes generalmente pueden seguir el estándar de los atributos del miembro (por ejemplo, `.rpgle`, `.sqlrpgle`, `.cbble`, `.clle`, etc.). + +Sin embargo, se anima a utilizar una extensión adicional para identificar si tu fuente es un programa o un módulo, además de la extensión regular. + +- `sale10.rpgle` indica un módulo (que podría convertirse en un programa de servicios o parte de un programa de varios módulos) +- `ord600.pgm.cbble` indica que esta fuente debe convertirse en un programa + +## Inclusión de copias y copybooks + +Se recomienda que todas las inclusiones (también conocidas como copybooks o encabezados) para RPGLE y COBOL utilicen la extensión `.xxxinc`. + +Por ejemplo: + +- `ordsrv.rpgleinc` es una inclusión de RPGLE. +- `pwrdta.cbbleinc` es una inclusión de COBOL. + +Para C y C++, debes continuar utilizando la extensión estándar `.h` para los archivos de encabezado. + +## Declaraciones de inclusión (RPGLE) + +Al utilizar `/COPY` y `/INCLUDE` en RPGLE con un proyecto local, la ruta siempre debe ser relativa al directorio del proyecto y no relativa al archivo activo. En general, cuanto más explícito seas, más fácil será el mantenimiento a largo plazo. + +- Funciona: `/copy 'faq500.rpgleinc'`, +- **Mejorado**: `/copy 'qrpgleref/faq500.rpgleinc'` + +Aunque es posible utilizar `INCDIR` y luego no proporcionar un directorio en la declaración de inclusión, al leer el código, es mucho más claro de dónde proviene el archivo. + +Si deseas que tu proyecto local resuelva archivos en el IFS, asegúrate de especificar tus 'directorios de inclusión': + +- Utilizando el parámetro `INCDIR` disponible en la mayoría de los compiladores ILE, +- o dentro del [archivo `iproj.json` con la propiedad `includePath`](https://ibm.github.io/vscode-ibmi-projectexplorer/#/pages/ibm-i-projects/iproj-json?id=includepath) para las rutas donde el compilador debería buscar (esto es compatible con ibmi-bob). + +## Estructura de proyecto de ejemplo + +Consulta el [repositorio company_system](https://github.com/worksofliam/company_system) para ver un buen ejemplo de proyecto que sigue estas reglas. diff --git a/docs/es/pages/developing/sourcedates.md b/docs/es/pages/developing/sourcedates.md new file mode 100644 index 0000000..28474ba --- /dev/null +++ b/docs/es/pages/developing/sourcedates.md @@ -0,0 +1,60 @@ +Las fechas de origen son compatibles con Code for IBM i, pero no están habilitadas de forma predeterminada. + +## Prerrequisitos para usar fechas de origen +Para habilitar las fechas de origen, el valor del sistema QCCSID no debe ser 65535. Consulta [nuestra documentación sobre codificación](../tips/ccsid.md) y [la documentación de IBM sobre el valor del sistema QCCSID](https://www.ibm.com/docs/en/i/7.5?topic=faqs-i-system-value-qccsid). + +## Configuración de fechas de origen + +Las fechas de origen se pueden habilitar en la configuración de la conexión. + +Hay tres opciones relacionadas con las fechas de origen: + +* *Habilitar fechas de origen*: si la compatibilidad con las fechas de origen está habilitada para los miembros de origen +* *Modo de seguimiento de fechas de origen*: qué tipo de modo se debe utilizar para realizar un seguimiento de los cambios. Más abajo. +* *Fechas de origen en el gutter*: si las fechas de origen deben aparecer en el margen de la ventana del editor cuando están habilitadas + +## Modos de seguimiento + +Existen dos tipos de modos de edición para las fechas de origen + +* *Modo de edición*, que es el estilo tradicional para la edición. Cuando cambia una línea, la fecha de origen de esa línea se actualizará. No comprende deshacer/rehacer. Se considera el modo 'tonto'. +* *Modo de diferencia* es el enfoque moderno para el seguimiento de fechas de origen. En lugar de realizar un seguimiento de las ediciones línea por línea, realiza [una diferencia](https://en.wikipedia.org/wiki/Diff) para comprender qué ha cambiado en el documento. Compara el documento base (desde la última apertura o última guardada) con la versión sucia más reciente del documento. Esta es una mejora de prueba. Comprende deshacer/rehacer. Se considera el modo 'más inteligente' de los dos modos. + +## Filtrado de fechas de origen + + + + + +Esta función solo está habilitada cuando se utiliza el seguimiento en 'Modo de diferencia', así como tener habilitado el margen de fechas de origen. + +Al pasar el ratón sobre el margen, se mostrarán dos botones para: + +* mostrar los cambios desde la última guardada, lo que abre una nueva vista de diferencias con los cambios +* iniciar una nueva búsqueda basada en la fecha de origen + + + +![Edición con espacio máximo](../../../assets/sourcedates_1.png) + + + +--- + + + + + +Iniciar una búsqueda basada en la fecha permitirá al usuario ingresar un nuevo filtro de fecha en formato `YYMMDD`. El margen resaltará cualquier fecha en o después de la fecha que ingresó el usuario. + +Al pasar el ratón sobre el margen nuevamente, se mostrará otro botón para borrar el filtro. + +También hay un botón en la barra de estado que el usuario puede utilizar para iniciar un nuevo filtro de fecha. + + + +![Edición con espacio máximo](../../../assets/sourcedates_2.png) + + + +--- diff --git a/docs/es/pages/extensions/db2i/index.md b/docs/es/pages/extensions/db2i/index.md new file mode 100644 index 0000000..fb2492d --- /dev/null +++ b/docs/es/pages/extensions/db2i/index.md @@ -0,0 +1,72 @@ +La extensión Db2 for i permite a los usuarios explorar esquemas de bases de datos, ejecutar declaraciones SQL y más en un sistema IBM i. + +![](./main.png) + +## Instalación + +La extensión se puede [instalar desde el Marketplace](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.vscode-db2i) y también es parte del [Paquete de Desarrollo de IBM i](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.ibm-i-development-pack). + +### Componente del Servidor + +A partir de la versión 0.3.0, la extensión Db2 for i requiere un componente del servidor. Este componente proporciona un rendimiento mejorado y facilita la adición de funciones avanzadas. La extensión Db2 for i administra la instalación del componente del servidor cuando te conectas a un IBM i con Code for IBM i y pedirá al usuario que confirme cualquier instalación o actualización. El componente del servidor se instala en `$HOME/.vscode`, lo que significa una instalación por usuario. [El componente del servidor también es de código abierto](https://github.com/ThePrez/CodeForIBMiServer). + +## Ejecución de declaraciones + +Ya sea: + +- Abrir un archivo `.sql` existente (miembro fuente, archivo de flujo o archivo local). +- Crear un nuevo archivo. + 1. Crear un archivo (control / comando + N). + 2. Cambiar el ID del lenguaje a `sql`. + +Una vez que tengas abierto un archivo SQL, puedes: + +- Mover el cursor sobre la declaración que deseas ejecutar y: + - Utilizar el botón de reproducción en la esquina superior derecha para ejecutar. + - Utilizar el atajo (control / comando + R) para ejecutar la declaración. + +El conjunto de resultados aparecerá debajo de la declaración. A medida que te desplazas por el conjunto de resultados, se cargará más datos. Cuando ejecutas una declaración SQL, se añadirá a tu vista de Historial de Consultas, donde permanece fácilmente accesible. + +Las declaraciones SQL se ejecutan utilizando el trabajo activo seleccionado en la vista SQL Job Manager. + +### Procesadores SQL + +Las versiones más recientes de SQL proporcionadas por Db2 for i te permiten ejecutar comandos CL en un script. También hay procesadores `json`, `csv` y `sql`, que abrirán el conjunto de resultados en el formato elegido. + +```sql +-- result set as normal table +select * from sample.employee; + +-- result set as JSON, will open in a new file +json: select * from sample.employee; + +-- result set as CSV, will open in a new file +csv: select * from sample.employee; + +-- result set as SQL insert statement +sql: select * from sample.employee; + +-- run CL commands. output is directed to IBM i output channel +cl: dspffd sample/employee +``` +## SQL Job Manager + +Esta vista permite a los usuarios gestionar diferentes trabajos de SQL, cada uno con su propia configuración única de JDBC. Se puede crear un nuevo trabajo haciendo clic en el icono de la base de datos en la barra de título del Administrador de Trabajos de SQL. O, si aún no has creado un nuevo trabajo, hay un gran botón para realizar la misma acción. + +![](./sqlJobManager-newJob.png) + +Tu trabajo activo se marcará con un icono resaltado. **El trabajo activo se utiliza para todas las ejecuciones de declaraciones SQL,** incluidas las SQL que alimentan el Navegador de Esquemas, declaraciones SQL ejecutadas por el usuario, etc. Puedes cambiar el trabajo activo simplemente haciendo clic en el trabajo que elijas usar. Verás que el icono resaltado cambia para indicar el trabajo activo. + +### Edición de la configuración del trabajo + +Puedes utilizar el icono de lápiz en cualquier trabajo para editar las propiedades de JDBC. Cuando se presiona el botón "Aplicar cambios", se guardan los cambios y se reinicia el trabajo para aplicar completamente los cambios. + +Puedes hacer clic con el botón derecho en cualquier trabajo para guardar esos ajustes de trabajo, lo que permite su reutilización fácil. Al utilizar la acción de clic derecho "Guardar configuración en el archivo" se te pedirá que ingreses un nombre para la configuración. Una vez guardada, verás aparecer una carpeta de 'Configuraciones Guardadas', con todas tus configuraciones guardadas. Haciendo clic en una configuración guardada lanzará un nuevo trabajo con esos ajustes predefinidos. Puedes utilizar el icono de lápiz en cualquier configuración guardada para editarla. + +## Uso del Navegador de Esquemas + +La extensión Db2 for i agrega una vista llamada Navegador de Esquemas que permite al usuario agregar esquemas existentes a la lista y les permite explorar objetos de base de datos existentes. Puedes hacer clic con el botón derecho en objetos SQL para mostrar más acciones. Cada tipo de objeto SQL puede tener acciones únicas. + +### Ver el contenido de la tabla + +Si estás utilizando el Navegador de Esquemas para explorar objetos, puedes utilizar el icono 'Ver contenido' al pasar el ratón sobre una tabla, vista o alias para generar y ejecutar una declaración SQL básica de selección. diff --git a/docs/es/pages/extensions/db2i/main.png b/docs/es/pages/extensions/db2i/main.png new file mode 100644 index 0000000..1ccea57 Binary files /dev/null and b/docs/es/pages/extensions/db2i/main.png differ diff --git a/docs/es/pages/extensions/db2i/sqlJobManager-newJob.png b/docs/es/pages/extensions/db2i/sqlJobManager-newJob.png new file mode 100644 index 0000000..5e03e79 Binary files /dev/null and b/docs/es/pages/extensions/db2i/sqlJobManager-newJob.png differ diff --git a/docs/es/pages/extensions/rpgle/faq.md b/docs/es/pages/extensions/rpgle/faq.md new file mode 100644 index 0000000..d55ae7f --- /dev/null +++ b/docs/es/pages/extensions/rpgle/faq.md @@ -0,0 +1,7 @@ +> ¿Funciona esto solo con formato libre? + +La asistencia de contenido y la vista de contornos funcionan para todas las versiones de ILE RPG, incluido el formato fijo. La asistencia de columnas es solo para el formato fijo. El linter es solo para el formato `**FREE`. + +> ¿Funciona esto con proyectos locales? + +¡Sí! Pero, tu RPGLE local debe tener la ruta de estilo IFS en tus directivas `copy` e `include`. Cuando desarrollas localmente, las rutas de inclusión no distinguen entre mayúsculas y minúsculas. diff --git a/docs/es/pages/extensions/rpgle/index.md b/docs/es/pages/extensions/rpgle/index.md new file mode 100644 index 0000000..1fb3cf4 --- /dev/null +++ b/docs/es/pages/extensions/rpgle/index.md @@ -0,0 +1,148 @@ +# RPGLE: Extensión para Visual Studio Code + +![Logo](https://github.com/halcyon-tech/vscode-rpgle/blob/main/media/logo.png?raw=true) + +RPGLE es un lenguaje tipado diseñado específicamente para ejecutarse en IBM i. Se utiliza principalmente para transacciones comerciales, procesamiento de grandes cantidades de datos, entrada de datos y APIs web. + +Echa un vistazo a [este video de YouTube del canal Visual Studio Code](https://www.youtube.com/watch?v=JRI7K8Y7cjQ) sobre IBM i y RPGLE. + +## Instalación + +La extensión se puede [instalar desde el Marketplace](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.vscode-rpgle) y también forma parte del [IBM i Development Pack](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.ibm-i-development-pack). + +Los compiladores oficiales para RPGLE solo se pueden ejecutar en IBM i y no son necesarios para la funcionalidad de este lenguaje. Si eres usuario de IBM i, la extensión Code for IBM i ofrece la funcionalidad para compilar el código fuente en el espacio de trabajo local. + +## Uso + +La extensión tiene dos funcionalidades principales: + +- Herramientas de lenguaje: asistencia de contenido, vista de esquema, etc. Admite todas las versiones de ILE RPG (formato fijo, mixto y de formato libre). +- Linter: linter configurable para verificar la calidad del código. **Solo admite formato libre total** (`**FREE`). + +La extensión de lenguaje RPGLE funciona en tres sistemas de archivos principales: + +- Espacio de trabajo local +- Miembros de fuente de IBM i (remoto) +- Streamfiles de IBM i (remoto) + +## Hola Mundo + +Para asegurarte de que la extensión RPGLE está funcionando, podemos escribir el código fuente de un programa muy simple en nuestro espacio de trabajo local. + +Crea una carpeta llamada `HelloWorld` y abre VS Code en esa carpeta (`code .` abre VS Code en la carpeta actual): + +```terminal +mkdir HelloWorld +cd HelloWorld +code . +``` + +TEl comando "code ." abre Visual Studio Code en la carpeta de trabajo actual, que se convierte en tu "espacio de trabajo". Acepta el diálogo de Confianza del Espacio de Trabajo seleccionando **Sí, confío en los autores** ya que esta es una carpeta que creaste. + +Ahora crea un archivo nuevo llamado `helloworld.pgm.rpgle` con el botón **Nuevo Archivo** en el Explorador de Archivos o con el comando **Archivo** > **Nuevo Archivo**. + +![](../../../assets/rpgle/hw_1.png) +![](../../../assets/rpgle/hw_2.png) + +### Agregar código fuente de Hello World + +Ahora pega este código fuente: + +```rpgle +**free + +ctl-opt dftactgrp(*no); + +dcl-s mytext char(25); + +Dcl-PR printf Int(10) extproc('printf'); + input Pointer value options(*string); +End-PR; + +mytext = 'Hello World'; +printf(mytext); + +return; +``` + +### Verificar con la Vista de Contornos + +Puedes enfocar la Vista de Contornos abriendo la Paleta de Comandos (**F1**) y buscando 'focus outline'. Las definiciones del programa deberían mostrarse: + +![](../../../assets/rpgle/hw_3.png) + +### ¿Y ahora qué? + +Compilar el código desde Visual Studio Code requiere una extensión diferente debido a que los compiladores solo existen en IBM i. Consulta la [documentación oficial de Code for IBM i](https://halcyon-tech.github.io/docs/#/) para empezar. + +## Asistencia de Contenido + +La asistencia de contenido proporciona autocompletado de código, información al pasar el cursor y problemas de formato para ayudar al usuario a escribir código correctamente. + +![](../../../assets/rpgle/intellisense.png) + +Puedes desactivar la asistencia de contenido para que no aparezca automáticamente cambiando la configuración 'Suggest On Trigger Characters'. + +### Información al Pasar el Cursor + +Pasa el cursor sobre cualquier definición (variable, estructura, procedimientos, etc.) para ver información sobre el tipo y la documentación. + +![](../../../assets/rpgle/hover.png) + +## Navegación de Código + +Ya sea escribiendo código en el espacio de trabajo local o en un IBM i remoto, los usuarios pueden utilizar la funcionalidad de navegación de código incorporada para comprender mejor su aplicación. + +### Ir a la definición + +Con cualquier definición, puedes utilizar Ir a la Definición o Explorar Definición: + +![](../../../assets/rpgle/peek_defs.png) + +### Mostrar Referencias + +Al igual que con las definiciones, puedes encontrar todas las referencias a las definiciones con Ir a Referencias o Explorar Referencias: + +![](../../../assets/rpgle/peef_refs.png) + +### Ir a Implementación + +Ir a Implementación funciona para procedimientos de dos maneras. + +* Para todas las fuentes (miembros/streamfiles/locales) buscará el nombre del procedimiento en los directorios de enlace que hayas especificado en el encabezado/control-spec `BNDDIR` e intentará abrir la fuente correspondiente. + * La búsqueda utiliza la lista de bibliotecas de Code for IBM i si el directorio de enlace no está calificado con una biblioteca. +* Para proyectos locales, te llevará a la implementación de un procedimiento de exportación donde sea que esté en tu proyecto. + +### Formatear Documento + +Puedes corregir automáticamente toda la sangría de tus fuentes de formato libre utilizando Formatear Documento dentro de VS Code. + +*Abre la Paleta de Comandos (F1/Control+Shift+P) -> 'Format Document'* + +### Extraer a Nuevo Procedimiento + +Cuando usas código fuente completamente de formato libre, puedes utilizar 'Extraer a procedimiento' que tomará las líneas de código seleccionadas y las envolverá en un nuevo procedimiento y convertirá todas las variables referenciadas en parámetros. + +![](../../../assets/rpgle/extract_procedure.png) + +## Linter + +La extensión incluye un linter incorporado para garantizar que los desarrolladores escriban el código más limpio posible. El linter no tiene opiniones y es altamente configurable. + +### Crear Configuración de Lint + +Utiliza el comando 'Abrir configuración de lint de RPGLE' desde la paleta de comandos para crear y abrir automáticamente la configuración de lint relativa a la fuente de RPGLE en la que estás trabajando. + +![](../../../assets/rpgle/lint_create.png) + +### Opciones de Lint + +Hay algunas opciones predeterminadas habilitadas cuando se crea la configuración de lint. La asistencia de contenido dentro de `rpglint.json` mostrará otras opciones disponibles: + +![](../../../assets/rpgle/lint_options.png) + +### Corrección Rápida y Formateo + +La mayoría de los errores de lint tienen una Corrección Rápida y las correcciones están disponibles al pasar el cursor sobre el error. También puedes utilizar 'Format Document' desde la paleta de comandos para corregir todos los errores con una Corrección Rápida adjunta. + +![](../../../assets/rpgle/lint_errors.png) diff --git a/docs/es/pages/extensions/rpgle/linter.md b/docs/es/pages/extensions/rpgle/linter.md new file mode 100644 index 0000000..56ff045 --- /dev/null +++ b/docs/es/pages/extensions/rpgle/linter.md @@ -0,0 +1,97 @@ +# Configuración del Linter + +La información a continuación es específica del linter en la extensión RPGLE. + +## Abrir la configuración del linter + +Utiliza `vscode-rpgle.openLintConfig` para abrir la configuración de reglas para el fuente en el que estás trabajando. + +![Comando para Abrir la Configuración del Lint](../../../assets/rpgle/OpenLintConfig.png) + +O también puedes hacer clic derecho en un filtro de biblioteca: + +![Abrir Configuración del Lint con un Clic](../../../assets/rpgle/OpenLintConfig_02.png) + +Si no existe un archivo de reglas del linter, se te preguntará si deseas crear uno. El archivo creado proporcionará algunas reglas predeterminadas, como se muestra a continuación. + +## Configuración relativa del linter + +* Si estás desarrollando en miembros fuente (`LIB/QRPGLESRC/MYSOURCE.RPGLE`) + * la configuración del linter existe en `LIB/VSCODE/RPGLINT.JSON`. + * Cada biblioteca tiene su propio archivo de configuración de reglas, vinculándolo a todos los fuentes RPGLE en esa biblioteca. + * los cambios de configuración se aplican cuando se vuelven a abrir los fuentes RPGLE. +* Al desarrollar en el IFS: + * la configuración de reglas del linter existe en `.vscode/rpglint.json` en relación con el directorio de trabajo actual. + * los cambios de configuración se aplican cuando se vuelven a abrir los fuentes RPGLE. +* Al desarrollar en un espacio de trabajo local + * las reglas del linter existen en `.vscode/rpglint.json` en relación con el espacio de trabajo. + * los RPGLE locales se escanean automáticamente cuando la configuración cambia. + +## Opciones del Lint + +A continuación, se presentan algunas configuraciones de linter disponibles. [Consulta el esquema `rpglint.json` para las reglas más actualizadas](https://github.com/halcyon-tech/vscode-rpgle/blob/main/schemas/rpglint.json). + +| Tipo | Regla | Valor | Descripción | +|---|---|---|---| +| 🌟 | indent | número | Sangría para RPGLE. | +| 🌟 | BlankStructNamesCheck | booleano | Los nombres de estructuras no pueden estar en blanco (*N). | +| 🌟 | QualifiedCheck | booleano | Los nombres de estructuras deben estar calificados (QUALIFIED). | +| 🌟 | PrototypeCheck | booleano | Los prototipos solo pueden definirse con EXT, EXTPGM o EXTPROC. | +| 🌟 | ForceOptionalParens | booleano | Las expresiones deben estar rodeadas por corchetes. | +| 🌟 | NoOCCURS | booleano | OCCURS no está permitido. | +| 🤔 | NoSELECTAll | booleano | 'SELECT *' no está permitido en SQL incorporado. | +| 🌟 | UselessOperationCheck | booleano | No se permiten códigos de operación redundantes (EVAL, CALLP). | +| 🌟 | UppercaseConstants | booleano | Las constantes deben estar en mayúsculas. | +| 🌟 | IncorrectVariableCase | booleano | Los nombres de variables deben coincidir con el caso de la definición. | +| 🌟 | RequiresParameter | booleano | Se deben usar paréntesis en una llamada a procedimiento, incluso si no tiene parámetros. | +| 🌟 | RequiresProcedureDescription | booleano | Se deben proporcionar títulos y descripciones de procedimientos. | +| 🌟 | StringLiteralDupe | booleano | No se permiten literales de cadena duplicados. | +| 🌟 | RequireBlankSpecial | booleano | *BLANK debe usarse en lugar de literales de cadena vacíos. | +| 🌟 | CopybookDirective | cadena | Fuerza la directiva que se debe usar para incluir otro fuente (`COPY` o `INCLUDE`). | +| 🌟 | UppercaseDirectives | booleano | Las directivas deben estar en mayúsculas. | +| 🤔 | NoSQLJoins | booleano | No se permiten JOINs en SQL incorporado. | +| 🌟 | NoGlobalsInProcedures | booleano | No se permiten globales en procedimientos. | +| 🌟 | SpecificCasing | array | Casing específico para códigos de operación, declaraciones o códigos de funciones integradas. | +| 🌟 | NoCTDATA | booleano | No se permite CTDATA. | +| 🌟 | PrettyComments | booleano | Los comentarios no pueden estar en blanco, deben comenzar con un espacio y tener una correcta sangría. | +| 🌟 | NoGlobalSubroutines | booleano | No se permiten subrutinas globales. | +| 🌟 | NoLocalSubroutines | booleano | No se permiten subrutinas en procedimientos. | +| 🌟 | NoUnreferenced | booleano | No se permiten definiciones no referenciadas. | +| 🔒 | NoExternalTo | array de cadenas | No se permiten llamadas a ciertas API (EXTPROC / EXTPGM). | +| 🔒 | NoExecuteImmediate | booleano | No se permiten declaraciones SQL incorporadas con EXECUTE IMMEDIATE. | +| 🔒 | NoExtProgramVariable | booleano | No se permite declarar un prototipo con EXTPGM y EXTPROC usando un procedimiento. | +| 🤔🌟 | IncludeMustBeRelative | booleano | Al usar declaraciones copy o include, la ruta debe ser relativa a la raíz. Se recomienda su uso solo para proyectos locales/espaciales de trabajo. | +| 🤔 | SQLHostVarCheck | booleano | Advierte cuando se hacen referencia a variables en SQL incorporado que también están definidas localmente. | +| 🤔 | RequireOtherBlock | booleano | Requiere que los bloques `SELECT` tengan un bloque `OTHER`. | + +**Clave de tipo** + +| Clave | Valor | +|---|---| +| 🌟 | Código limpio | +| 🤔 | Código seguro | +| 🔒 | Código seguro | + +### Ejemplo de `SpecificCasing` + +Esta regla te permite especificar el formato requerido para cualquier o todas las declaraciones o BIFs. + +Si deseas que todas las `DCL` estén en minúsculas y todas las `BIF`s estén en mayúsculas, se codificaría así: + + +```json + "SpecificCasing": [ + { + "operation": "%parms", + "expected": "*lower" + }, + { + "operation": "%timestamp", + "expected": "*TimeStamp" + }, + { + "operation": "*bif", + "expected": "*upper" + } + ] +``` \ No newline at end of file diff --git a/docs/es/pages/login.md b/docs/es/pages/login.md new file mode 100644 index 0000000..c6ba1d1 --- /dev/null +++ b/docs/es/pages/login.md @@ -0,0 +1,75 @@ +### Conectar por Primera Vez + + + + + +Haz clic en el ícono de IBM i y luego en 'Conectar a un IBM i'. + + + +![](../../assets/connect_02.png) + + + +--- + + + + + +Ingresa los detalles del sistema en la ventana que aparece. Necesitarás una contraseña o una clave privada. + +Alternativamente, presiona F1, busca `IBM i: Nueva Conexión` y completa el formulario anterior. + + + +![](../../assets/connect_03.png) + + + +### Conectar Posteriormente + + + + + +Si ya te has conectado a un sistema IBM i, haz clic en la conexión en el navegador de Servidores IBM i. + + + +![](../../assets/connect_04.png) + + + +--- + + + + + +Después de iniciar sesión, aparecerá un ítem de barra de estado mostrando el nombre del sistema IBM i al que estás conectado. + + + +![assets/connect_05.png](../../assets/connect_05.png) + + + +### Cerrar Sesión (Desconectar) + +Para cerrar una conexión y salir, presiona F1, busca `IBM i: Desconectar de la conexión actual` + +### Conexiones Inestables (Reconectar) + + + + + +Si tu conexión es inestable y se pierde a veces, verifica la configuración "Mostrar Botón de Reconexión". Consulta *Configuración: Global*, más abajo. Esto agregará un botón "Forzar reconexión al sistema" a la barra de tareas. + + + +![Botón de Reconexión](../../assets/connect_06.png) + + diff --git a/docs/es/pages/settings/connection.md b/docs/es/pages/settings/connection.md new file mode 100644 index 0000000..314b887 --- /dev/null +++ b/docs/es/pages/settings/connection.md @@ -0,0 +1,41 @@ +# Conexiones Múltiples + +Se pueden definir múltiples conexiones y algunas configuraciones son específicas de una conexión y se pueden guardar para la conexión y luego recargarlas más tarde. + +### Biblioteca Actual + +La biblioteca que se establecerá como la biblioteca actual durante la compilación. + +Puedes cambiar la biblioteca actual con el comando 'Cambiar biblioteca de compilación' (F1 -> Cambiar biblioteca de compilación). + +### Directorio de Inicio + +Directorio de inicio para el usuario. Este directorio también es la raíz para el navegador de IFS. + +### Biblioteca Temporal + +Biblioteca temporal. Almacena objetos temporales utilizados por Code for i. Se creará automáticamente si no existe. No puede ser QTEMP. El valor predeterminado es `ILEDITOR`. + +> [!ATENCIÓN] +> Si tu IBM i utiliza software de replicación, no es necesario replicar la biblioteca temporal. Tu administrador del sistema puede agregarla a la lista de objetos que se deben ignorar. + +### Directorio Temporal de IFS + +Directorio temporal de IFS. Almacena archivos temporales de IFS utilizados por Code for i. Se creará automáticamente si no existe. Debe estar en el sistema de archivos root o QOpenSys. El valor predeterminado es `/tmp`. + +> [!ATENCIÓN] +> Si tu IBM i utiliza software de replicación, no es necesario replicar el directorio temporal. Tu administrador del sistema puede agregarlo a la lista de rutas que se deben ignorar. +Es seguro tener archivos creados por Code for i eliminados automáticamente durante el mantenimiento o IPL. + +### ASP de Fuente + +Si los archivos fuente están ubicados en un ASP específico, especifica aquí. +De lo contrario, déjalo en blanco. + +### Habilitar Fechas de Fuente + +Cuando está marcado, se retendrán las fechas de fuente. + +### Fechas de Fuente en el Margen + +Cuando está marcado, las fechas de fuente se mostrarán en el margen. diff --git a/docs/es/pages/settings/global.md b/docs/es/pages/settings/global.md new file mode 100644 index 0000000..2228f7e --- /dev/null +++ b/docs/es/pages/settings/global.md @@ -0,0 +1,74 @@ +# Configuración Global + +Estas son las configuraciones que afectan a la extensión (y, por ende, a *cada* conexión). Para ajustar la configuración global de la extensión, puedes: + +- Utilizar la combinación estándar de teclas de VS Code Ctrl + , y hacer clic en Extensiones. +- O hacer clic en Archivo/Preferencias/Configuración y hacer clic en Extensiones. +- O presionar F1, buscar `Preferences: Open Settings (UI)` y hacer clic en Extensiones. + + + + + +Las configuraciones para la extensión estarán bajo `Code for IBM i` + +La mayoría de las configuraciones tienen una descripción autoexplicativa. Algunas tienen notas a continuación. + +**No se recomienda editar manualmente el JSON. Si lo haces, reinicia/recarga VS Code para que Code for IBM i pueda aplicar los cambios.** + + + +![assets/settings_01.png](../../../assets/settings_01.png) + + + +--- + +### Advertencia de eliminación de IFS (Eliminar seguro) + +Si está habilitada, cuando el usuario intenta eliminar un directorio, se le pedirá que confirme la eliminación escribiendo el nombre del directorio. + +![](./safeDelete.png) + +### Acciones + +Las acciones se pueden editar en settings.json, pero también de manera más fácil haciendo clic en **Actions** en la barra de estado. Ver *Acciones*, arriba. + +### Conexiones + +Las conexiones se pueden editar en settings.json, pero normalmente agregarías conexiones adicionales como en *Conectar por Primera Vez*, arriba. + +Puedes utilizar las siguientes variables en cualquiera de las cadenas dentro de Conexiones: +- `${userHome}` = se reemplaza con el directorio de inicio del usuario. +- `${pathSeparator}` = se reemplaza con el separador de rutas. (Típicamente "\\" en Windows o "/" en Mac/Unix/Linux.) + +### Configuración de Conexión + +Estas son las diversas configuraciones relacionadas con los elementos en los navegadores, por ejemplo, la lista de archivos fuente en el NAVEGADOR DE OBJETOS. Aunque se pueden editar en settings.json, la mayoría se pueden mantener más fácilmente haciendo clic o haciendo clic derecho en un elemento en el navegador. + +### Registrar la Salida de Compilación + + + + + +Cuando está habilitado, los archivos de spool se registrarán desde la ejecución del comando. +Estos archivos de spool se pueden encontrar bajo la pestaña **Output** (Ver->Output, o Ctrl + Shift + U). Selecciona **IBM i Output** en el menú desplegable a la derecha. + + + + +![Panel a la Derecha](../../../assets/LogOutput_01.png) + + + +Puedes borrar la pestaña de Output usando el ícono **Clear Output** en la esquina derecha. + +![Limpiar salida](../../../assets/LogOutput_02.png) + +Puedes cambiar el tamaño de fuente en la pestaña OUTPUT en tu settings.json de la siguiente manera: + +```json +"[Log]": { + "editor.fontSize": 11 +}, diff --git a/docs/es/pages/settings/profiles.md b/docs/es/pages/settings/profiles.md new file mode 100644 index 0000000..2d1a426 --- /dev/null +++ b/docs/es/pages/settings/profiles.md @@ -0,0 +1,32 @@ +# Perfiles de Conexión + +Un Perfil de Conexión permite al usuario cambiar entre configuraciones rápidamente. Puedes usar un perfil para cambiar rápidamente la lista de bibliotecas y otros elementos específicos de un proyecto. Un perfil almacena la siguiente información: + +- El directorio de inicio / de trabajo +- La biblioteca actual +- La lista de bibliotecas +- Los accesos directos de IFS +- La lista del navegador de objetos +- La lista del navegador de bases de datos + +Si no tienes perfiles existentes, puedes crear tu primero desde la vista de Lista de Bibliotecas del Usuario: + +![Guardar Perfil](../../../assets/Connect_Profile_Save_01.png) + +Después de haber creado tu primer perfil, estará disponible la vista de Perfiles. La vista de Perfiles te permite cambiar rápidamente entre perfiles, así como actualizar y eliminar perfiles existentes. La vista de Perfiles también te mostrará cuál fue el último perfil que configuraste. + +En la vista de perfiles, el botón de guardar en la barra de encabezado pedirá al usuario que guarde en un perfil completamente nuevo. Puedes hacer clic derecho en un perfil y guardar para actualizar un perfil. + +**Cambiar cualquiera de las configuraciones** no actualizará el perfil. Si cambias la lista de bibliotecas y quieres que esto se refleje en el perfil, puedes guardar sobre el perfil existente o en uno nuevo. + +## Perfiles de Comando + +Los Perfiles de Comando son tipos especiales de perfiles que solo actualizan la lista de bibliotecas del usuario y la biblioteca actual. Los Perfiles de Comando se crean a partir de comandos ILE/CL que establecen la lista de bibliotecas y/o la biblioteca actual. + +Al crear un Perfil de Comando, se proporciona un comando ILE/CL que configuraría la lista de bibliotecas del usuario y la biblioteca actual para un trabajo. Esto es especialmente útil al trabajar con cambios en la gestión que tienen comandos para configurar el entorno del usuario. + +Puedes cambiar entre Perfiles de Comando y Perfiles de Conexión tan a menudo como desees. + +![Guardar Perfil](../../../assets/command_profile.png) + +Los Perfiles de Comando solo se pueden crear después de haber creado el primer Perfil de Conexión. diff --git a/docs/es/pages/settings/safeDelete.png b/docs/es/pages/settings/safeDelete.png new file mode 100644 index 0000000..e6cf70d Binary files /dev/null and b/docs/es/pages/settings/safeDelete.png differ diff --git a/docs/es/pages/tips/ccsid.md b/docs/es/pages/tips/ccsid.md new file mode 100644 index 0000000..f053454 --- /dev/null +++ b/docs/es/pages/tips/ccsid.md @@ -0,0 +1,42 @@ +# Configuración de Caracteres en Code for IBM i + +IBM i utiliza el conjunto de caracteres EBCDIC, a diferencia de tu estación de trabajo, que utiliza algún conjunto de caracteres basado en ASCII (Windows, MAC y Linux usan su propia variante). Esto puede causar algunos problemas con los nombres mostrados para los objetos, archivos y miembros en el Navegador de Objetos. Aún peor, IBM i tiene varias variantes EBCDIC, cada una dirigida a un idioma nacional, y los caracteres especiales de EE. UU. '#', '@' y '$' permitidos en los nombres de objetos y miembros de IBM i tienen otros valores de código en las otras variantes. Sin embargo, IBM i aún espera que se utilicen los mismos valores de código de los caracteres de EE. UU., y por lo tanto, se deben usar los caracteres nacionales con estos valores de código. + +A partir de la versión 1.4.0 de esta extensión, el código para manejar estas diferencias ha cambiado, principalmente cuando SQL está habilitado y se usa para recuperar listas de objetos y miembros. Anteriormente, no había conversión entre los caracteres de EE. UU. y los caracteres nacionales, pero ahora Code for IBM i convierte los caracteres de EE. UU. en los caracteres nacionales. Esto está controlado por el valor del conjunto de caracteres codificado (CCSID) en el perfil de usuario IBM i utilizado para la conexión, alternativamente el valor del sistema `QCCSID` (si el valor CCSID del perfil de usuario es `*SYSVAL`). El CCSID probablemente ya esté configurado en tu perfil de usuario o sistema, pero si necesitas cambiar a otro idioma, aquí hay algunos ejemplos de cómo configurar el CCSID: + +| Idioma | Comando | Caracteres de Variante | +| -------- | ------- | :----------------: | +| EE. UU. | `CHGUSRPRF _tuperfil_ CCSID(37)` | $, #, @ | +| DK | `CHGUSRPRF _tuperfil_ CCSID(277)` | Å, Æ, Ø | +| IT con euro | `CHGUSRPRF _tuperfil_ CCSID(1144)` | $, £, § | + +La conversión se realiza en ambas direcciones: al leer nombres de objetos y miembros para la lista, pero también al crear un archivo fuente o miembro o al aplicar un filtro a una lista. Para usuarios no estadounidenses, siempre debes usar tus caracteres nacionales en lugar de los caracteres estadounidenses, incluso en los valores de filtro. + +Si cambias el CCSID para tu perfil en el servidor, es posible que también tengas que cambiar tus filtros, ¡si has utilizado alguno de los caracteres especiales en el filtro! + +El valor especial de CCSID 65535 significa "sin conversión", y esto desactivará el soporte SQL. **No** se recomienda usar CCSID 65535 y la mayoría de los sistemas más nuevos tienen un CCSID diferente de 65535. Pero puedes encontrar este valor en sistemas más antiguos. La solución aquí sería cambiar el perfil de usuario a un valor de CCSID correspondiente a tu idioma nacional, por ejemplo, 280 en Italia o 297 en Francia. + +## Configuración de variables de entorno + +Si aún experimentas problemas después de configurar el valor de CCSID, es posible que desees verificar que la configuración regional del entorno PASE de IBM i esté configurada correctamente: + +- OS 7.4 o superior: + +[7.4 y superior se configura automáticamente en UTF-8](https://www.ibm.com/docs/en/i/7.4?topic=system-default-pase-ccsid-locale-changed-utf-8) y no debería haber problemas. + +- OS 7.3 o anterior: + +El daemon SSH debe iniciarse con las variables de entorno `PASE_LANG` y `QIBM_PASE_CCSID` establecidas correctamente. Probablemente quieras usar una configuración regional que se configure en CCSID 1208 de forma predeterminada. **La configuración regional distingue mayúsculas y minúsculas**. Por ejemplo, `FR_FR` es diferente de `fr_FR`. + +1. Cambia el idioma PASE y el CCSID *en todo el sistema* usando `WRKENVVAR LEVEL(*SYS)` para configurar: + - la configuración regional/idioma apropiada, por ejemplo, `PASE_LANG 'FR_FR'`. Puedes encontrar información sobre las configuraciones regionales de PASE para IBM i [aquí](https://www.ibm.com/docs/en/i/7.4?topic=ssw_ibm_i_74/apis/pase_locales.htm) + - `QIBM_PASE_CCSID` debería ser `1208`. +2. **Reinicia** el daemon SSH. + +También puedes cambiar las variables de entorno a nivel de `*JOB`, pero se recomienda hacerlo una vez para todo tu sistema. + +Algunos enlaces a páginas que contienen información sobre caracteres de variante: + +- [Definición de IBM de caracteres de variante](https://www.ibm.com/docs/en/db2-for-zos/11?topic=ccsids-variant-characters) +- [Soporte de IBM](https://www.ibm.com/support/pages/what-impact-changing-qccsid-shipped-65535-another-ccsid) +- [Wikipedia](https://en.wikipedia.org/wiki/EBCDIC) diff --git a/docs/es/pages/tips/quickstart.md b/docs/es/pages/tips/quickstart.md new file mode 100644 index 0000000..8a62976 --- /dev/null +++ b/docs/es/pages/tips/quickstart.md @@ -0,0 +1,30 @@ +### Establecer una conexión + +1. Presiona F1. +2. Encuentra 'IBM i: Nueva Conexión'. +3. Ingresa los detalles de tu conexión en la ventana que se abre. +4. Haz clic en Conectar. + +Consejo: la próxima vez, intenta usar 'IBM i: Conectar a la anterior'. + +### Navegar/Editar miembros fuente + +1. Conéctate a tu sistema. +2. Encuentra el EXPLORADOR DE OBJETOS y haz clic en **+ Crear nuevo filtro**. +3. Completa el diálogo del nuevo filtro, siguiendo el texto descriptivo, asegurándote de: + a. Que **Objeto** sea el archivo físico fuente que deseas editar. + b. Que el **Filtro de tipo de objeto** esté configurado como *SRCPF. +4. Guarda la configuración. +5. Haz clic en el filtro para expandir los miembros en el archivo fuente. +6. Haz clic en un miembro para abrirlo. + + > [!NOTA] +> No hay bloqueo de miembros y la extensión no retiene automáticamente las fechas de origen. + +### ¿Cómo compilo mi código fuente? + +1. Edita tu lista de bibliotecas en el explorador 'LISTA DE BIBLIOTECAS DEL USUARIO'. (Cada conexión tiene su propia lista de bibliotecas.) +2. Abre el fuente que deseas compilar. +3. Usa Ctrl+E o Cmd+E para compilar tu fuente. +4. Si tienes más de una opción de compilación disponible para el tipo de fuente, selecciona la apropiada. +5. Si estás utilizando `*EVENTF`, el listado de errores debería cargarse automáticamente en la pestaña PROBLEMAS. diff --git a/docs/es/pages/tips/setup.md b/docs/es/pages/tips/setup.md new file mode 100644 index 0000000..542f30d --- /dev/null +++ b/docs/es/pages/tips/setup.md @@ -0,0 +1,70 @@ +# Soluciones a Errores en Code for IBM i + +Esta página consta de correcciones para errores extraños que los usuarios reciben basados en la configuración del sistema. + +## Error en la configuración de la terminal + +Este error aparece cuando tienes líneas en los archivos de inicio que escriben en la salida estándar. Por lo general, el problema principal es cuando los siguientes comandos existen en el archivo `.bashrc` (archivo de inicio no interactivo). + +- `echo` +- `liblist` - este es un nuevo comando bash en IBM i que agrega a la lista de bibliotecas, pero también escribe en la salida estándar. + +Puedes ver el [problema original en GitHub](https://github.com/halcyon-tech/vscode-ibmi/issues/325): + +> Este fue mi momento 'aha', ya que recientemente cambié mi archivo `~/.bashrc` en IBM i para generar alguna salida general. Y efectivamente, cuando cambio el archivo `~/.bashrc` entre escribir en stdout y no escribir en stdout, veo que el problema aparece/desaparece (respectivamente). +> +> La mejor solución, para mí, es mantener la inicialización de la terminal que escribe en stdout en mi archivo `~/.profile`, que no se ejecutará a través de una conexión SFTP. Sin embargo, esto está fuera del alcance de esta extensión. + +## Sin resultados al ejecutar SQL + +Cuando ejecutas una declaración SQL, no aparecen mensajes ni resultados. Esto ha estado sucediendo cuando el SSHD no se ha iniciado correctamente. Puedes ver en la salida de Code for IBM i algo como lo siguiente: + + +``` +/home/NUJKJ: LC_ALL=EN_US.UTF-8 system "call QSYS/QZDFMDB2 PARM('-d' '-i' '-t')" +select srcdat, rtrim(srcdta) as srcdta from ILEDITOR.QGPL_QCLSRC_A_CHGUSR_C +{ +"code": 0, +"signal": null, +"stdout": "DB2>", +"stderr": "" +} +``` + +### Solución potencial + +Si ejecutas `ps -ef | grep sshd` y ves `/QOpenSys/usr/sbin/sshd`, este fix puede funcionar para ti. + +1. Finaliza la instancia actual de SSHD: `ENDTCPSVR SERVER(*SSHD)`. +2. Inicia SSHD nuevamente: `STRTCPSVR SERVER(*SSHD)`. +3. En una terminal PASE, ejecuta `ps -ef | grep sshd`. + +Ahora deberías ver que el SSHD se ha iniciado desde un lugar diferente. + + +``` +$ ps -ef | grep sshd + qsecofr 107 1 0 Jul 15 - 0:00 /QOpenSys/QIBM/ProdData/SC1/OpenSSH/sbin/sshd +``` + +The issue should now be resolved. + +## Connection using SSH private key always fails + +On some platforms (e.g., Linux PopOS) your connection using SSH private key may fail with a message like: +``` +Error while signing data with privateKey: error:06000066:public key routines:OPENSSL_internal:DECODE_ERROR +``` +Esto puede ocurrir si las rutinas OpenSSL en tu plataforma utilizadas por Code for IBM i tienen problemas con el formato predeterminado de la clave pública. + +### Solución mediante la creación de una copia de la clave privada en formato PEM + +Puedes resolver esto creando una segunda instancia de tu clave pública existente en formato PEM para que esté junto a tu clave predeterminada. Por ejemplo, si tu clave pública es `$HOME/.ssh/id_rsa`, puedes hacer lo siguiente: +``` +cd $HOME/.ssh +cp id_rsa id_rsa_original +ssh-keygen -p -f id_rsa -m PEM +mv id_rsa id_rsa.pem +mv id_rsa_original id_rsa +``` +Ahora configura la conexión de Code for IBM i utilizando `id_rsa.pem` en lugar de `id_rsa`. De esta manera, tu clave original sigue estando allí para hacer conexiones como siempre, y tienes una nueva copia en formato PEM con la que las conexiones de Code for IBM i funcionan correctamente. diff --git a/docs/es/pages/tips/terminals.md b/docs/es/pages/tips/terminals.md new file mode 100644 index 0000000..8beb4bb --- /dev/null +++ b/docs/es/pages/tips/terminals.md @@ -0,0 +1,57 @@ +# Terminal en Code for IBM i + +En Code for IBM i, puedes abrir un terminal 5250 en su propia pestaña, de modo que casi todas las necesidades del desarrollador estén integradas en el editor. Puedes lanzar tanto un terminal 5250 como una terminal PASE directamente en el editor. + +![Captura de pantalla 2021-12-06 a las 12:07:22 PM](https://user-images.githubusercontent.com/3708366/144915006-20d44162-23ec-4f04-beec-889f989cd497.png) + +_Muestra el explorador, código RPGLE, problemas, vista de esquema y terminal 5250._ + +## Inicio del Terminal + + + + + +Pasa el cursor sobre el sistema conectado en la barra de estado. + + + +![Menú de Selección Rápida del Sistema](../../../assets/Terminals_01.png) + + + +--- + + + + + +Haz clic en **Terminales** en el menú de selección rápida y luego elige un terminal: + +* **PASE** se lanzará en el entorno PASE. +* **5250** lanzará un emulador 5250 para el sistema conectado. + + + +![Elegir terminal](../../../assets/Terminals_02.png) + + + +## Requisitos y Configuración del Terminal 5250 + +Para iniciar un emulador 5250, debes tener tn5250 instalado en el sistema remoto. Esto se puede [instalar mediante yum](https://www.seidengroup.com/php-documentation/how-to-set-up-the-ibm-i-open-source-environment/). + +Después de instalar tn5250, deberías poder lanzar el terminal 5250, pero si no puedes: antes de conectarte a tu servidor, haz clic derecho en el servidor y elige "Conectar y Recargar Configuración del Servidor". + +Code for IBM i proporciona configuraciones adicionales para que puedas configurar tu terminal según tus preferencias. La configuración más común es probablemente la configuración de asignación de CCSID, que te permite establecer la codificación para el terminal. + +![imagen](https://user-images.githubusercontent.com/3708366/144916702-79ba1d15-ab1f-4248-abed-8b19c84715c9.png) + +## Preguntas Frecuentes (FAQ) + +- **¿Funcionan las teclas de función?** Sí. +- **¿Es posible hacer una solicitud al sistema?** Sí. Usa Command+C. +- **¿Cómo cierro mi sesión?** Usa el icono de la papelera en VS Code. +- **¡Estoy atascado con `Cursor in protected area of display.`!** Usa Command+A para llamar la atención, luego usa F12 para retroceder. +- **¿Cuáles son todas las combinaciones de teclas?** [Consúltalas aquí](https://linux.die.net/man/1/tn5250). +Now configure the Code for IBM i connection using `id_rsa.pem` instead of `id_rsa`. In this way, your original key is still there to make connections as always, and you have a new copy in PEM format using which Code for IBM i connections operate correctly. diff --git a/docs/es/pages/tips/tricks.md b/docs/es/pages/tips/tricks.md new file mode 100644 index 0000000..cf2cb4e --- /dev/null +++ b/docs/es/pages/tips/tricks.md @@ -0,0 +1,51 @@ +### Comparación de fuentes + + + + + +Compara dos fuentes, ya sean miembros o archivos de flujo. + +1. Haz clic derecho en cualquiera de los tipos, elige 'Seleccionar para comparar'. +2. Haz clic derecho en la otra fuente que deseas comparar y elige 'Comparar con la seleccionada'. + + + +![assets/compare_01.png](../../../assets/compare_01.png) + + + +### Ejecución de una declaración SQL + + + + + +Instala la [extensión Db2 for IBM i](https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.vscode-db2i) para esta funcionalidad. [Consulta la documentación aquí](pages/extensions/db2i/index). + +También es posible ejecutar declaraciones SQL directamente desde el editor en un archivo SQL. Puedes resaltar la declaración que deseas ejecutar o mover tu ancla sobre la declaración y usar Ctrl+R/Cmd+R para ejecutar la declaración. + +Los conjuntos de resultados de SQL aparecen en el panel 'IBM i: Resultados'. + + + +![assets/db_03.png](../../../assets/db_03.png) + + + + +### Buscar archivos fuente y directorios IFS + +Haz clic derecho y selecciona 'Buscar' en directorios IFS y archivos fuente para buscar a través del contenido de archivos de flujo y miembros fuente. + +### Sobrescribir + +VS Code funciona en modo de "inserción". Esto puede resultar molesto al editar un fuente en modo fijo, como DDS. Afortunadamente, hay una [extensión de sobrescritura](https://marketplace.visualstudio.com/items?itemName=DrMerfy.overtype) que te permite alternar entre inserción y sobrescritura, y también puede mostrar el modo actual en la barra de estado. + +### Tamaño de Fuente + +El tamaño de fuente en el editor está controlado por la configuración de VS Code *Editor: Font Size*. Sin embargo, con el cursor en un editor, también puedes cambiar temporalmente el tamaño de fuente del editor manteniendo presionado Ctrl y usando la barra de desplazamiento del mouse. + +El tamaño de fuente en las barras de menú, laterales, de estado y de actividad se puede cambiar manteniendo presionado Ctrl y usando + o -. Dichos cambios se mantendrán de sesión a sesión. Sin embargo, esto también cambiará el tamaño de fuente del editor y es posible que debas ajustarlo como se menciona anteriormente para esta sesión. + +Consejo práctico: Experimenta. diff --git a/docs/index.html b/docs/index.html index 2dfbfb3..eca9f68 100644 --- a/docs/index.html +++ b/docs/index.html @@ -15,7 +15,6 @@ href="https://cdn.jsdelivr.net/npm/docsify-themeable@0/dist/css/theme-simple.css">