DEV Community: Edgar Rios Navarro

Jira Java API

Edgar Rios Navarro — Wed, 13 Aug 2025 15:22:22 +0000

Jira provee un REST API, del que se abordó en el post anterior: https://dev.to/e240683/cliente-jira-mediante-cookie-5f3n. Pero también, provee un Java API.

Para este caso, importar dos librerías específicas:

jira-rest-java-client-core
fugue

Luego, implementar la autenticación (mediante cookie).

Finalmente, invocar la búsqueda del Issue y acceder a sus propiedades.

Documentación

https://developer.atlassian.com/server/jira/platform/java-apis/

Cliente Jira mediante Cookie

Edgar Rios Navarro — Thu, 06 Mar 2025 17:08:27 +0000

Aunque acceder a Jira mediante Cookie es una funcionalidad deprecada, sigue siendo una alternativa en entornos restrictivos al uso del Token.

En Typescript existe una librería recomendada por su reducido tamaño:
https://github.com/UrielCh/jira-api/

El fork que utiliza la opción de Cookie lo subí al siguiente repositorio: https://github.com/edgargs/jira-api/tree/feature/client-cookie

Este bloque de código, demuestra el cambio en la creación del cliente.

const domain:string = Deno.env.get("JRA_DOMAIN")!;
const cookie:string = Deno.env.get("JRA_COOKIE") || '';

const jira = new JiraClient(domain, { COOKIE: cookie });

El valor del cookie se obtiene de la sesión activa en el navegador web.

Procesar miles de registros con Spring-Batch

Edgar Rios Navarro — Tue, 26 Sep 2023 22:51:33 +0000

Pongamos como contexto, que se necesita leer desde una base de datos origen y grabar en otra base de datos distinta. Con el propósito de realizar resúmenes y cuadres diarios.

Lo más eficiente será no depender de algún ORM. Por lo que se recomienda emplear JDBC.

Spring-Batch provee un JdbcPagingItemReader el cual, al recuperar los registros de manera paginada no ocupará memoria en retener todo el resultado de la consulta.

También tenemos un JdbcBatchItemWriter para grabar los registros, que los grabarán usando la capacidad batch del driver.

Documentación

https://docs.spring.io/spring-batch/docs/current/reference/html/readersAndWriters.html#database

https://docs.spring.io/spring-batch/docs/current/reference/html/scalability.html#scalability

MySQL usar tipo SET para validar

Edgar Rios Navarro — Tue, 04 Jul 2023 15:00:57 +0000

Cuando diseñamos un sistema y tenemos una lista restringida de opciones, el modelo ER nos mostrará una relación de 'muchos a muchos'.

Consideremos el caso de Usuario - Roles:

El diagrama nos indica que debemos crear tres tablas.

Como alternativa, en MySQL nos proporciona el tipo SET.

Dicho campo acepta ninguno, uno o más valores de la lista.

mysql> insert into user(email,name,password) 
values('a@greatsolutions.consulting','A','A');
Query OK, 1 row affected (0.04 sec)

mysql> insert into user(email,name,password,roles) 
values('b@greatsolutions.consulting','B','B','');
Query OK, 1 row affected (0.04 sec)

mysql> insert into user(email,name,password,roles) 
values('c@greatsolutions.consulting','C','C','editor,user');
Query OK, 1 row affected (0.04 sec)

Por el contrario, nos da error cuando intentamos insertar un valor diferente.

mysql> insert into user(email,name,password,roles) 
values('d@greatsolutions.consulting','D','D','root');
ERROR 1265 (01000): Data truncated for column 'roles' at row 1
mysql>

Documentación

https://dev.mysql.com/doc/refman/8.0/en/set.html

Autoincrement en Oracle

Edgar Rios Navarro — Wed, 21 Jun 2023 16:41:48 +0000

Consideremos el script original, basado en la versión 11g:

---------
-- 11g --
---------
CREATE TABLE ORDERS (
    ID NUMBER NOT NULL,
    ...
);
/

ALTER TABLE ORDERS 
ADD CONSTRAINT PK_ID PRIMARY KEY (ID);
/

CREATE SEQUENCE SEQ_ORDERS
 START WITH     1000
 INCREMENT BY   1
 NOCACHE
 NOCYCLE;
/

CREATE OR REPLACE TRIGGER TRG_I_ORDERS
BEFORE INSERT
   ON ORDERS
   FOR EACH ROW
BEGIN
   :NEW.ID = SEQ_ORDERS.NEXTVAL
END;
/

Anteriormente, se empleaba un trigger para incrementar el ID: recuperar el valor de un sequence y asignarlo al campo.

Desde la versión 12c, obtenemos la misma funcionalidad con IDENTITY Column.

---------
-- 12c --
---------

CREATE TABLE ORDERS(
    ID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    ...
);
/

Documentación

Oracle:Database:identity_clause

Procesar una transacción completamente con TRANSACT-SQL

Edgar Rios Navarro — Fri, 28 Apr 2023 14:06:29 +0000

Consideremos que, la cadena XML se genera en el servidor de aplicación. Se emplea la configuración de Spring para usar JAXB2.

