Jerarquía de clases de servicios de transacciones

Transaction, State, Transaction Log

La Transacción es el pilar fundamental del servicio de Transacciones. La transacción es en realidad cada operación que ejecutas sobre los datos. LaTransaction interfaz define tres propiedades:id ynewValue.type

Elid registro de la transacción debe ser único por registro de datos y definir el registro al que afecta esta transacción. Puedetype ser cualquiera de los tres tipos de transacción:ADD yDELETE,UPDATE dependiendo de la operación que ejecutes. ContienenewValue el valor del nuevo registro en caso de que añadas unaADD transacción. Si estás actualizando un registro existente,newValue solo contendrá los cambios. Puede que tengas varias transacciones deUPDATE tipo con el mismo ID. Si estás eliminando un registro, elnewValue contenido contendrá el valor del registro eliminado.

Puede ver un ejemplo de cómo se ve agregar cada tipo de transacción en el tema Cómo utilizar el servicio de transacciones.

Cada vez que añades una transacción, se añade al registro de transacciones y al deshacer la pila. Todos los cambios en el registro de transacciones se acumulan por registro. A partir de ese momento, el servicio mantiene un agregadoState. ConsisteState en registros únicos y cada registro puede pertenecer a uno de los tipos de transacciones soportados mencionados anteriormente.

Al añadir transacciones puedes activar lasstartPending pendientes llamando. Todas las transacciones posteriores se acumularán en una sola transacción hasta que llamesendPending. Si pasastrue aendPending la transacción acumulada, todas las transacciones acumuladas se añadirán como una sola transacción en el registro de transacciones y en la pila de deshacer.

Using igxBaseTransaction

Nuestro módulo de cuadrícula ofrece una implementación muy básica del servicio de Transacciones (igxBaseTransactionService) con funcionalidad de sesión pendiente que permite la función de Edición de Filas. Al usarstartPending yendPending la edición de fila puede combinar múltiples operaciones por celda en un solo cambio. Esto significa que editar varias celdas de un solo registro crea una sola transacción y puedes manejar solo el evento de edición de fila.

Dado que el estado acumulado es un objeto parcial, también podemos usar el servicio para verificar qué celda se ha editado y crear una interfaz de usuario en torno a eso.

NoigxBaseTransactionService tiene pila de deshacer, así que no ofrece funcionalidad de deshacer o rehacer.

Un ejemplo detallado de cómo puedes usarigxBaseTransactionService para habilitar la edición de filas se ofrece en los siguientes temas:

General information on igxTransactionService and igxHierarchicalTransactionService

igxTransactionServiceyigxHierarchicalTransactionService son middlewars inyectables, que implementan laTransaction Service interfaz. Un componente puede usarlos para acumular cambios sin afectar los datos subyacentes. El proveedor expone la API para acceder, manipular (deshacer y rehacer) y descartar o comprometer uno o todos los cambios en los datos.

En un ejemplo más concreto,igxTransactionService yigxHierarchicalTransactionService puede funcionar tanto con la edición de celdas como con la edición de filas de elIgxGrid. La transacción para la edición de celdas se añade cuando la celda sale del modo edición. Cuando comienza lastartPending edición de filas, la cuadrícula establece su servicio de transacciones en estado pendiente llamando. Cada celda editada se añade al registro de transacciones pendientes y no se añade al registro principal de transacciones. Cuando la fila sale del modo edición, todos los cambios se añaden al registro principal de transacciones y al registro de deshacer como una sola transacción.

En ambos casos (edición de celdas y edición de filas), el estado de las ediciones de la cuadrícula consta de todas las filas actualizadas, agregadas y eliminadas y sus últimos estados. Posteriormente, estos pueden inspeccionarse, manipularse y enviarse de una vez o por identificación. Los cambios se recopilan para celdas o filas individuales, según el modo de edición, y se acumulan por fila/registro de datos.

Using igxTransactionService

igxTransactionServiceextiendeigxBaseTransactionService.

Si quieres que tu componente use transacciones al realizar operaciones de datos, necesitas definir eligxTransactionService como proveedor en el array deproviders tu componente.

OfreceigxTransactionService una pila de deshacer para que puedas aprovechar la funcionalidad de deshacer y rehacer. La pila de Deshacer es en realidad un array que contiene arrays de transacciones. Al usar eligxTransactionService, puedes comprobar alcanUndo accesorio para entender si hay alguna transacción en la pila de Deshacer. Si las hay, puedes usar elundo método para eliminar la última transacción yredo aplicar la última transacción deshecha.

Puede encontrar un ejemplo detallado de cómo se implementa igxGrid con edición por lotes en el siguiente tema:

Edición por lotes de cuadrícula

Using igxHierarchicalTransactionService

igxHierarchicalTransactionServiceextiendeigxTransactionService.

