Proyecto Multiplataforma – Episodio 3 (Aplicación Cliente «Windows/Linux»)

Hola amigos.

En este Episodio vamos a crear nuestra Aplicación Cliente la cual enviará las peticiones http GET a nuestro Servidor Datasnap para obtener información de los métodos Usuario y Habitaciones.

Escribiremos el código necesario para procesar los dos tipos de RESPONSE que vimos en el Episodio 2.2 y mostraré las diferencias de serializar los objetos JSONObject y FDJSONDataSets. Esto lo haremos en dos aplicaciones independientes que nos servirán de prueba para después implementar el código realizado en la Aplicación Cliente principal.

***En el siguiente video vamos a consumir los métodos Usuario() y Habitaciones() que nos regresarán la clase TJSONObject.

***En el siguiente video vamos a consumir los métodos getUsuario() y getHabitaciones() que nos regresarán la clase TFDJSONDataSets.

Ya vimos como enviar las peticiones GET y consumir los métodos de nuestro Servidor DataSnap y la implementación de los métodos en la Aplicación Cliente se harán con aquellos que nos regresan la clase TJSONObject ya que nos permitirá desarrollar clientes desde cualquier herramienta de programación y no solo desde RAD Studio, sin embargo ustedes podrán decidir cual será su favorito.

Dicho lo anterior, todas las peticiones GET, PUT y POST que se agreguen a partir ahora se escribirán con Response TJSONObject y solo haremos un método para las peticiones PUT y POST como ejemplo ilustrativo de la clase TFDJSONDataSets los cuales se consumirá en una pequeña aplicación por separado, los demás métodos se consumirán directamente en nuestra Aplicación Cliente.

***En el siguiente video vamos a implementar los métodos vistos anteriormente en nuestra Aplicación Cliente y se compilará para el Escritorio de Windows (Win10) y para el Escritorio de Linux (Ubuntu).

Con esto terminamos el Episodio 3. En el siguiente Episodio veremos como generar una app Android a partir de nuestra Aplicación Cliente Base.

***Mientras tanto los invito a iniciar sus pruebas con peticiones GET y consumir sus métodos con la opción que mas les interese.

Nos vemos en la próxima

Nos vemos en la próxima entrada.

Proyecto Multiplataforma – Episodio 2.2 (Creación de Métodos)

Hola amigos.

En éste Episodio vamos a escribir un par de métodos para poder pasar a la siguiente etapa que es la construcción de las Aplicaciones Cliente y de esa forma avanzar con el proyecto.

Posteriormente cada método que se agregue en el Servidor, se hará la el proceso para el llamado del mismo desde la Aplicación Cliente para avanzar de forma paralela.

Primero vamos a rediseñar el método ValidaUsuario() ya que requerimos que además de validar que el usuario existe es necesario obtener la información del usuario que inició sesión en el sistema y mostrarla en la ventana principal.

Posteriormente vamos a crear el método Habitaciones() el cual nos regresará la información de las habitaciones para generar lo que en hotelería se le conoce como Rack de Habitaciones.

Un Rack permite visualizar de forma inmediata el estado de las habitaciones (Disponible, Ocupada, Limpia, Sucia, etc.) en una relación Habitación / Día, la siguiente imagen nos muestra un ejemplo de éste visor .

Vamos a mostrar dos formas diferentes de regresar objetos JSON para que ustedes decidan cual se adapta a sus necesidades. Para realizar esto se van a utilizar las siguientes clases:

  • TJSONObject
    • Con esta clase se creará el mapeo JSON del DataSet para que puedan escribir Aplicaciones Cliente con cualquier herramienta y poder serializar el contenido con formato JSON y extraer la información contenida.
  • TFDJSONDataSets
    • Con esta clase se creará el mapeo JSON del DataSet en formato «mime encoded binary content» por lo que solo será útil cuando se use RAD Studio en ambos extremos es decir tanto en el Servidor como en el Cliente.

***En el siguiente video vamos a crear los métodos con el objeto TJSONObject.

***En el siguiente video vamos a crear los métodos con el objeto TFDJSONDataSets

Con esto terminamos el Episodio 2 el cual hice en dos partes para separar el motor y los métodos que serán consumidos.

En el siguiente Episodio comenzaremos a diseñar nuestra aplicación de Escritorio para las plataformas Windows y Linux.

***Mientras tanto los invito a experimentar con la creación de métodos utilizando los dos enfoques TJSONObject y TFDJSONDataSets .

Nos vemos en la próxima

Nos vemos en la próxima entrada.

Proyecto Multiplataforma – Episodio 2.1 (Núcleo del proyecto)

Hola amigos

En este Episodio vamos a crear el núcleo de nuestro proyecto que nos permita la comunicación a través de Internet, de Red local o en el Localhost a las Aplicaciones Cliente desarrolladas en diferentes plataformas.

Construiremos una aplicación que permitirá a las Aplicaciones Cliente invocar los métodos implementados utilizando una tecnología llamada DataSnap la cual genera automáticamente la interfaz de comunicación entre las aplicaciones Cliente y el Servidor.

Antes de iniciar la creación de nuestro Servidor DataSnap vamos a definir algunos métodos que serán invocados desde las aplicaciones Cliente.

Métodos Get

  1. Validación de Usuario para Iniciar Sesión en el Sistema
  2. Obtener Información de las Habitaciones para crear el Rack de Habitaciones
  3. Obtener Detalle de una Habitación en particular
  4. Obtener Información de Huéspedes o un Huésped en particular.
  5. Obtener Listado de Productos o un solo Producto
  6. Obtener Estado de Cuenta

Métodos Post

  1. Check In
  2. Consumos
  3. Pagos
  4. Check Out
  5. Clientes

Creando el Servidor DataSnap

***En el siguiente video veremos como crear un Servidor DataSnap de forma simple y rápida. Una vez creado probaremos su funcionamiento con dos métodos que seguramente ya conocen EchoString() y ReverseString().

Como pudieron ver, crear el motor base de un Servidor DataSnap es muy fácil y muy rápido.

A continuación vamos a construir un método para validar la existencia de un usuario, dicho método requerirá el envío de los elementos USUARIO y CLAVE, se realizará la consulta a la base de datos y el retorno del método será de tipo Boolean, es decir Falso o Verdadero según corresponda.

Método para la Validación de Usuarios

***El siguiente video muestra como crear el Método para validad Usuario y Contraseña.

Ahora sabemos que crear un método con acceso a base de datos es muy fácil, éste método es muy simple porque solo valida si existe o no el registro solicitado y nos regresa un campos Booleano, muy simple pero la idea era mostrar la capacidad de generar métodos en el servidor DataSnap.