Debemos asignar una lista de detalle (listCollectionSpendReport) a la entidad que vamos a persistir (collection). Nótese que, previamente se grababa la entidad y luego, uno por uno, los detalles.

El procedimiento almacenado, recibe los datos de la entidad principal y una cadena de los detalles. Luego, son casteados en formato XML y recorridos en una sentencia SELECT para ser insertados en la tabla correspondiente.

Documentación

http://docs.spring.io/spring-ws/site/reference/html/oxm.html

Enviar geoposición desde el backend con Primefaces y Gmaps.

Edgar Rios Navarro — Fri, 14 Apr 2023 13:48:57 +0000

Este ejemplo muestra como interactuar con información del backend y el frontend. Específicamente, enviar una posición y mostrarla en un mapa (google maps).

Recuperamos la latitud y longitud (posiblemente desde la base de datos) en el controller.

La posición lo almacenamos en variables de javascript. En la página web, también tendremos dos input's para mostrar cómo va cambiando la posición al mover el marker.

Creamos el mapa y colocamos el marker. Agregamos los eventos para mostrar la posición actual.

Documentación

https://developers.google.com/maps/documentation/javascript/examples/

Procesar una transacción remota (XML) mediante un procedimiento almacenado

Edgar Rios Navarro — Fri, 10 Mar 2023 15:50:29 +0000

Para enviar información (transaccional) hacia una base de datos centralizada, prodríamos emplear un servicio web: recibe los datos y los persiste de forma autónoma, segura y confiable. Pero como alternativa, es invocar un procedimiento almacenado remoto.

Consideremos la limitante que no podemos enviar la información en formato JSON. La versión del motor no lo soporta: Oracle 11g. La solución será emplear el formato XML.

No pasemos por alto los riesgos de enviar la información no cifrada (el sistema está en una red privada o no), el tamaño de los datos y el costo de procesamiento del servidor.

Este ejemplo nuestra cómo generar el formato XML en el cliente. Se etiqueta los bean's con la anotación @XmlRootElement.

El procedimiento para interpretar el xml y grabar las tablas correspondientes. La solución es válida para todas las base de datos relacionales (como Postgres y Sql Server), aunque el código varía entre ellas.

Documentación

https://github.com/edgargs/Ejemplo-2016-01.git
http://howtodoinjava.com/jaxb/jaxb-exmaple-marshalling-and-unmarshalling-list-or-set-of-objects/
http://viralpatel.net/blogs/oracle-xmltable-tutorial/

JTable Color Header

Edgar Rios Navarro — Sat, 28 Jan 2023 16:12:39 +0000

A diferencia de las aplicaciones web, personalizar grillas (tablas) en Java Swing requiere de mucho más código. Pero podemos ayudarnos con clases utilitarias.

1) Original

Consideremos este ejemplo:

2) Column Group

Para agregar la capacidad de agrupar columnas, emplearemos una clase llamada ColumnGroup. Reconoce el título y las columnas que debe agrupar.

ColumnGroup columnGroup = null;

int[] columns = {8,9};
columnGroup = new ColumnGroup("Precio Venta " + "S/.", columns);

UtilityTable.initSelectList(jTable, tableModel, ConstantsVentas.columnsList, 
columnGroup );

3) Color Header

También podemos cambiar el color de columnas específicas. Ello lo conseguimos indicando en la clase FarmaColumnData, el color de fondo.

Documentación

https://docs.oracle.com/javase/tutorial/uiswing/components/table.html
https://github.com/edgargs/table-color-header.git

Mock Service with Groovy

Edgar Rios Navarro — Thu, 08 Dec 2022 12:30:18 +0000

Cuando dependemos de una servicio de tercero, nos encontraremos con la situación que dicho servicio no está disponible por un tiempo. Para eliminar esa dependencia, podemos crear un MockService por nuestra cuenta.

En el ecosistema de Groovy, existe una librería que nos facilita: RatPack.

En una solo archivo, configuramos los métodos y las respuestas. Es posible agregarle lógica, pero la intención es que tengamos respuesta.

