Validacion de datos en ExcelJS

 Hoy les traigo a la mano la información para poder crear datavalidation con ExcelJS o bien un dropdownlist en los archivos exportados desde java, sin mas por el momento vamos al codigo.

Un dataValidation permite agregar dropdownlist a una hoja de excel esta puede ser asignada por medio de un array de tipo string o bien hacer referencia de la informacion en otra hoja.

En el ejemplo de hoy veremos el caso de crear la lista a partir de la referencia de otra hoja del mismo documento, para ello creamos nuestro objeto Workbook. 

  
     var workbook = new ExcelJS.Workbook();
     workbook.creator = 'DivingJS';
     workbook.lastModifiedBy = 'inovania.blogspot.com';
     workbook.created = new Date();
     
  

Ahora por el momento agregaremos el primer registro que bien puede servir como header del documento para ello.

	var workSheet=workbook.addWorksheet("sheet_1");
    workSheet.addRow(["item 1","item 2", "item 3"]);

Aquí agregamos el contenido de la segunda hoja

	var workSheet_2=workbook.addWorksheet("sheet_2");
    workSheet_2.addRow(["elemento 1"]);
    workSheet_2.addRow(["elemento 2"]);
    workSheet_2.addRow(["elemento 3"]);
    workSheet_2.addRow(["elemento 4"]);
    workSheet_2.addRow(["elemento 5"]);
    workSheet_2.addRow(["elemento 6"]);
    