En el siguiente Episodio veremos ***Bloopers incluidos 🙂 *** como se regresan DataSets a las aplicaciones cliente y la facilidad con la que lo podemos hacer con nuestra querida herramienta de trabajo.

***Mientras tanto, los invito a experimentar con mas métodos que regresen datos simples y cualquier duda o comentario con gusto la ampliamos 😀

Nos vemos en la próxima

Nos vemos en la próxima entrada.

Proyecto Multiplataforma – Episodio 1 (Diseño de la Base de Datos)

Hola amigos,

Ya estamos listos para iniciar nuestro Proyecto Multiplataforma y lo primero que vamos a hacer es darle un nombre. En realidad no fue demasiado el tiempo que ocupé pero entre varios nombres que se me ocurrieron he elegido el siguiente:

***Aztlán Resort***

Si deseas conocer que es Aztlán da clic aquí.

Ahora, vamos a determinar «el que», «el como» y «el para qué» del proyecto y a partir de ahí crear nuestra base de datos.

Propósito

  • El sistema debe solicitar el registro del usuario que desea acceder al sistema. (Los perfiles de usuario no los veremos por ahora).
  • El sistema debe permitir al usuario ver el rack de habitaciones disponibles y ocupadas.
  • El sistema debe controlar las entradas de huéspedes.
  • El sistema debe permitir realizar cargos de consumos a la cuenta del huésped.
  • El sistema debe permitir a los clientes la búsqueda de habitaciones y ver sus detalles; costo, tipo de habitación, fotos, etc…
  • El sistema debe permitir consultar el estado de cuenta del huésped.
  • El sistema debe controlar la salida y los pagos de los huéspedes.

Definición

Nuestro sistema deberá contar con la información necesaria para poder controlar las habitaciones, su ocupación, todos los consumos de los huéspedes durante su estancia y la salida y pagos del huésped.

De acuerdo a lo anterior vamos a proceder a definir las tablas y su relación entre ellas, No vamos a profundizar en el diseño de una base de datos compleja ya que no es el objetivo que buscamos con el proyecto.

Tablas de la Base de Datos

  1. Habitaciones
    • Tabla Catálogo
    • Esta tabla contendrá las habitaciones del hotel así como la información de precios y disponibilidad.
  2. Tipo Habitación
    • Tabla Catálogo
    • Esta tabla contendrá los tipos de habitación y sus detalles.
  3. Reservas
    • Tabla Operativa
    • En esta tabla se registrarán las entradas y salidas de las habitaciones del Hotel y nos servirá para mostrar el rack de habitaciones.
  4. Clientes
    • Tabla Catálogo
    • Esta tabla contendrá la información de los huéspedes del Hotel
  5. Consumos
    • Tabla Operativa
    • En ésta tabla se registrarán todos los cargos por consumos durante la estancia del huésped en el Hotel.
  6. Pagos
    • Tabla Operativa
    • En esta tabla se registrarán todos los pagos que realice el huésped.
  7. Empleados
    • Tabla Catálogo
    • En esta tabla se registrarán a los usuarios del sistema.
  8. Productos
    • Tabla Catálogo
    • Catálogo de productos que el Hotel comercializa.

Relaciones

La Tabla HABITACIONES se relaciona con la Tabla TIPO_HABITACION a través del campo HABITACIONES.TIPO_HAB_ID con el campo TIPO_HABITACION.TIPO_HAB_ID.

La tabla RESERVAS se relaciona con la Tabla HABITACIONES a través del campo RESERVAS.HABITACION_ID con el campo HABITACIONES.HABITACION_ID y también con la Tabla CLIENTES a través del campo RESERVAS.CLIENTE_ID con el campo CLIENTES.CLIENTE_ID.

La Tabla CONSUMOS se relaciona con la Tabla RESERVAS a través del campo CONSUMOS.RESERVA_ID con el campo RESERVAS.RESERVA_ID y con la Tabla PRODUCTOS a través del campo CONSUMOS.PRODUCTO_ID con el campo PRODUCTOS.PRODUCTO_ID.

Por último la Tabla PAGOS se relaciona con la Tabla RESERVAS a través del campo PAGOS.RESERVA_ID con el campo RESERVAS.RESERVA_ID.

Diagrama Entidad Relación

Como pueden observar todas las tablas tienen una relación excepto la tabla EMPLEADOS la cual solo tendrá la función de permitir la entrada de usuarios al sistema.

*** No estamos considerando ningún acceso restringido (privilegios de usuario) ni contraseñas cifradas ya que no es parte del objetivo del proyecto.

Motor de Base de Datos

En mi caso he decidido utilizar el motor de Firebird para generar la Base de Datos del sistema, ustedes pueden elegir la que consideren mejor.

Campos Auto Incrementables

Para la asignación de nuestras llaves primarias como campos auto-incrementables se creó el generador (GEN_CAT_ID) el cual será ejecutado vía disparadores (Triggers) configurados en los eventos Before_Insert de cada una de las Tablas del sistema como se podrá observar en la definición de la base de datos que se muestra a continuación. 


/******************************************************************************/
/*         Generated by IBExpert 2021.8.1.1 26/08/2021 05:48:13 p. m.         */
/******************************************************************************/

SET SQL DIALECT 3;

SET NAMES ISO8859_1;

CREATE DATABASE 'C:\AZTLAN\BASE\AZTLAN.FDB'
USER 'SYSDBA' PASSWORD 'masterkey'
PAGE_SIZE 16384
DEFAULT CHARACTER SET ISO8859_1 COLLATION ISO8859_1;

/******************************************************************************/
/*                                 Generators                                 */
/******************************************************************************/

CREATE GENERATOR GEN_CAT_ID START WITH 0 INCREMENT BY 1;
SET GENERATOR GEN_CAT_ID TO 0;

/******************************************************************************/
/*                                   Tables                                   */
/******************************************************************************/