@Grab("io.ratpack:ratpack-groovy:1.3.3")
import static ratpack.groovy.Groovy.ratpack
ratpack {
  handlers {
    path("Transaccion.asmx/getAffiliationSearch") {
      byMethod {
        get {
          response.contentType "text/xml"
          response.send '''<?xml version="1.0" encoding="utf-8"?>
            <ArrayOfStAffiliationSearch xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="https://mifarmaws02.orbisfarma.com.mx/">
                <stAffiliationSearch>
                    <transactionid>183477976581</transactionid>
                    <cardnumber>D007330811</cardnumber>
                    <accountnumber>D007330811</accountnumber>
                    <cardname>VILMA ALEJANDRINA</cardname>
                    <cardlastname>FERNANDEZ@RUIZ</cardlastname>
                    <cardbirthdate>19641008</cardbirthdate>
                    <cardgender>F</cardgender>
                    <carddoctor />
                    <cardcontactpreferences>1</cardcontactpreferences>
                    <cardemail />
                    <cardphone />
                    <cardcellphone />
                    <cardaddress>| | | | | |</cardaddress>
                    <cardrelated>8601080650271</cardrelated>
                    <cardfields>0</cardfields>
                    <errorid>0</errorid>
                    <message />
                    <transactiondate>2022-11-24 18:00:00</transactiondate>
                </stAffiliationSearch>
            </ArrayOfStAffiliationSearch>'''

groovy mock-service.groovy

Al consultar:

Documentación

https://ratpack.io/

Mapping with SCHEMA

Edgar Rios Navarro — Sat, 15 Oct 2022 23:58:43 +0000

Una mala práctica en la configuración de aplicaciones, es usar el owner del esquema para acceder a la base de datos.
Es recomendable crear una cuenta de usuario y otorgar los permisos necesarios y específicos.

Pongamos como ejemplo:

ESQUEMA: REGIONALIZACION
USUARIO: MSPRODUCTOSWOW
PERMISOS:

-- Oracle
GRANT SELECT, INSERT, UPDATE 
ON REGIONALIZACION.LGT_PROD_LOCAL_OFERTA_AUX 
TO MSPRODUCTOSWOW

Empleando las anotaciones de Jakarta Persistence, definimos el mapping de nuestra Entity: name/schema.

import jakarta.persistence.*;

@Table(name = "LGT_PROD_LOCAL_OFERTA_AUX", schema = "REGIONALIZACION")
public record WOWProduct(@EmbeddedId WOWProductId id,
                         float porcDctoOferta,
                         LocalDateTime fecIniVigOferta,
                         LocalDateTime fecFinVigOferta,
                         String usuCreaProdLocOfe,
                         LocalDateTime fecCreaProdLocOfe) {
}

Nótese que podemos usar record, incluso para definir una llave compuesta.

@Embeddable
record WOWProductId(
        @Column(name = "COD_GRUPO_CIA") String codGrupoCia,
        @Column(name = "COD_LOCAL") String codLocal,
        @Column(name = "COD_OFERTA") String codOferta,
        @Column(name = "COD_PROD") String codProd) {
}

Ejecutamos nuestro proyecto basado en #Micronaut:

Y al listar los productos:

Documentación

https://micronaut-projects.github.io/micronaut-data/latest/guide/#sqlAnnotations
https://github.com/edgargs/mn-jdbc-schema

Validar paquetes de Oracle con Docker (en un pipeline)

Edgar Rios Navarro — Tue, 30 Aug 2022 14:31:27 +0000

La forma correcta de asegurar que los paquetes de nuesta aplicación, no tengan errores durante el Pase a Producción; es compilarlos anticipadamente en un ambiente Pre-Producción (o UAT).

Pero si lo tenemos que hacer manualmente, existe la posibilidad de obviar algún script o validación.

De manera que, automatizar este paso es crucial en nuestra operación de CI/CD.

Como primer punto, es tener una base de datos inicial. Puede contener solo la estructura de las tablas y con ello reducimos el tamaño del export.

Realizamos el import en una imagen de Docker:

FROM docker.io/gvenzl/oracle-xe:11

Luego, ejecutaremos los scripts (DDL y DML). A continuación, compilaremos todos los paquetes.

De haber paquetes inválidos, el Pipeline fallará. Esa será la forma de validarlos.

Este es un ejemplo del archivo azure-pipelin.yml:

# Build Docker image for this app, to be published to Docker Registry
pool:
  vmImage: 'ubuntu-latest'
variables:
  buildConfiguration: 'Release'
steps:
- script: |
    git clone https://gitlab.com/edgar.gs/posunificado-docker-oracle11g.git
    cd posunificado-docker-oracle11g
    git checkout 5a9d701c0492841e734ee08dd1de10f6d652578d
- task: CopyFiles@2
  inputs:
    SourceFolder: 'posunificado-docker-oracle11g/DOCKER/init_scripts'
    contents: '**'
    targetFolder: 'fps-app-bd-posunificado/DOCKER/init_scripts'
- task: ExtractFiles@1
  inputs:
    archiveFilePatterns: 'posunificado-docker-oracle11g/DOCKER/PTOVENTA_V1.7.2.DMP.zip'
    destinationFolder: 'fps-app-bd-posunificado'
    cleanDestinationFolder: false
    overwriteExistingFiles: false 
- script: |
    cd fps-app-bd-posunificado
    docker build -f Dockerfile -t ptoventa-build:$BUILD_BUILDID .
    docker run --name ptoventadb ptoventa-build:$BUILD_BUILDID
- script: |
    docker start ptoventadb
    docker cp ptoventadb:/u01/app/oracle/artifacts $(System.DefaultWorkingDirectory)
    docker stop ptoventadb

- task: CopyFiles@2
  inputs:
    contents: '**/*.log'
    targetFolder: $(Build.ArtifactStagingDirectory)
- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: $(Build.ArtifactStagingDirectory)
    artifactName: MyBuildOutputs

Se puede observar la ejecución en el siguiente video:

Documentación

https://gitlab.com/edgar.gs/posunificado-docker-oracle11g.git
https://hub.docker.com/r/gvenzl/oracle-xe