[HombreSigma]

Saludos foro:

Sugiero aprovechar la tecnología de objetos de Delphi.

Como estas rutinas de captura de excepciones para validar la integridad de llave primaria y llave foránea son comunes a todas las tablas hace tiempo se me ocurrió crear un componente nuevo que llamé TTabla que hereda las características (métodos y propiedades) de TTable.

A este nuevo componente le modifique algunos de los métodos de los eventos tipicos de TTabla haciendo las validaciones estandar dentro de ellos.

Usando este componente, hasta ahora, me he olvidado por completo de tener que realizar validaciones de integridad tipicas como validacion de registros duplicados, mensajes de error en español, pues todo lo hace este componente, aprovechando los principios de la orientación a objetos de Delphi. De lo contrario estarían condenados para siempre a hacer copy paste del código de las validaciones mencionadas para cada TTable que ustedes crearan.

Envio un bosquejo del componente el cual se puede ampliar a conveniencia, luego pongase en una paleta de componentes personales y utilicese este componente en vez de TTable.

unit Tabla;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Db, DBCtrls, DBTables, ReglasValidacion, bdBaseDatos, ArchivoTexto,
  ComCtrls,Gauges, TiposComunes;

type
  TTabla = class(TTable)
  private
    { Private declarations }
    procedure MiDataSetPostError(DataSet: TDataSet;
                                   E: EDatabaseError;
                                   var Action: TDataAction);
    procedure MiUpdateError( DataSet: TDataSet;
                             E: EDatabaseError;
                             UpdateKind: TUpdateKind;
                             var UpdateAction: TUpdateAction);
    procedure MiDataSetDeleteError(DataSet: TDataSet;
                                   E: EDatabaseError;
                                   var Action: TDataAction);
    procedure MiBeforePost(DataSet:TDataSet);
    procedure MiBeforeDelete(DataSet:TDataSet);
    procedure MiBeforeInsert(DataSet:TDataSet);
    procedure MiBeforeEdit(DataSet:TDataSet);
    
   protected
    { Protected declarations }
   public
    { Public declarations }
   constructor Create (AOwner:Tcomponent);override;
    destructor Destroy;override;

  published
    { Published declarations }
  end;

implementation

constructor TTabla.Create (AOwner:TComponent);
var DataSetNo:Integer;
begin 
   inherited Create(AOwner);
  Self.OnDeleteError   :=MiDataSetDeleteError;
  Self.OnPostError     :=MiDataSetPostError;
  Self.BeforePost      :=MiBeforePost;
  Self.BeforeDelete    :=MiBeforeDelete;
  Self.BeforeInsert    :=MiBeforeInsert;
  Self.BeforeEdit      :=MiBeforeEdit;
  Self.OnUpdateError   :=MiUpdateError;
end;

destructor TTabla.Destroy;
begin
  //Destroy previos al de TTabla
  inherited Destroy;
end;

procedure TTabla.MiDataSetDeleteError
 (DataSet: TDataSet;E: EDatabaseError; var Action: TDataAction);
begin
  //Hacer aqui las validaciones estandar en caso de error al borrar un registro
end;


procedure TTabla.MiDataSetPostError
  (DataSet: TDataSet; E:EDatabaseError; var Action:TDataAction);
var MensajeValidacionIntegridadDatos:AnsiString;
begin
  inherited;
  //Validaciones estandar en caso de error al hacer POST
end;

procedure TTabla.MiUpdateError( DataSet: TDataSet;
                             E: EDatabaseError;
                             UpdateKind: TUpdateKind;
                             var UpdateAction: TUpdateAction);
begin
  inherited;
  //Validaciones estandar en caso de error al actualizar
end;

procedure TTabla.MiBeforePost(DataSet: TDataSet);
begin
  //Hacer validaciones estándar before post 
end;

procedure TTabla.MiBeforeDelete(DataSet: TDataSet);
begin
  if DataSet.IsEmpty
    then raise Exception.Create('No hay registros para borrar');
  //Otras validaciones estandar
end;

procedure TTabla.MiBeforeInsert(DataSet: TDataSet);
begin
  //Validaciones estandar BeforeInsert  
end;

procedure TTabla.MiBeforeEdit(DataSet: TDataSet);
begin
  //Validaciones estandar Before Edit
end;


end.