CREATE TABLE RESERVAS (
    RESERVA_ID       INTEGER NOT NULL,
    HABITACIONES_ID  INTEGER NOT NULL,
    CLIENTES_ID      INTEGER NOT NULL,
    FH_RESERVA       DATE NOT NULL,
    CHECKIN          TIMESTAMP NOT NULL,
    CHECKOUT         TIMESTAMP NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE CLIENTES (
    CLIENTE_ID       INTEGER NOT NULL,
    NOMBRE           VARCHAR(100) NOT NULL,
    DIRECCION        BLOB SUB_TYPE 1 SEGMENT SIZE 80,
    TELEFONO         VARCHAR(15),
    GENERO           VARCHAR(10) NOT NULL,
    DNI              VARCHAR(100),
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE EMPLEADOS (
    EMPLEADO_ID      INTEGER NOT NULL,
    NOMBRE           VARCHAR(30) NOT NULL,
    MATERNO          VARCHAR(30) NOT NULL,
    PATERNO          VARCHAR(30),
    USUARIO          VARCHAR(25) NOT NULL,
    CLAVE            VARCHAR(100) NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE PRODUCTOS (
    PRODUCTO_ID      INTEGER NOT NULL,
    TIPO             VARCHAR(25) NOT NULL,
    NOMBRE           VARCHAR(100) NOT NULL,
    COSTO            DOUBLE PRECISION NOT NULL,
    DESCRIPCION      BLOB SUB_TYPE 1 SEGMENT SIZE 80 NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE CONSUMOS (
    CONSUMO_ID       INTEGER NOT NULL,
    PRODUCTOS_ID     INTEGER NOT NULL,
    RESERVAS_ID      INTEGER NOT NULL,
    FH_CONSUMO       DATE NOT NULL,
    CANTIDAD         DOUBLE PRECISION NOT NULL,
    COSTO            DOUBLE PRECISION NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE PAGOS (
    PAGO_ID          INTEGER NOT NULL,
    RESERVAS_ID      INTEGER NOT NULL,
    IMPORTE          DOUBLE PRECISION NOT NULL,
    TIPO             VARCHAR(20) NOT NULL,
    OBSERVACIONES    BLOB SUB_TYPE 1 SEGMENT SIZE 80 NOT NULL,
    FH_PAGO          DATE NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE HABITACIONES (
    HABITACION_ID    INTEGER NOT NULL,
    TIPO_HAB_ID      INTEGER NOT NULL,
    NUMERO           VARCHAR(10) NOT NULL,
    DETALLES         BLOB SUB_TYPE 1 SEGMENT SIZE 80,
    ESTATUS          VARCHAR(10) NOT NULL
);

CREATE TABLE TIPO_HABITACION (
    TIPO_HAB_ID      INTEGER NOT NULL,
    TIPO             VARCHAR(100) NOT NULL,
    DESCRIPCION      BLOB SUB_TYPE 1 SEGMENT SIZE 80 NOT NULL,
    FOTO             VARCHAR(100) NOT NULL,
    COSTO            DOUBLE PRECISION NOT NULL,
    ESTATUS          VARCHAR(10) NOT NULL
);

/******************************************************************************/
/*                                Primary keys                                */
/******************************************************************************/

ALTER TABLE RESERVAS ADD CONSTRAINT PK_RESERVAS PRIMARY KEY (RESERVA_ID);
ALTER TABLE CLIENTES ADD CONSTRAINT PK_CLIENTES PRIMARY KEY (CLIENTE_ID);
ALTER TABLE EMPLEADOS ADD CONSTRAINT PK_EMPLEADOS PRIMARY KEY (EMPLEADO_ID);
ALTER TABLE PRODUCTOS ADD CONSTRAINT PK_PRODUCTOS PRIMARY KEY (PRODUCTO_ID);
ALTER TABLE CONSUMOS ADD CONSTRAINT PK_CONSUMOS PRIMARY KEY (CONSUMO_ID);
ALTER TABLE PAGOS ADD CONSTRAINT PK_PAGOS PRIMARY KEY (PAGO_ID);
ALTER TABLE HABITACIONES ADD CONSTRAINT PK_HABITACIONES PRIMARY KEY (HABITACION_ID);
ALTER TABLE TIPO_HABITACION ADD CONSTRAINT PK_TIPO_HABITACION PRIMARY KEY (TIPO_HAB_ID);

/******************************************************************************/
/*                                Foreign keys                                */
/******************************************************************************/

ALTER TABLE RESERVAS ADD CONSTRAINT FK_RESERVAS_1 FOREIGN KEY (HABITACIONES_ID) REFERENCES HABITACIONES (HABITACION_ID);
ALTER TABLE RESERVAS ADD CONSTRAINT FK_RESERVAS_2 FOREIGN KEY (CLIENTES_ID) REFERENCES CLIENTES (CLIENTE_ID);
ALTER TABLE CONSUMOS ADD CONSTRAINT FK_CONSUMOS_1 FOREIGN KEY (PRODUCTOS_ID) REFERENCES PRODUCTOS (PRODUCTO_ID);
ALTER TABLE CONSUMOS ADD CONSTRAINT FK_CONSUMOS_2 FOREIGN KEY (RESERVAS_ID) REFERENCES RESERVAS (RESERVA_ID);
ALTER TABLE PAGOS ADD CONSTRAINT FK_PAGOS_1 FOREIGN KEY (RESERVAS_ID) REFERENCES RESERVAS (RESERVA_ID);
ALTER TABLE HABITACIONES ADD CONSTRAINT FK_HABITACIONES_1 FOREIGN KEY (TIPO_HAB_ID) REFERENCES TIPO_HABITACION (TIPO_HAB_ID);

/******************************************************************************/
/*                                  Triggers                                  */
/******************************************************************************/

SET TERM ^ ;

/******************************************************************************/
/*                            Triggers for tables                             */
/******************************************************************************/

/* Trigger: RESERVAS_BI */
CREATE TRIGGER RESERVAS_BI FOR RESERVAS
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.reserva_id is null) then
    new.reserva_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: CLIENTES_BI */
CREATE TRIGGER CLIENTES_BI FOR CLIENTES
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.cliente_id is null) then
    new.cliente_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: EMPLEADOS_BI */
CREATE TRIGGER EMPLEADOS_BI FOR EMPLEADOS
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.empleado_id is null) then
    new.empleado_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: PRODUCTOS_BI */
CREATE TRIGGER PRODUCTOS_BI FOR PRODUCTOS
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.producto_id is null) then
    new.producto_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: CONSUMOS_BI */
CREATE TRIGGER CONSUMOS_BI FOR CONSUMOS
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.consumo_id is null) then
    new.consumo_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: PAGOS_BI */
CREATE TRIGGER PAGOS_BI FOR PAGOS
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.pago_id is null) then
    new.pago_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: HABITACIONES_BI */
CREATE TRIGGER HABITACIONES_BI FOR HABITACIONES
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.habitacion_id is null) then
    new.habitacion_id = gen_id(gen_cat_id,1);
end
^

/* Trigger: TIPO_HABITACION_BI */
CREATE TRIGGER TIPO_HABITACION_BI FOR TIPO_HABITACION
ACTIVE BEFORE INSERT POSITION 0
as
begin
  if (new.tipo_hab_id is null) then
    new.tipo_hab_id = gen_id(gen_cat_id,1);
end
^
SET TERM ; ^

El siguiente paso es inicializar algunas tablas para poder construir los métodos de nuestro Servidor DataSnap.

