Implementación de Sistemas de Transacciones en Java: Validación y Gestión de Datos

Generación Dinámica de Códigos de Identificación

El siguiente método permite la creación de un identificador único basado en los atributos de la transacción. Se utiliza la clase StringBuilder para optimizar la concatenación de cadenas.

private String generarCodigoIdentificacion() {
    StringBuilder sb = new StringBuilder();

    // 1. Dos primeras letras del tipo
    sb.append(this.tipo.name().substring(0, 2));

    // 2. Letra D
    sb.append("D");

    // 3. Año y 4. Día del año (Usando métodos de LocalDateTime)
    sb.append(this.fecha.getYear());
    sb.append(this.fecha.getDayOfYear());

    // 5. Letra H
    sb.append("H");

    // 6. Hora y segundos
    sb.append(this.fecha.getHour());
    sb.append(this.fecha.getSecond());

    // 7. Barra "/"
    sb.append("/");

    // 8. Número aleatorio de dos dígitos (10-99)
    Random rnd = new Random();
    int aleatorio = rnd.nextInt(90) + 10;
    sb.append(aleatorio);

    return sb.toString();
}

Validación de Códigos mediante Expresiones Regulares

Para garantizar la integridad de los datos externos, implementamos un método estático que utiliza las clases Pattern y Matcher de Java para validar el formato del código.

public static boolean validarCodigo(String codigo) {
    // Patrón: 2 mayúsculas + D + 4 dígitos (año) + 1 a 3 dígitos (día) + H + dígitos + / + 2 dígitos
    String regex = "^[A-Z]{2}D\\d{4}\\d{1,3}H\\d+/\\d{2}$";

    Pattern patron = Pattern.compile(regex);
    Matcher matcher = patron.matcher(codigo);

    return matcher.matches();
}

Gestión de Transacciones con Matrices Bidimensionales

A continuación, se muestra cómo inicializar y recorrer una matriz bidimensional de objetos de tipo Transaccion, incluyendo el manejo de entradas de usuario.

// Array bidimensional 4x4 para almacenar objetos Transaccion
Transaccion[][] matriz = new Transaccion[4][4];

try {
    // Pedimos datos al usuario para la primera transacción (Posición 0,0)
    System.out.println("-> Datos para la Transacción 1:");
    matriz[0][0] = crearTransaccionDesdeTeclado();

    // Pedimos datos al usuario para la segunda transacción (Posición 0,1)
    System.out.println("-> Datos para la Transacción 2:");
    matriz[0][1] = crearTransaccionDesdeTeclado();

    // Mostramos el array bidimensional recorriendo filas y columnas
    System.out.println("\n--- Listado de Transacciones (Matriz) ---");
    for (int f = 0; f < matriz.length; f++) {
        for (int c = 0; c < matriz[f].length; c++) {
            // Importante: Verificar que no es null antes de imprimir
            if (matriz[f][c] != null) {
                System.out.println(matriz[f][c].toString());
            }
        }
    }
} catch (Exception e) {
    System.out.println("Error general en la ejecución: " + e.getMessage());
}

Procesamiento de Vectores y Validación Externa

Implementación de la lógica para rellenar y procesar un vector de cadenas de texto destinado a la validación masiva.

// --- PARTE 2: ARRAY DE STRINGS Y VALIDACIÓN ---
System.out.println("\n=== VALIDACIÓN DE CÓDIGOS EXTERNOS ===");

String[] vectorCodigos = new String[5];

// Llamada al método para rellenar códigos
rellenarVector(vectorCodigos);

// Llamada al método para procesar y validar
procesarValidacion(vectorCodigos);

Interfaz de Usuario y Control de Flujo

El siguiente bloque implementa un menú interactivo utilizando un bucle do-while y una estructura switch, asegurando la robustez frente a errores de formato numérico.

MENÚ:
int opcion;
do {
    System.out.println("1. Opción A");
    System.out.println("2. Opción B");
    System.out.println("0. Salir");

    // Control de error para evitar fallos por entrada de caracteres no numéricos
    try {
        opcion = Integer.parseInt(sc.nextLine());
    } catch (NumberFormatException e) {
        opcion = -1; // Forzamos opción inválida
    }

    switch (opcion) {
        case 1:
            // Llamar a método 1
            break;
        case 2:
            // Llamar a método 2
            break;
        case 0:
            System.out.println("Adiós");
            break;
        default:
            System.out.println("Opción no válida");
    }
} while (opcion != 0);

Métodos Auxiliares de Procesamiento

public static void rellenarVector(String[] vector) {
    System.out.println("Introduce 3 códigos para validar:");
    for (int i = 0; i < 3; i++) {
        System.out.print("Código " + (i + 1) + ": ");
        vector[i] = sc.nextLine();
    }
}

public static void procesarValidacion(String[] vector) {
    System.out.println("\n--- Resultado de la validación ---");
    for (String codigo : vector) {
        if (codigo != null) {
            // Usamos el método estático de la clase Transaccion
            boolean esValido = Transaccion.validarCodigo(codigo);
            String mensaje = esValido ? "válido" : "inválido";
            System.out.println(codigo + " - " + mensaje);
        }
    }
}

Captura de Datos y Manejo de Excepciones

Este método auxiliar facilita la creación de objetos controlando posibles errores de formato en fechas y tipos enumerados mediante bloques try-catch.

public static Transaccion crearTransaccionDesdeTeclado() {
    Transaccion t = null;
    boolean datosOk = false;

    // Bucle hasta que los datos sean correctos
    do {
        try {
            System.out.print("Tipo (VENTA, COMPRA, DEVOLUCION, ANULACION, PRUEBA): ");
            String tipoStr = sc.nextLine().toUpperCase();
            Transaccion.Tipo tipo = Transaccion.Tipo.valueOf(tipoStr); // Lanza IllegalArgumentException si falla

            System.out.print("Fecha (formato ISO aaaa-mm-ddThh:mm:ss): ");
            String fechaStr = sc.nextLine();
            LocalDateTime fecha = LocalDateTime.parse(fechaStr); // Lanza DateTimeParseException si falla

            t = new Transaccion(tipo, fecha);

            System.out.print("Descripción: ");
            t.setDescripcion(sc.nextLine());

            datosOk = true;

        } catch (IllegalArgumentException e) {
            System.out.println("ERROR: El tipo introducido no es válido.");
        } catch (DateTimeParseException e) {
            System.out.println("ERROR: El formato de la fecha es incorrecto.");
        }
    } while (!datosOk);

    return t;
}