Mostrando entradas con la etiqueta Handler. Mostrar todas las entradas
Mostrando entradas con la etiqueta Handler. Mostrar todas las entradas

jueves, 18 de julio de 2019

D365FO | Creación de métodos para control de eventos de datos

Los controladores de eventos de datos manejan los delegados expuestos en cada tabla, y estos se activan cuando ocurre el evento.
Hay dos métodos para cada uno: un método presente-continuo (ing) y un método en tiempo pasado (ed). Los métodos ing se invocan antes de que se active el evento, y el método ed se dispara después del evento.  
En nuestro ejemplo, el controlador de eventos se utiliza para asignar, validar y actualizar un campo. Por lo tanto, vamos a colocar estos métodos en una clase de ayuda. 

En nuestro caso, tenemos como escenario de prueba la aplicación para generar Renta de vehículos. Los registros se almacenan en la tabla HAVehicleRentTable.



- Crear una nueva clase. En nuestro caso HAVehicleRentManager.
- Abra el diseño de la tabla en cuestión, expanda el nodo Eventos y ubique onInserting.



- Haga clic derecho en el evento y elija Copiar el método del controlador de eventos.



- Abra la clase HAVehicleRentManager y pegue el código generado anteriormente en el cuerpo de la clase, como se muestra aquí:
 class HAVehicleRentManager  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(HAVehicleRentTable), DataEventType::Inserting)]  
   public static void HAVehicleRentTable_onInserting(Common sender, DataEventArgs e)  
   {
  
   }  
 }  

- A continuación, tendremos que escribir el código de la siguiente manera:
 class HAVehicleRentManager  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(HAVehicleRentTable), DataEventType::Inserting)]  
   public static void HAVehicleRentTable_onInserting(Common sender, DataEventArgs e)  
   {  
     HAVehicleRentTable vehicleRentTable = sender;  
     vehicleRentTable.numberDays = vehicleRentTable.toDate - vehicleRentTable.fromDate;  
     info(strFmt("Renta %1",vehicleRentTable.RentId));  
   }  
 }  

- Para probar esto, realice una compilación completa que incluya la sincronización de la base de datos. Y al crear una nueva renta de vehículo, el evento ejecuta nuestro código.



- Asignando el número de días y notificando el número de renta creado.



Al controlar campos en un diseño, también necesitamos controlar eventos como modifiedField y validateField. Para controlarlos, nos suscribiremos al evento de datos apropiado.

- Considerando lo antes mencionado. Abra el diseño de la tabla HAVehicleRentTable, haga clic derecho en el evento onValidatedField y elija Copiar el método del controlador de eventos.



- Pegue el código generado en el cuerpo de la clase HAVehicleRentManager, y escriba el código del evento de la siguiente manera:
 class HAVehicleRentManager  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(HAVehicleRentTable), DataEventType::ValidatedField)]  
   public static void HAVehicleRentTable_onValidatedField(Common sender, DataEventArgs e)  
   {  
     ValidateFieldEventArgs fieldArgs = e;  
     HAVehicleRentTable vehicleRentTable = sender;  
     Boolean ok = true;  
     switch(fieldArgs.parmFieldId())  
     {  
       case fieldnum(HAVehicleRentTable,toDate):  
         if(vehicleRentTable.toDate < vehicleRentTable.fromDate)  
         {  
           ok = checkFailed("Fecha");  
         }  
         break;  
     }  
     if(!ok)  
     {  
       fieldArgs.parmValidateResult(false);  
     }  
   }  
 }  

- Para probar esto, realice una compilación completa que incluya la sincronización de la base de datos. Y al modificar el valor del campo de fecha "Hasta", el evento ejecuta nuestra validación.



- Finalmente, abra el diseño de la tabla HAVehicleRentTable, haga clic derecho en el evento onModifyingField y elija Copiar el método del controlador de eventos.



- Pegue el código generado en el cuerpo de la clase HAVehicleRentManager, y escriba el código del evento de la siguiente manera:
 class HAVehicleRentManager  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(HAVehicleRentTable), DataEventType::ModifyingField)]  
   public static void HAVehicleRentTable_onModifyingField(Common sender, DataEventArgs e)  
   {  
     ModifyFieldEventArgs fieldArgs = e;  
     HAVehicleRentTable vehicleRentTable = sender;  
     //Boolean ok = true;  
     switch(fieldArgs.parmFieldId())  
     {  
       case fieldnum(HAVehicleRentTable,toDate):  
         vehicleRentTable.numberDays = vehicleRentTable.toDate - vehicleRentTable.fromDate;  
         break;  
     }  
   }  
 }  

- Para probar esto, realice una compilación completa que incluya la sincronización de la base de datos. Y al modificar el valor del campo de fecha "Hasta", el evento ejecuta nuestra actualización.



- Otras clases especializadas en DataEventArgs que son útiles son las siguientes:

lunes, 23 de abril de 2018

D365FO | Extensibilidad en tablas estándar (Eventos y Delegados)

Las extensiones de tabla proporcionan una forma de agregar campos a una tabla sin over-layering. Para agregar un campo a una tabla como una extensión, siga estos pasos:

- Localice la tabla SalesTable en el Explorador de Aplicaciones.
- Haz clic derecho y elige crear extensión.



- Recordando que todos los nombres de elementos deben ser globalmente únicos, cambie el nombre de la nueva extensión. Para nuestro caso SalesTable.HAExtension.
- Abra la extensión de la tabla y agregue el nuevo campo.



- Cree la clase de manejo de eventos. Para nuestro caso SalesTable_Extension.

 [ExtensionOf(tablestr(SalesTable))]  
 final class SalesTable_Extension  
 {  
   
 }  

- En el nodo Eventos de la tabla extendida SalesTable.HAExtension, haz clic derecho sobre el evento OnInserting; luego Copiar metodo de manejo de evento.


- Pegue el método en la clase de manejo de eventos creada, de la siguiente manera.

 [ExtensionOf(tablestr(SalesTable))]  
 final class SalesTable_Extension  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(SalesTable), DataEventType::Inserting)]  
   public static void SalesTable_onInserting(Common sender, DataEventArgs e)  
   {  
   
   }  
   
 }  

- Agregue dentro del evento el proceso que desee ejecutar, de la siguiente manera.

 [ExtensionOf(tablestr(SalesTable))]  
 final class SalesTable_Extension  
 {  
   /// <summary>  
   ///  
   /// </summary>  
   /// <param name="sender"></param>  
   /// <param name="e"></param>  
   [DataEventHandler(tableStr(SalesTable), DataEventType::Inserting)]  
   public static void SalesTable_onInserting(Common sender, DataEventArgs e)  
   {  
     SalesTable   salesTable = sender as SalesTable;  
   
     salesTable.HAName = salesTable.SalesName;  
     info(strFmt("Orden de venta %1 procesada",salesTable.SalesId));  
   }  
   
 }  

- Para nuestro ejemplo, el proceso se ejecutará cada vez que se cree una nueva Orden de venta.


- Adicionalmente, se almacenará el dato asignado en el nuevo campo.