Tipo de Habitación

INSERT INTO TIPO_HABITACION (TIPO_HAB_ID, TIPO, DESCRIPCION, FOTO, COSTO, ESTATUS)
VALUES (NULL, 'SENCILLA', 'Habitación Sencilla una cama Matrimonial', 'C:\AZTLAN\FOTOS\SENCILLA.JPG', 1200, 'DISPONIBLE');
INSERT INTO TIPO_HABITACION (TIPO_HAB_ID, TIPO, DESCRIPCION, FOTO, COSTO, ESTATUS)
VALUES (NULL, 'DOBLE', 'Habitación Doble dos camas Matrimoniales', 'C:\AZTLAN\FOTOS\DOBLE.JPG', 1800, 'DISPONIBLE');
INSERT INTO TIPO_HABITACION (TIPO_HAB_ID, TIPO, DESCRIPCION, FOTO, COSTO, ESTATUS)
VALUES (NULL, 'JUNIOR SUITE', 'Habitación Junior Suite una cama Queen Size', 'C:\AZTLAN\FOTOS\JUNIORSUITE.JPG', 2800, 'DISPONIBLE');
INSERT INTO TIPO_HABITACION (TIPO_HAB_ID, TIPO, DESCRIPCION, FOTO, COSTO, ESTATUS)
VALUES (NULL, 'MASTER SUITE', 'Habitación Master Suite una cama King Size', 'C:\AZTLAN\FOTOS\MASTERSUITE.JPG', 4500, 'DISPONIBLE');
INSERT INTO TIPO_HABITACION (TIPO_HAB_ID, TIPO, DESCRIPCION, FOTO, COSTO, ESTATUS)
VALUES (NULL, 'TEMATICA', 'Habitación Temática una cama Queen Size', 'C:\AZTLAN\FOTOS\TEMATICA.JPG', 1500, 'DISPONIBLE');
COMMIT WORK;

Habitaciones

INSERT INTO HABITACIONES (HABITACION_ID, TIPO_HAB_ID, NUMERO, DETALLES, ESTATUS)
VALUES (NULL, 1, '100', 'Pantalla plana, Internet, Cafetera', 'LIMPIA');
INSERT INTO HABITACIONES (HABITACION_ID, TIPO_HAB_ID, NUMERO, DETALLES, ESTATUS)
VALUES (NULL, 2, '101', 'Pantalla plana, Internet, Servibar, Cafetera', 'LIMPIA');
INSERT INTO HABITACIONES (HABITACION_ID, TIPO_HAB_ID, NUMERO, DETALLES, ESTATUS)
VALUES (NULL, 3, '111', 'Pantalla plana, Internet, Servibar, Escritorio, Cafetera', 'LIMPIA');
INSERT INTO HABITACIONES (HABITACION_ID, TIPO_HAB_ID, NUMERO, DETALLES, ESTATUS)
VALUES (NULL, 4, '120', 'Pantalla plana, Internet, Servibar, Escritorio, Balcón, Cafetera', 'LIMPIA');
INSERT INTO HABITACIONES (HABITACION_ID, TIPO_HAB_ID, NUMERO, DETALLES, ESTATUS)
VALUES (NULL, 5, '430', 'Pantalla Plana, Cafetera',  'LIMPIA');
COMMIT WORK;

Empleados

INSERT INTO EMPLEADOS (EMPLEADO_ID, NOMBRE, MATERNO, PATERNO, USUARIO, CLAVE, ESTATUS)
VALUES (NULL, 'ELISEO', 'G.', 'N.', 'INSTALADOR', 'DelphiAccess', 'SUPER')

Con esto hemos terminado de diseñar nuestra Base de Datos que por supuesto nada tiene que ver con un ERP Hotelero, sin embargo, nos servirá perfectamente para los fines de éste proyecto multiplataforma.

En el siguiente episodio comenzaremos a construir los métodos REST de nuestro Back-End.

*** Mientras tanto los invito a publicar sus comentarios y/o sugerencias acerca de esta entrada.

Nos vemos en la próxima

Nos vemos en la próxima entrada.

Proyecto Multiplataforma

Hola amigos,

En el segundo Embarcadero Dev Lounge Latinoamérica al cual fui invitado hablamos acerca de porqué desarrollar para Linux, los pros y los contras de aprovechar dicha plataforma y algunas estadísticas acerca de segmento de mercado ocupado tanto por la versión Servidor como de la versión Escritorio y me recordó que en el CodeRage XII presenté la experiencia que obtuve al desarrollar una aplicación multiplataforma.

En dicha presentación mostré un ejercicio que intentaba transportar una aplicación de escritorio VCL a Linux utilizando el nuevo FMXLinux y por supuesto quise hacerlo también a las diversas plataformas que tenía a la mano, es decir, una Laptop con Windows, una Tableta con Android, una Laptop con OSX (Air Pro) y una Máquina Virtual con Linux (Ubuntu).

El resultado de ese primer intento es la siguiente imagen:

Dicha imagen muestra visualmente que se puede crear la misma aplicación para las diversas plataformas, sin embargo, aún no estaba de todo lista ya que por falta de tiempo en ese momento, agregué accesibilidad de Base de Datos solo a la aplicación Linux y a las demás plataformas solo interfaz gráfica, es decir, sin acceso a Base de Datos.

Y bueno, como ya estarán enterados, próximamente se lanzará al mercado el nuevo Delphi 11, por lo que aprovecharé este lanzamiento para continuar con mi proyecto multiplataforma el cual intenta mostrar que podemos desarrollar un Proyecto Multiplataforma con nuestra querida herramienta de trabajo.

Así que para iniciar esta aventura comenzaré por plasmar la idea de lo que quiero desarrollar.

Espero que el poco tiempo libre que me queda en el día a día me permita avanzar a un buen ritmo y sobre todo aprendiendo algo nuevo cada día.

Idea de concepto

Desarrollar un API que corra en un servidor (Windows/Linux) que permita acceder a él desde cualquier aplicación cliente ya sea desarrollada con Delphi o con cualquier otro lenguaje.

Alcance del proyecto

Gestionar la operación básica de un hotel desde el registro del huésped (CheckIn), el uso de las instalaciones (Consumos) hasta la salida del Hotel (CheckOut).

Etapas

Las etapas iniciales de éste proyecto contemplan las siguientes tareas:

  1. Creación de la Base de Datos (Firebird/PostgreSQL/Interbase/MySQL – La que se quiera utilizar). ***Ver el Episodio 1***
  2. Creación del núcleo del proyecto (API REST) con métodos para gestionar la operación del Hotel. ***Ver Episodio 2.1*** ***Ver Episodio 2.2***
  3. Creación de un cliente de escritorio (Windows / Linux). ***Ver Episodio 3***
  4. Creación de un cliente Móvil (Android).
  5. Creación de un cliente Web (Herramienta por definir).