EstáigxHierarchicalTransactionService diseñado para gestionar las relaciones entre padres e hijos (úsalo cuando tienes una estructura de datos jerárquica, por ejemploigxTreeGrid). El servicio garantiza que se añada un nuevo registro en el lugar que esperas al añadir unaADD transacción. Cuando eliminas un registro padre, sus hijos se promocionan al nivel superior de jerarquía, o se eliminan junto con su registro padre, dependiendo de la implementación. Puedes ver lacascadeOnDelete propiedad de la cuadrícula de árbol como ejemplo concreto: dependiendo del valor, eliminar un registro padre tendrá efectos diferentes sobre sus hijos.

En su aplicación, es posible que desee manejar el escenario en el que el usuario intenta agregar un registro secundario a un registro principal que ya está eliminado y está esperando que se confirme la transacción. El Servicio de transacciones no permitirá agregar un registro a un padre que se va a eliminar y se mostrará un mensaje de error en la Consola. Sin embargo, puede verificar si se va a eliminar un padre e implementar su propia alerta para el usuario usando el siguiente código:

    const state = this.transactions.getState(parentRecordID);
    if (state && state.type === TransactionType.DELETE) {
        // Implement your logic here
    }

Puedes encontrar ejemplos detallados de cómoigxTreeGrid yigxHierarchicalGrid con la edición por lotes se implementan en los siguientes temas:

Transaction Factory

En la implementación concreta de transacciones dentro de Ignite UI for Angular cuadrículas, se utiliza una fábrica para instanciar el servicio de transacción adecuado, dependiendo del valor de la redbatchEditing. Hay dos fábricas de transacciones separadas: laIgxFlatTransactionFactory (usada paraGrid yHierarchical Grid) yIgxHierarchicalTransactionFactory (usada para la Red de Árboles). Ambas clases exponen solo un método,create que devuelve una nueva instancia del tipo adecuado. El parámetro passed (TRANSACTION_TYPE) se usa internamente -Nonese usa cuandobatchEditing es falso yBase- cuando la edición por lotes está habilitada. Se usa unenum (en lugar de a-flagtruefalse), ya que permite ampliarse.

Using Transaction Factory

TantoIgxFlatTransactionFactory comoIgxHierarchicalTransactionFactory se proporcionan enroot la API pública y se exponen en ella. Si quieres instanciar una nueva instancia de un servicio de transacciones, dependiendo de alguna comprobación arbitraria, puedes usar una fábrica de transacciones.

En el siguiente ejemplo, puedes ver cómo puedes instanciar diferentes servicios de transacción dependiendo de una bandera arbitraria (hasUndo):

import { IgxFlatTransactionFactory, TRANSACTION_TYPE } from 'igniteui-angular/core';
// import { IgxFlatTransactionFactory, TRANSACTION_TYPE } from '@infragistics/igniteui-angular'; for licensed package

export class MyCustomComponent {
    ...
    constructor(private transactionFactory: IgxFlatTransactionFactory) {}
    ...
    public transaction!: IgxTransactionService<Transaction, State>;

    public set hasUndo(val: boolean) {
        if (val) {
            this.transactions = this.transactionFactory.create(TRANSACTION_TYPE.Base);
        } else {
            this.transactions = this.transactionFactory.create(TRANSACTION_TYPE.None);
        }
    }
}

Ambas clases de fábrica pueden extenderse y sobrescribirse en la jerarquía DI (usando elproviders array) para proporcionar tu propia implementación personalizada. Esto, combinado con el hecho de que todas las clases que instancian las fábricas también son públicas, te da mucho control sobre lo que se proporciona a los componentes que usan implementaciones de transacciones internamente.

Por ejemplo, para anular el servicio de transacciones utilizado internamenteIgxGridComponent, puedes hacer lo siguiente:

Primero, defina una clase de fábrica personalizada

import { IgxFlatTransactionFactory, TRANSACTION_TYPE, IgxBaseTransactionService,
TransactionService, Transaction, State } from 'igniteui-angular/core';
// import { IgxFlatTransactionFactory, TRANSACTION_TYPE, IgxBaseTransactionService,
// TransactionService, Transaction, State } from '@infragistics/igniteui-angular'; for licensed package

class CustomTransactionService extends IgxBaseTransactionService {
    ...
}

export class CustomTransactionFactory extends IgxFlatTransactionFactory {
    ...
    create(type: TRANSACTION_TYPE): TransactionService<Transaction, State> {
        if (type === TRANSACTION_TYPE.Base) {
            return new CustomTransactionService();
        }
        super.create(type);
    }
}

Luego, en el array deproviders tu componente, sobrescribe elIgxFlatTransactionFactory (usado porigx-grid) con tu implementación personalizada.

import { IgxFlatTransactionFactory } from 'igniteui-angular/core';
// import { IgxFlatTransactionFactory } from '@infragistics/igniteui-angular'; for licensed package
import { CustomTransactionFactory } from '../custom-factory.ts';

@Component({
    selector: 'app-grid-view',
    template: `<igx-grid [batchEditing]="true" [data]="data" [autoGenerate]="true"></igx-grid>`,
    providers: [{ provide: IgxFlatTransactionFactory, useClass: CustomTransactionFactory }]
})

export class GridViewComponent {
    ...
}

Ahora, cuandobatchEditing está configurado en ,true la cuadrícula recibirá una instancia deCustomTransactionService.