Una vez teniendo esto lo que sigue es agregar la regla para poder generar el dataValidation, esto queda de la siguiente manera.

    worksheet.getCell("B2").dataValidation = {
         type: 'list',
         allowBlank: true,
         showInputMessage: true,
         showErrorMessage: true,
         formulae: ["=sheet_2!$A$1:$A$6"]

Ahora bien, recibe los parametros allowBlank , showInputMessage, showErrorMessage, type, formulae. la propiedad type corresponde al tipo de dato que estará alojado en la celda seleccionada en este caso una lista.

En el parámetro formulae recibe un arreglo o en este caso la referencia para hacer un arreglo el cual lo encontrara en la hoja 2 asociado de la celda A1 a la celda A6. 

De esta manera es como referenciamos a otra hoja para crear nuestra lista.

Por ultimo exportamos el archivo y listo.

   await workbook.xlsx.writeBuffer()
         .then(buffer => saveAs(new Blob([buffer]),obj.name))
         .catch(err => console.log(err));

No olvides seguirme para ser de los primeros a quienes les llegue la notificación de lo que se publique.

Snake part_1

En este capitulo comenzaremos con una serie de tutoriales para crear el clásico juego de Snake, por el momento será solo en javascript, dibujando los frames en la etiqueta canvas.

En esta entrada comenzamos con la parte de html y css con el enlace a JS.

index.html

<canvas class="mcv" height="600" id="canvas" width="400"></canvas>

Por el momento el código html lo dejamos de con eso damas, mientras que el apartado css 

estilo.css

.mcv {
    border: solid 0px;
    box-shadow: 0px 0px 5px 2px #404040;
    float: left;
}

Comenzamos con el javascript de la siguiente manera.

Para este punto quiero mencionar que en este caso estoy comenzando a usar los objetos de tipo clase en javaScript.

El codigo comienza en con lo siguiente.

Game.js

class Game{
     //constructor de la clase
     constructor(){
          this.c = document.getElementById("canvas");
          this.ctx = this.c.getContext("2d");
     }
     //evento inicial de la clase
     //nos ayudara a iniciar los demas objetos
     init(){
          var ts = this;
          this.interval = setInterval(function() {
               ts.update();
          }, 500);
     }
     //evento que pintara lo que veremos
     draw(){
          this.ctx.clearRect(0,0,this.c.width,this.c.height);
          this.ctx.beginPath();
          this.ctx.font = "12px Verdana";
          this.ctx.fillStyle="green";
          this.ctx.fillText('inovania.blogspot.com', 50, 50);
          this.ctx.stroke();
     }
     //evento que actualiza el estado del juego.
     update(){
          this.draw();
     }
}
//llamado de la clase
new Game().init();

Dejamos hasta aquí la entrada.

No olvides seguirme para ser de los primeros en recibir las notificaciones de la continuidad del juego.

El Manejo de Arreglos en Java: Implementación del Método Slice

El manejo de arreglos es una característica fundamental en prácticamente cualquier lenguaje de programación. Algunos lenguajes permiten agregar y eliminar elementos de un arreglo fácilmente, y en este artículo veremos cómo implementar una función similar en Java. En particular, crearemos un método slice para trabajar con arreglos.

Para este ejemplo, usaremos un arreglo de tipo String.

Implementación del Método Slice

La función slice permite eliminar un elemento de un arreglo, ya sea por valor o por índice. A continuación se presenta el código:

    /**
     * Méthod slice, permite eliminar un elemento del arreglo
     * 
     * @param value variable de tipo Object en formato arreglo
     * @return arreglo de tipo String que contiene el nuevo arreglo
     */
    public String[] slice(Object... value){
        String[] arr=null;
        int pos=-1;
        String element = null;
        for (Object value1 : value) {
            if (value1 instanceof java.lang.String)
                element = value1.toString();
            if (value1 instanceof java.lang.Integer)
                pos=(int) value1;
            if (value1 instanceof java.lang.String[])
                arr = (String[]) value1;
        }
        String[]temp = new String[arr.length-1];
        int i=0,x=0;
        for(String a : arr){
            if(element!=null&&!a.equalsIgnoreCase(element)){
                temp[i]=a;
                i++;
            }
            if(pos>-1){
                if(i!=pos){
                    temp[x]=a;
                    x++;
                }
                i++;
            }
        }
        return temp;
    }

Uso del Método Slice

A continuacion muestro como se usa el metodo.

        
public static void main(String[] args) {
    // Creación del arreglo inicial
    String[] b = {"uno", "dos", "tres", "cuatro", "cinco", "seis", "siete"};
    
    // Eliminación del elemento "cuatro"
    b = slice(b, "cuatro");
    // Eliminación del elemento en la posición 1
    b = slice(b, 1);
    
    // Imprimir el arreglo resultante
    for (String b1 : b) {
        System.out.println(b1);
    }
}

Explicación del Código

Declaración del Método:

    El método slice acepta una lista variable de argumentos (Object... value), permitiendo flexibilidad en los parámetros

Identificación de Parámetros:

    Se identifica si cada parámetro es un String, un Integer, o un arreglo de String

Creación del Nuevo Arreglo:

    Se crea un nuevo arreglo (temp) de tamaño reducido para almacenar los elementos restantes después de la eliminación

Eliminación por Valor o Índice

• Si se proporciona un String, se eliminan todas las apariciones de ese valor.
• Si se proporciona un Integer, se elimina el elemento en esa posición

Impresión del Resultado

    El arreglo resultante se imprime en la consola

Conclusión

En este artículo, hemos implementado un método slice en Java que permite eliminar elementos de un arreglo por valor o por índice. Este tipo de manipulación de arreglos es común en muchos lenguajes de programación y puede ser muy útil en diversos contextos.

Espero que encuentres útil este método y que puedas integrarlo en tus proyectos. Si tienes alguna pregunta o comentario, no dudes en dejar un comentario a continuación. ¡Gracias por leer!

Metodo Push en Java

 El método push nos ayuda en la construcción de arreglo en JavaScript a diferencia del desarrollo en java, este método aparte de agregar elementos al arreglo incrementa en 1 la longitud del mismo. sin embargo en Java no existe tal método así que es necesario construirlo para ello vamos al código.

Para este ejemplo será un código push para un arreglo de tipo String.

Sin mas les dejo aquí el código.

/**
     * Autor<b>innovania.blogspot.com</b><br />
     * <br />
     * Metodo <b>push</b>: permite agregar un elemento al arreglo ya existente<br />
     * @param arr arreglo que se esta agregando el elemento value<br />
     * @param value valor a agregar <br />
     * @return nuevo arreglo con elemento value en la posicion final del arreglo
     */
public String[] push(String[] arr,String value){
    String[] temp = new String[arr.length];
    System.arraycopy(arr, 0, temp, 0, arr.length);
    arr= new String[temp.length+1];
    System.arraycopy(temp, 0, arr, 0, temp.length);
    arr[temp.length]=value;
    return arr;
}

Explicación del código. 

Comienza creando un arreglo igualando la longitud al arreglo que esta entrando.

Copia el arreglo entrante al temporal.

Construye un nuevo arreglo tomando la longitud del arreglo temporal mas 1.

Copia el contenido del arreglo temporal en el nuevo arreglo.

Agrega el valor del push en la ultima posición de ahora nuevo arreglo.

Retorna el nuevo arreglo con el nuevo valor agregado.

Ya por ultimo queda el llamado. 

    IncrementArray app = new IncrementArray();
        String[] a ={"uno","dos","tres"};
        a=app.push(a,"cuatro");
        a=app.push(a,"cinco");
        for (String a1 : a) {
            System.out.println(a1);
        }

Sin mas por el momento me despido, espero les ayude, si tienes dudas deja tu comentario y con gusto resolvemos juntos las dudas.

Exportar Imagen en Excel JS

 Hola a todos, en este momento aremos un archivo de excel a partir de la informacion en un arreglo de propiedades, entre estas propiedades estará una constante con images en base64.
Para ello utilizaremos las librerias de exceljs.js y FileSaver.js puedes acceder a estas librerías en las siguientes direcciones.

<script src="https://cdnjs.cloudflare.com/ajax/libs/amcharts/3.21.15/plugins/export/libs/FileSaver.js/FileSaver.min.js" type="text/javascript"> </script>
 <script crossorigin="anonymous" integrity="sha512-UnrKxsCMN9hFk7M56t4I4ckB4N/2HHi0w/7+B/1JsXIX3DmyBcsGpT3/BsuZMZf+6mAr0vP81syWtfynHJ69JA==" referrerpolicy="no-referrer" src="https://cdnjs.cloudflare.com/ajax/libs/exceljs/4.3.0/exceljs.min.js"> </script>

A partir de aquí lo que sigue es preparar nuestra información.

  var arreglo = [{ name: "Jane Doe",foto:'data:image/png;base64,/9j/4QAYRXhpZgAAS...'},{ name: "John Doe",foto:'data:image/png;base64,/9j/4QAYRXhpZgAAS...'}];
 var cols= [{field:'name',title:'Nombre'},{field:'foto',title:'IMAGEN'}];
  

Una vez que tenemos el insumo creamos nuestra función.

  async function exportFile(arry,cols,fileName){
     var workbook = new ExcelJS.Workbook();
     workbook.creator = 'inovania.blogspot.com';
     workbook.lastModifiedBy = 'inovania.blogspot.com';
     workbook.created = new Date();
     var worksheet =  workbook.addWorksheet('Sheet 1');
     var grd={
          columns:cols,
          data:array
     };
     var arrRow=[];
     grd.columns.map((e,i) => {
          arrRow.push(e.title);
     });
     worksheet.addRow(arrRow);
     for(var e=0;e<grd.data.length;e++){
          var arrDt = [];
          var logo;
          for(var x=0;x<grd.columns.length;x++){
               var c = grd.columns[x].field;
               if(x==0){
                    logo = workbook.addImage({
                         base64: grd.data[e][c],
                         extension: 'jpg',
                    });
                    arrDt.push("");
               }else{
                    arrDt.push(grd.data[e][c]);
               }
          }
          worksheet.addRow(arrDt);
          worksheet.addImage(logo, ('A'+(e+2)+":"+"A"+(e+2)));
     }
     await workbook.xlsx.writeBuffer()
          .then(buffer => saveAs(new Blob([buffer]),fileName+".xlsx"))
          .catch(err => console.log(err) );
};
  

Con esto solo nos queda el llamado el cual queda de la siguiente manera

  exportFile(arreglo,cols,"archivoInnovania");
  

De esta manera queda nuestro objeto capas de exportar imagenes en base64 en un archivo de excel.

Cabe mencionar que la función worksheet.addImage(img,rango); ocupa dos parámetros el primero es la imagen y el segundo parámetro es un rango de celdas, en este caso lo deje en la misma celda, pasándole como rango desde la celda ( A1 hasta la celda A1) A1:A1, simulando que este será un rango de celdas.

Quedo en espera de sus comentarios, hasta la proxima.

Creación y lectura de archivo desde java

 Hola a todos, está es una entrada mas al respecto en esta nota, explicare como crear y leer un archivo desde java.

Primero que nada una disculpa por la demora de mis entradas. Siguiendo con lo que nos truje, vamos a nuestro editor de mejor preferencia, en mi caso usare netbeans.

Para ello creamos un nuevo documento que será nuestra toma de decisiones.

Principal.java

package com.diving.inovania;

import java.io.FileWriter;
import java.io.IOException;

/**
 *
 * @author inovania.blogspot.com
 */
public class Principal {
    public static void main(String[] args) {
        Principal app = new Principal();
        app.createFile();
    }
}

El código encargado de la creación y escritura del documento queda de la siguiente manera

public void createFile() {
   FileWriter wr;
     try {
         wr = new FileWriter(path+"filename.txt");
         wr.write("Este es un archivo creado desde java\n");
         wr.write("Continua en\n");
         wr.write("https://inovania.blogspot.com");
         wr.close();
     } catch (IOException e) {
         System.out.println("Ocurrio un error: " + e.getMessage());
     }
}

Pero no siempre estaremos creando y sobre escribiendo el mismo documento. Es decir hay ocasiones en que se requiere abrir un archivo leerlo y agregar algo nuevo o simplemente leerlo. Para ello el siguiente metodo.

public String readFile() {
    Scanner sc;
        StringBuilder sb = new StringBuilder();
    try {
        File f = new File("E:\\Oscar\\blog\\filename.txt");
        sc = new Scanner(f);
        while (sc.hasNextLine()) {
            sb.append(sc.nextLine()).append("\n");
        }
        sc.close();
    } catch (FileNotFoundException e) {
        System.err.println("Erro al leer el archivo: " + e.getMessage());
    }
    return sb.toString();
}

De esta manera tenemos tanto la lectura como escritura del mismo archivo.

Sin mas por el momento me despido, no sin antes pedirles sus comentarios. hasta la proxima.

Java desde cero

Hola a todos, en esta entrada estaré escribiendo el comienzo de un nuevo tutorial, el cual vamos a ir viendo la creación y ejecución de java desde un editor de texto común hasta las herramientas propias de java.

Para ello es necesario contar con el paquete JRE y JDK, una vez obtenidos continuamos con el editor de texto que deseen y avanzamos.

Comenzamos con un archivo con extensión .java lo llamaremos.

HolaMundo.java

  public class HolaMundo{
  	public static void main(String[] args){
    	System.out.println("Hola Mundo");
    }
  }
  

Una vez que tengamos el archivo continuaremos con cmd posicionándonos en la ubicación del archivo HolaMundo.java ejecutando el siguiente comando.

_>: javac HolaMundo.java

Este comando compila el código en este momento se muestran todos los errores obtenidos durante la compilación, de salir todo bien se estará creando un archivo con el extensión .class.

El siguiente comando a ejecutar.

_>: java HolaMundo

Esta vez sin la extensión java ya que por ahora lo que estaremos ejecutando será el código compilado, de aquí en adelante si se realiza un cambio en el código, se debe de recompilar ejecutando javac seguido de java.

Por el momento es todo, no olvides comentar, que opinas al respecto. al igual que hacerte un seguidor y recibir las notificaciones de las siguientes publicaciones.