Nota: Como en la vida real, dichas etapas podrán sufrir cambios de acuerdo a las necesidades y/o nuevas ideas que surjan durante el desarrollo de cada una de ellas ya sea propias o de ustedes que me acompañaran en este viaje.

Nos vemos en la próxima

Nos vemos en la próxima entrada.

RAD Studio 10.4.2

Recién he actualizado mi RAD Studio 10.4.1 y en esta ocasión la instalación fue «disparada» desde el Administrador de Descargas GetIt si cuentas con suscripción de actualización.

Y como es costumbre vamos a mostrar el paso a paso de la instalación de mi flamante RAD Studio 10.4.2

Iniciamos seleccionando las plataformas que se desean incluir en nuestro RAD, solo voy a seleccionar la plataforma Delphi Windows Enterprise y posteriormente vamos a instalar las demás plataformas en una serie de entradas independientes.

A manera de collage muestro imágenes del progreso de la instalación.

Durante la instalación nos pregunta si deseamos instalar el Kit de Desarrollo de Software para Windows (Windows SDK).

Una vez que la instalación a finalizado, se inicia nuestro flamante Delphi 10.4.2

Nota: La licencia que me otorga Embarcadero por ser miembro del programa MVP es renovada cada año y aún me quedan 109 días. Tenemos tiempo para hacer varias entradas 🙂

La primera vez que se inicia la versión instalada nos permite seleccionar el tema que mas nos guste.

He seleccionado el tema Dark y finalmente ya tenemos nuestro RAD en funcionamiento.

Esta versión cuenta con 3 parches los cuales por supuesto he instalado antes de comenzar a escribir código.

Ya tenemos nuestra nueva versión lista y esperando poner manos a la obra. En las próximas entradas instalaremos las demás plataformas,

Nos vemos en la próxima
Nos vemos en la próxima entrada

Webinar de Aniversario DelphiAccess (Replays)

Ya están disponibles los Videos del Webinar del Aniversario número 12 de la Comunidad DelphiAccess en su Canal de Youtube

Un grandioso evento que duró aproximadamente 8 horas continuas que nos ha dejado muchas enseñanzas y por supuesto mucha energía.

Muchas gracias a todos los panelistas que amablemente nos han regalado su valioso tiempo y su enorme conocimiento y por supuesto a quienes tomaron parte de su tiempo familiar para acompañarnos.

Mención especial a mi gran amigo Edgar Ramírez por su gran entusiasmo para organizar y dirigir el evento.

Vanessa Amaya

Richard Gress Méndez

Emilio Pérez

M. Yahaira Rodriguez Matla

Marcelo Cuadrado

Miguel Ángel Suárez

Nos vemos en la Próxima.

Delphi RIO y FMXLinux

Hola amigos, en esta ocasión toca hablar del nuevo y esperado Delphi para Linux Desktop y que le han llamado FMXLinux . Comenzaremos por dar su definición y los pasos a seguir para la configuración del ambiente de desarrollo, terminando con la ejecución de un ejemplo simple, si lo adivinaron…. el típico «Hola Mundo». 🙂

Ésta implementación Linux para Firemonkey es un complemento adicional que se instala en las ediciones Enterprise y Architect de Delphi y RAD Studio. Está disponible para clientes Delphi y RAD Studio Enterprise que cuentan con la Suscripción de actualización y la podrán descargar a través del GetIt Package Manager.

FireMonkey_for_Linux

Características principales de FMXLinux

– Permite crear aplicaciones GUI para Linux, extendiendo el framework de plataforma cruzada FireMonkey de Delphi.

– FMXLinux expande el soporte de Delphi a las distribuciones populares de Linux.

– Incluye varios estilos de interfaz de usuario listos para usar.

– Muchos de los componentes de FMX, como grids, widgets, etc. funcionan perfectamente en clientes Linux.

– Tiene soporte de WebKitGTK para ejecutar una aplicación FMXLinux como una aplicación web HTML5 en el navegador.

Pre-Requisitos

Antes de instalar FMXLinux, es necesario tener instalado el soporte de la plataforma Linux para Delphi. Podemos verificar si tenemos instalado Delphi Linux 64-Bits desde el menú Tools > Manage Platforms como se muestra en la siguiente imagen:

Una vez que nos aseguramos que tenemos instalada la plataforma Linux, ya podemos descargar e instalar el complemento FMXLinux, para ello vamos al menú Tools > GetIt Package Manager, buscamos por «fmxlinux» y nos mostrará dos descargas, el complemento y ejemplos.

Instalamos el complemento y si lo deseamos descargamos los ejemplos para probar el funcionamiento, Al final del proceso se reiniciará el IDE.

Por supuesto necesitamos una maquina linux para poder correr nuestros programas; en mi caso instalé Ubuntu Desktop 16.04.6

Se preguntarán porque una versión antigua… Bueno, les diré que antes de instalar ésta versión de Ubuntu, instalé dos versiones mas actuales.

– Ubuntu 18.04.2 LTS
– Ubuntu 19.04

Sin embargo, no pude configurar el SDK de ubuntu para que funcionara con éstas versiones de Ubuntu Desktop, al final tuve que instalar la versión que mencioné y el SDK se instaló sin problemas, debido a mi desconocimiento de Linux perdí 3 noches intentando instakar el SDK sin éxito hasta que en un último intento funcionó con Ubuntu 16.04.6.

PD: Recien me he enterado que mi buen amigo Germán Estévez (Neftalí) tiene instalada la versión 18.04 y funciona correctamente.

Lo dicho, tengo que estudiar Linux 🙂

Instalar Linux SDK

Para instalar el SDK de Linux se requiere de instalar un repositorio, abrimos una terminal y escribiremos las siguientes instrucciones:

sudo add-apt-repository ppa:ubuntu-sdk-team/ppa

sudo apt install ubuntu-sdk

Instalar «Platform Assistant» ( PAServer ) en Linux

Necesitamos instalar «Platform Assistant» en Linux para construir e implementar aplicaciones de Linux. PAServer le permite usar el Administrador de implementación, importar el SDK de Linux y realizar una depuración remota en un sistema Linux, tal y como se hace con Android, iOS, OSX, etc.

Para instalar PAServer en Linux siga estos pasos:

– Copie el archivo LinuxPAServer20.0.tar.gz a un directorio local de la máquina Linux.

– Abra una Terminal.

– Vaya al directorio donde se localiza el archivo LinuxPAServer20.0.tar.gz.

– Descompacte el archivo LinuxPAServer20.0.tar.gz con el siguiente comando tar –xvf LinuxPAServer20.0.tar.gz.

– Se creará el subdirectorio PAServer-20.0. Y aquí encontrará los binarios de la «Platform Assistant».

Instalar dependencias en Linux

Para usar características gráficas en su aplicación de servidor, es necesario instalar algunas dependencias. No se requiere instalar todo el sistema X11 en la maquina. Para instalar dependencias en Ubuntu/Debian, abra una Terminal y escriba lo siguiente:

sudo apt install libgl1-mesa-glx libglu1-mesa libgtk-3-common libgstreamer1.0 libgstreamer-plugins-base1.0

Configuración de FMXLinux

Al instalar FMXLinux a través de GetIt, el sistema registra un «DLL Expert» que agrega el menú contextual la opción «Agregar plataforma Linux» que se indica a continuación y también agrega la carpeta de la biblioteca del repositorio de catálogo a la Ruta de la biblioteca para la plataforma Linux. Puede verificar esto en Tools > Options > Language > Delphi Options > Library y elegir Linux de 64 bits.

Crear un perfil de conexión

Para crear el perfil de la conexión es necesario que PAServer esté en ejecución en la máquina Linux, para ello abra una terminal y entre al directorio donde se ha descompactado el archivo LinuxPAServer20.0.tar.gz y ejecute el comando ./paserver como se muestra en la imagen siguiente:

A continuación entramos a Delphi RIO en el menú Tools > Deployment > Connection Profile Manager y presionamos el botón [Add], agregamos la plataforma, la máquina Host, el puerto y la contraseña (si ha solicitado una), una vez que hemos llenado las propiedades de la conexión, probamos que se conecte correctamente presionando el botón [Test Connection] y si todo sale bien presionamos el botón [Save] y salimos.

Ya estamos listos para construir nuestra primer aplicación Linux. Abrimos (File > Open) o creamos un nuevo proyecto Firemonkey (File > New > Multi-Device Application) .

A continuación presionamos el botón derecho del mouse sobre el Proyecto y seleccionamos Add Linux platform.

Seleccionamos la plataforma Linux de 64 bits (en mi caso Ubuntu 16.04.6 LTS -fmxLinux profile) e implementar muestras aplicaciones GUI en Linux. Hay que asegurarnos que PAServer se está ejecutando en la máquina Linux de destino.

Atención: Al crear una aplicación FMXLinux, puede aparecer un mensaje de error que dice que System.Devices no es compatible con esta plataforma.

Error message.png

Esto sucede porque las rutas de la biblioteca no están configuradas correctamente y, en lugar de compilarse con el archivo DCU adecuado, el compilador busca la versión original del archivo de código fuente, que no es compatible.

Delphi Linux soporta RedHat Enterprise y las distribuciones Ubuntu que se muestran en la siguiente imagen:

Y bien, ya que hemos terminado de configurar nuestro ambiente Linux Desktop.

Agregamos un botón a la forma de nuestro proyecto y el código respectivo para mostrar el ya famosísimo «Hola Mundo».

Compilamos y ejecutamos y como se esperaba ya podemos ver nuestra aplicación Delphi corriendo en Linux.

Así de fácil y rápido.

Como pueden ver, el funcionamiento es el mismo que ya conocemos para crear aplicaciones multiplataforma así que no tendrán problema para desarrollar aplicaciones Linux.

Además ya existe mucho material en la nube acerca de éste complemento FMXLinux.

– FMXLinux
– Running the Platform Assistant on Linux
– Supported Target Platforms
– Preguntas frecuentes FMXLinux

Solo me resta invitarlos a experimentar y desarrollar aplicaciones multiplataforma con nuestra herramienta de desarrollo consentida Delphi.

Nos leemos en la próxima.

Delphi 10.3 RIO (Community Edition)

Que tal amigos, hace unos días se anunció el lanzamiento de la versión 10.3 de Delphi la cual ha sido llamada RIO y como se ha hecho una costumbre también ha sido liberada la edición Community la cual facilita la creación de aplicaciones multiplataforma ya sea como entretenimiento, aplicaciones personales o para iniciar un negocio personal. Ésti último como ya sabemos al obtener utilidades por un monto de 5,000 (cinco mil) dólares (o su equivalente en moneda local) se pide que siendo solidarios con el producto se adquiera una version de pago ya sea Professional, Enterprise o Architect.

Ésta edición trae varios cambios que en las siguientes entradas vamos a realizar algunos ejercicios para probar las nuevas características.

Imagen obtenida desde https://www.embarcadero.com/products/delphi

Y como ya es mi costumbre, les mostraré a través de capturas de pantalla la instalación en mi máquina de la Edición Community de Delphi 10.2 RIO.

Pueden descargar ésta edición desde la siguiente ruta: 

https://www.embarcadero.com/products/delphi/starter

Al iniciar la instalación se presentarán una serie de ventanas donde se decidirá que se va o que no se va a instalar. Tenga paciencia ya que se descargarán todas las características seleccionadas. Cabe mencionar que las ediciones Community no cuentan con un instalador ISO descargable, la instalación es vía Web.

Una vez instalado se muestra la ventana de inicio donde podrán ver los días que restan para que la licencia caduque, normalmente es de 1 año la cual puede renovarse y lo mejor es que se renovará con la versión que esté disponible en ese momento. Ya tenemos la experiencia de Delphi 10.2.3 Tokyo CE y al renovar lo hice para la versión 10.3 RIO.

En el primer acceso a Delphi CE nos pide la personalización de nuestro IDE.

Finalmente verémos nuestro Delphi en la configuración deseada, ya sea la vista Light o la vista Dark, en lo personale prefiero la Light, pero en ésta versión creo que le daré una oportunidad a la Dark, la han mejorado y me parece muy buena. Ustedes decidan cual es su preferencia. 🙂

Enjoy!!!

.

.

.

.

.

Nos vemos en la siguiente entrada.

Agregando reporteador a Delphi 10.2 Starter

Hola amigos,

Como hemos visto en los artículos anteriores, la Edición Delphi 10.2 Starter no cuenta con algunos componentes importantes para el desarrollo de aplicaciones y una de estas limitaciones es que no dispone de la posibilidad de generar reportes, por tal razón, comencé a investigar si existía algún componente que nos permitiera obtener reportes en nuestras aplicaciones y que además se pudiera instalar en ésta Edición de Delphi 10.2 Starter.

Intenté instalar algunos reporteadores conocidos sin éxito ya que éstos no tenían compatibilidad con Delphi 10.2 Starter, finalmente encontré una biblioteca llamada Virtual Print Engine (VPE) en su edición Community la cual instalé sin problemas ya que no tiene dependencia con componentes de Delphi y además sigue la misma filosofía ya que ésta biblioteca tiene el mismo concepto de Delphi Starter que es el principo de equidad el cual menciona que si utilizas la biblioteca para generar ganancias, les gustaría que se comprara la versión de pago lo cual me parece por demás aceptable.

La edición Community de VPE al ser gratuita también tiene sus limitaciones pero después de instalarlo y hacer algunas pruebas de concepto puedo asegurarles que es mas que suficiente para crear cualquier tipo de documento y exportarlo a PDF.

Para éste artículo requerimos de descargar el instalador de Report Engine and PDF Library, la versión que encontré disponible para éste tutorial es para Delphi XE2, sin embargo, no tuve problemas para instalarlo y utilizarlo en Delphi 10.2 Starter.

Al terminar la descarga procederemos a instalar la versión de 32 bits, recuerden que Delphi Starter solo tiene soporte para la arquitectura de 32bits y no para arquitectura de 64bits.

Ejecutamos el programa vpec32.exe el cual instalará el motor de impresión en nuestra maquina.

Agregar el componente a Delphi es muy fácil, solo cargamos el proyecto VpevclXe2.dproj en nuestro IDE lo compilamos y finalmente lo instalamos. El componente se instalará en el grupo System con el nombre TVPEngine como pueden observar en la siguiente imagen.

Nota 1: Antes de compilar deberá agregar el Path del componente en las opciones de Delphi en Tools –> Options — Delphi Options –> Library  –> Library Path como se observa en la siguiente imagen.

Nota 2: Si al compilar les genera el siguiente error:

[MakeDir Error] Unable to create directory «.\Win32\Debug\». Access to the path ‘.\Win32\Debug\’ is denied.
Failed

Deberán ejecutar Delphi con permisos de Administrador.

Ya estamos listos para comenzar a experimentar con éste nuevo componente, para ello vamos a abrir el proyecto que hemos estado desarrollando en ésta serie y vamos a hacer algunos cambios a la interfáz gráfica que me parecen adecuados.

Vamos a eliminar los componentes TDBGrid y TDataSurce de nuestra forma ya que no serán necesarios y agregamos un TButton y el nuevo componente TVPEngine.

Usted decida como quiere ver su interfáz gráfica, en mi caso se verá de la siguiente forma:

Antes de continuar les diré que el concepto del Virtual Printer Engine hace que no solo sea un simple reporteador sino un motor de informes para crear dinámicamente cualquier tipo de documento ya sea simple o complejo. La disposición de objetos me recordó viejos tiempos donde todo lo hacíamos a mano (me ha traido gratos recuerdos), sin embargo, a pesar de que en apariencia no se vea «tan profesional» nos proporciona el control total de como queremos mostrar la información .

El proceso para generar un informe es muy simple,

  • Se abre el TPVEngine
  • Se colocan los objetos (texto, imagen, lineas, etc) en las coordenadas deseadas,
  • Se muestra y se imprime o se genera un archivo PDF
  • Se cierra elTPVEngine.

Nota importante: En la edición Community la cual es gratuita, no se tiene la posibilidad de imprimir los documentos desde código, primero se tiene que visualizar en pantalla y después se podrá mandar a imprimir desde su visor, las ediciones de pago si que tienen mayores caracterìsticas.

Ya estamos listos para escribir código. Nuestra ventana tiene dos botones nuevos, uno para generar el documento en pantalla (Vista Previa) y el otro para exportar la información en un archivo PDF (Exporta a PDF).

Como ya les comenté el proceso es muy sencillo y lo vamos a hacer por separado para cada uno de los botónes con el objeto de que se tenga más comprensión del mismo.

Generamos la consulta de los tipos de cambio en un rango de fechas presionando el botón Vista Previa:

Se ejecuta el siguiente proceso:

  • Abrimos la consulta pasando el rango de fechas donde deseamos obtener.
  • Si se encuentra información, se genera el reporte.
    • Se genera el encabezado
    • Se genera el detalle de la información
  • Se muestra la Vista Previa del reporte
  ZQuery1.Close;
  ZQuery1.ParamByName('ini').asString := FormatDateTime('yyyy-mm-dd',dtpInicial.Date);
  ZQuery1.ParamByName('fin').AsString := FormatDateTime('yyyy-mm-dd',dtpFinal.Date);
  ZQuery1.Open;

  if not ZQuery1.IsEmpty then
  begin
    generaReporte;
    Report.Preview;
  end;

  ZQuery1.Close;
end;

En el procedimiento generaReporte se encuentra el código para la impresión de la información enmcabezado y detalle de la información.

procedure TForm1.GroupHeader(Fecha: String);
var
   y: double;
begin
  Report.TextAlignment := ALIGN_LEFT;
  y := Report.Print(1.5, Report.nBottom + 0.2, Format('[N S 14 C Blue]%s', [Fecha]));
  y := y + 0.1;
  Report.Print(1.5, y, '[S 10 C Purple]Clave');
  Report.Write(3.5, y, 6, VFREE, '[R]Tipo de Cambio');
  Report.Write(6.5, y, 19.5, VFREE, '[L]Descripción');
end;

procedure TForm1.DetailLine(color: TColor; Clave: String; TC:Real; Descrip: String);
var
  y: double;
begin
  y := Report.nBottom;
  Report.BkgMode := VBKG_SOLID;
  Report.BkgColor := color;
  Report.PenColor := color;
  Report.Box(1.5, y, 19.5, LineHeight+0.3);
  Report.BkgMode := VBKG_TRANSPARENT;

  Report.WriteBox(1.5, y, -4, LineHeight+0.3, Format('[S 7 C Black L]%s', [Clave]));
  Report.TextAlignment := ALIGN_RIGHT;
  Report.WriteBox(3.5, y, 6, LineHeight+0.3, Format('%4.5n', [TC]));
  Report.TextAlignment := ALIGN_LEFT;
  Report.WriteBox(6.5, y, 19.5, LineHeight+0.3, Format('%s', [Descrip]));
end;

procedure TForm1.generaReporte;
var
  I: integer;
  y: double;
  color: TColor;
  FechaCorte: TDateTime;
begin
  if Report.IsOpen then Report.CloseDoc;
  Report.OpenDoc;
  Report.RenderPrintBox(0, 0, '[S 14 C Black]x');
  LineHeight := -Report.nRenderHeight;
  Report.AutoBreakMode := AUTO_BREAK_NO_LIMITS;
  Report.SetPen(0.05, PS_SOLID, COLOR_BLACK);
  Report.Picture(1.5, 1.0, 8.5, 3.0, 'Imagenes\DenM.bmp');
  Report.WriteBox(9.5, 2.0, 19.5, 3, '[N S 9 CE I C Black BC Gray TO]Tipos de Cambio del ' +
                   FormatDateTime('dd "de" mmmm "de" yyyy',ZQuery1.ParamByName('INI').AsDate) + ' al ' +
                   FormatDateTime('dd "de" mmmm "de" yyyy',ZQuery1.ParamByName('FIN').AsDate) );
  y := Report.nBottom + 1;
  Report.Line(1.5, y, 19.5, y);
  Report.nBottom := y + 0.1;
  GroupHeader(FormatDateTime('d "de" mmmm "de" yyyy', ZQuery1.FieldByName('FECHA').AsDateTime));
  FechaCorte := ZQuery1.FieldByName('FECHA').AsDateTime;

  for I := 0 to ZQuery1.RecordCount-1 do
  begin
    if FechaCorte <> ZQuery1.FieldByName('FECHA').AsDateTime then
    begin
      GroupHeader(FormatDateTime('d "de" mmmm "de" yyyy', ZQuery1.FieldByName('FECHA').AsDateTime));
      FechaCorte := ZQuery1.FieldByName('FECHA').AsDateTime;
    end;
    if I mod 2 = 0 then
       color := COLOR_GRAY
    else
       color := COLOR_LTGRAY;
    DetailLine(color, ZQuery1.FieldByName('Clave').AsString,
	                  ZQuery1.FieldByName('TipCamb').AsFloat,
					  ZQuery1.FieldByName('Descripcion').AsString);
    ZQuery1.Next;
  end;

  Report.PageBreak;
  Report.SetFont('Arial', 10);
  Report.BkgMode := VBKG_SOLID;
  Report.BkgColor := clRed;
end;

Las funciones que se utilizan cuentan con toda la información necesaria para «pintar» la información, a continuación estudiaremos algunas.

Report.RenderPrintBox(0, 0, ‘[S 14 C Black]x’);

Se genera el espacio de trabajo desde el punto [0,0] , (S)tamaño de letra 14 y0(C)olor Negro.

Report.SetPen(0.05, PS_SOLID, COLOR_BLACK);

Asignamos el estilo de la pluma con espesor de 0.5, (PS)estilo sólido y (C)olor Negro.

Report.Picture(1.5, 1.0, 8.5, 3.0, ‘Imagenes\DenM.bmp’);

Con éste método se inserta la imagen DenM.bmp en la posición [1.5,1.0] [8.5,3.0].

Report.WriteBox(9.5, 2.0, 19.5, 3, ‘[N S 9 CE I C Black BC Gray TO]TEXTO’);

Se imprime un texto libre a partir de las cordenadas [9.5,2.0] [19.5,3.0] pero además se le indica las propiedades con las que será mostrado, (N) le indica que no guarde ésta configuración para los demás textos, (S) tamaño de letra 9, (CE)ntrado, fuente (I)talica, (C)olor Negro y (BC)Fondo Gris (TO)Sólido

Al dar clic al botón de Vista Previa el programa nos mostrará el reporte como se ve en la siguiente imagen:

Una vez que tenemos la Vista Previa podremos imprimir el documento y es que la edición Community de VPE no permite enviar a impresión desde código y solo puede hacerse desde la Vista Previa, eso y mucho mas se podrá hacer si se adquiere una de las versiones de pago.

Ahora vamos a crear un archivo PDF con el código asignado al botón Exporta a PDF.

En éste botón se ejecuta el siguiente proceso:

  • Abrimos la consulta pasando el rango de fechas donde deseamos obtener.
  • Si se encuentra información, se genera el reporte.
    • Se genera el encabezado
    • Se genera el detalle de la información
  • Se exporta la información a un archivo PDF
procedure TForm1.Button4Click(Sender: TObject);
begin
  ZQuery1.Close;
  ZQuery1.ParamByName('ini').asString := FormatDateTime('yyyy-mm-dd',dtpInicial.Date);
  ZQuery1.ParamByName('fin').AsString := FormatDateTime('yyyy-mm-dd',dtpFinal.Date);
  ZQuery1.Open;

  if not ZQuery1.IsEmpty then
  begin
    generaReporte;
    ExportDocumentNoAsk(Report, ExtractFilePath(Application.ExeName) + 'Report_' +
                                FormatDateTime('yyyymmdd_hhnnss', now) + '.pdf');
  end;

  ZQuery1.Close;
end;

Éste proceso creará el archivo PDF y posteriormente nos lo mostrará, ésto se genera en el procedimiento ExportDocumentNoAsk(). Éste procedimiento sustituye al Visor de reportes del botón anterior.

procedure TForm1.ExportDocumentNoAsk(Doc: TVPEngine; FileName: String);
begin
   if Doc.WriteDoc(FileName) then
   begin
     MessageDlg('Archivo PDF "' + FileName + '" creado satisfactoriamente.',
                 mtInformation, [mbOk], 0);
     ShellExecute(0, nil, PCHAR(Filename), nil, nil, SW_SHOWMAXIMIZED);
   end
   else begin
          MessageDlg('Error creating PDF file "' + FileName + '"!' + #10 +
                     'Possible reasons:' + #10 +
                     ' - the file is open in Acrobat Reader' + #10 +
                     ' - hard disk full' + #10 +
                     ' - no access rights to the folder' + #10 +
                     ' - out of memory' + #10 +
                     ' - export module missing', mtInformation, [mbOk], 0);
   end;
end;

Al terminar nos mostrará el archivo PDF creado como se ve en la imagen siguienre:

Hay muchas otras funciones, procedimientos que pueden estudiarse en el manual de control de referencia

Hasta aquí llegamos con la tercera entrega de la serie en la cual hemos abarcado solo tres características de uso común en cualquier aplicación (Consumo de webService, Acceso a Base de Datos y Generación de Reportes) y que la edición Starter de Delphi 10.2 no tiene disponibles.

Como siempre, espero que ésta información sea de su agrado pero sobre todo de utilidad. Por supuesto que el código presentado en todos mis artículos son hechos de la forma más básica posible con la intención de que sea fácil de entender por aquellos que están dando sus primeros pasos y nutrida por los grandes maestros que nos visitan.

Solo me resta decir que sigo investigando que mas se puede hacer, si alguien tiene alguna idea que quieran que se realice, con gusto estudiaremos si es posible desarrollarla con Delphi 10.2 Starter.

Hasta la próxima

Todo el código escrito aquí es de libre descarga y utilización solo te pido, si te parece correcto, que menciones su origen y claro cualquier mejora que le hagas publicala que se agradecerá enormemente.

Muchas gracias.