Delphi 數據庫 數據編輯 規範化

delphi數據庫編程一個規範化的控件， 主要有三种狀態，

DES_NONE, 清屏

DES_NEW,  新增

DES_BROWSE, 瀏覽

DES_EDIT 編輯

沒有增加過渡狀態描述， 如需要，請自擴充之

===========================================================================

unit JDBCmn;

interface
uses SysUtils;
type
  TDBEditorStatus = (DES_NONE, DES_NEW, DES_BROWSE, DES_EDIT);
  TDBEditorTryEvent = procedure(Sender: TObject; var Passed:Boolean) of object;

  TEditBaseException = class(Exception)
  end;

  IDBValidate = interface
    function Validate():boolean;
  end;

implementation

end.
 

===========================================================================

unit JDBEditorNotify;

interface

uses
  Windows, Messages, SysUtils, Classes, JDBCmn;

type

  IDBEditor = interface
      ['{98901426-28EC-4E8E-8952-888C587B59CC}']
      //
      function GetStatus():TDBEditorStatus;
      function TryInitData():Boolean;
      function TryActivateEditor(Active:Boolean):Boolean;
      function CanCloseEditor():Boolean;
      function TryCloseEditor():Boolean;
      //
      function CanNew():Boolean;
      function CanDelete():Boolean;
      function CanModify():Boolean;
      function CanSave():Boolean;
      function CanReset():boolean;
      //
      function TryNew():Boolean;
      function TryDelete():Boolean;
      function TrySave():boolean;
      function TryModify():Boolean;
      function TryReset():Boolean;
  end;

  TDBEditorNotify = class(TComponent, IDBEditor)
  private
    FCaption: string;
    FOnDBEditorSave: TNotifyEvent;
    FOnDBEditorDelete: TNotifyEvent;
    FOnDBEditorNew: TNotifyEvent;
    FOnDBEditorQuery: TNotifyEvent;
    FOnDBEditorModify: TNotifyEvent;
    FEditStatus: TDBEditorStatus;
    FOnDBEditorBeforeDelete: TDBEditorTryEvent;
    FOnDBEditorBeforeQuery: TDBEditorTryEvent;
    FOnDBEditorBeforeReset: TDBEditorTryEvent;
    FOnDBEditorBeforeSave: TDBEditorTryEvent;
    FOnDBEditorBeforeModify: TDBEditorTryEvent;
    FOnDBEditorBeforeNew: TDBEditorTryEvent;
    FOnDBEditorAfterNew: TNotifyEvent;
    FOnDBEditorAfterSave: TNotifyEvent;
    FOnDBEditorAfterQuery: TNotifyEvent;
    FOnDBEditorAfterReset: TNotifyEvent;
    FOnDBEditorReset: TNotifyEvent;
    FOnDBEditorAfterDelete: TNotifyEvent;
    FOnDBEditorAfterModify: TNotifyEvent;
    FOnDBEditorStatusChanged: TNotifyEvent;
    FEditStatusAfterSave: TDBEditorStatus;
    FAskSaveQuestion: String;
    FOnInit: TNotifyEvent;
    FOnActiveEditor: TNotifyEvent;
    FOnBeginTransaction: TNotifyEvent;
    FOnEndTransaction: TNotifyEvent;
    FOnRollBackTransaction: TNotifyEvent;
    FOnBeforeCloseEditor: TDBEditorTryEvent;
    FOnAfterCloseEditor: TNotifyEvent;
    { Private declarations }
    procedure SetFCaption(const Value: string);
    procedure SetOnDBEditorDelete(const Value: TNotifyEvent);
    procedure SetOnDBEditorModify(const Value: TNotifyEvent);
    procedure SetOnDBEditorNew(const Value: TNotifyEvent);
    procedure SetOnDBEditorQuery(const Value: TNotifyEvent);
    procedure SetOnDBEditorSave(const Value: TNotifyEvent);
    procedure SetEditStatus(const Value: TDBEditorStatus);
    procedure SetOnDBEditorAfterDelete(const Value: TNotifyEvent);
    procedure SetOnDBEditorAfterModify(const Value: TNotifyEvent);
    procedure SetOnDBEditorAfterNew(const Value: TNotifyEvent);
    procedure SetOnDBEditorAfterQuery(const Value: TNotifyEvent);
    procedure SetOnDBEditorAfterReset(const Value: TNotifyEvent);
    procedure SetOnDBEditorAfterSave(const Value: TNotifyEvent);
    procedure SetOnDBEditorBeforeDelete(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorBeforeModify(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorBeforeNew(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorBeforeQuery(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorBeforeReset(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorBeforeSave(const Value: TDBEditorTryEvent);
    procedure SetOnDBEditorReset(const Value: TNotifyEvent);
    procedure SetOnDBEditorStatusChanged(const Value: TNotifyEvent);
    procedure SetEditStatusAfterSave(const Value: TDBEditorStatus);
    procedure SetAskSaveQuestion(const Value: String);
    procedure SetOnInit(const Value: TNotifyEvent);
    procedure SetOnActiveEditor(const Value: TNotifyEvent);
    procedure SetOnBeginTransaction(const Value: TNotifyEvent);
    procedure SetOnEndTransaction(const Value: TNotifyEvent);
    procedure SetOnRollBackTransaction(const Value: TNotifyEvent);
    procedure SetOnAfterCloseEditor(const Value: TNotifyEvent);
    procedure SetOnBeforeCloseEditor(const Value: TDBEditorTryEvent);
  public
    { Public declarations }
      //
      constructor Create(AOwner:TComponent); override;
      function MessageBox(Info:String;BtnAndIcon:Integer=-1):Integer;
      function LocalTryAskDirtyDataAction(): Boolean;
      procedure WorkBegin(BeginTrans:Boolean);
      procedure WorkRollBack();
      // IDBEditor implementation
      function GetStatus():TDBEditorStatus;
      function TryInitData():Boolean;
      function TryActivateEditor(Active:Boolean):Boolean;
      function CanCloseEditor():Boolean;
      function TryCloseEditor():Boolean;
      // Auto Invoke OnDBEditorBeforeXXXXX Event
      function CanNew():Boolean;
      function CanDelete():Boolean;
      function CanModify():Boolean;
      function CanSave():Boolean;
      function CanReset():boolean;
      //  Auto Invoke OnDBEditorXXXXX events, Auto Invoke  OnDBEditorAfterXXXXX events, trace edit status
      function TryNew():Boolean;
      function TryDelete():Boolean;
      function TrySave():boolean;
      function TryModify():Boolean;
      function TryReset():Boolean;
      //
      property EditStatus:TDBEditorStatus read FEditStatus write SetEditStatus default DES_NONE;
  published
    { Published declarations }
    property Caption:string read FCaption write SetFCaption;
    property AskSaveQuestion:String read FAskSaveQuestion write SetAskSaveQuestion;
    property EditStatusAfterSave:TDBEditorStatus read FEditStatusAfterSave write SetEditStatusAfterSave default DES_NONE;
    // initialize, finalize
    property OnInit:TNotifyEvent read FOnInit write SetOnInit;
    property OnActiveEditor:TNotifyEvent read FOnActiveEditor write SetOnActiveEditor;
    property OnBeforeCloseEditor:TDBEditorTryEvent read FOnBeforeCloseEditor write SetOnBeforeCloseEditor;
    property OnAfterCloseEditor:TNotifyEvent read FOnAfterCloseEditor write SetOnAfterCloseEditor;

    //property OnCloseEditor:TNotifyEvent read FOnCloseEditor write SetOnCloseEditor;
    // before
    property OnDEBeforeNew:TDBEditorTryEvent read FOnDBEditorBeforeNew write SetOnDBEditorBeforeNew;
    property OnDEBeforeModify:TDBEditorTryEvent read FOnDBEditorBeforeModify write SetOnDBEditorBeforeModify;
    property OnDEBeforeDelete:TDBEditorTryEvent read FOnDBEditorBeforeDelete write SetOnDBEditorBeforeDelete;
    property OnDEBeforeSave:TDBEditorTryEvent read FOnDBEditorBeforeSave write SetOnDBEditorBeforeSave;
    property OnDEBeforeQuery:TDBEditorTryEvent read FOnDBEditorBeforeQuery write SetOnDBEditorBeforeQuery;
    property OnDEBeforeReset:TDBEditorTryEvent read FOnDBEditorBeforeReset write SetOnDBEditorBeforeReset;
    // on
    property OnDENew:TNotifyEvent read FOnDBEditorNew write SetOnDBEditorNew;
    property OnDEModify:TNotifyEvent read FOnDBEditorModify write SetOnDBEditorModify;
    property OnDEDelete:TNotifyEvent read FOnDBEditorDelete write SetOnDBEditorDelete;
    property OnDESave:TNotifyEvent read FOnDBEditorSave write SetOnDBEditorSave;
    property OnDEQuery:TNotifyEvent read FOnDBEditorQuery write SetOnDBEditorQuery;
    property OnDEReset:TNotifyEvent read FOnDBEditorReset write SetOnDBEditorReset;
    // after
    property OnDEAfterNew:TNotifyEvent read FOnDBEditorAfterNew write SetOnDBEditorAfterNew;
    property OnDEAfterModify:TNotifyEvent read FOnDBEditorAfterModify write SetOnDBEditorAfterModify;
    property OnDEAfterDelete:TNotifyEvent read FOnDBEditorAfterDelete write SetOnDBEditorAfterDelete;
    property OnDEAfterSave:TNotifyEvent read FOnDBEditorAfterSave write SetOnDBEditorAfterSave;
    property OnDEAfterQuery:TNotifyEvent read FOnDBEditorAfterQuery write SetOnDBEditorAfterQuery;
    property OnDEAfterReset:TNotifyEvent read FOnDBEditorAfterReset write SetOnDBEditorAfterReset;
    //
    property OnDEStatusChanged:TNotifyEvent read FOnDBEditorStatusChanged write SetOnDBEditorStatusChanged;
    property OnBeginTransaction:TNotifyEvent read FOnBeginTransaction write SetOnBeginTransaction;
    property OnEndTransaction:TNotifyEvent read FOnEndTransaction write SetOnEndTransaction;
    property OnRollBackTransaction:TNotifyEvent read FOnRollBackTransaction write SetOnRollBackTransaction;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('MY_CUSTOM', [TDBEditorNotify]);
end;

constructor TDBEditorNotify.Create(AOwner: TComponent);
begin
  inherited;
  Caption := 'Info';
  FAskSaveQuestion := 'Data is dirty, save it ?';
end;

function TDBEditorNotify.GetStatus: TDBEditorStatus;
begin
  result := EditStatus;;
end;

function TDBEditorNotify.CanDelete: Boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try              
   Passed := true;
   if Assigned(FOnDBEditorBeforeDelete) then FOnDBEditorBeforeDelete(Self, Passed);
   result := Passed;
  except
  end;
end;

function TDBEditorNotify.CanNew: Boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try
   Passed := true;
   if Assigned(FOnDBEditorBeforeNew) then FOnDBEditorBeforeNew(Self, Passed);
   result := Passed;
  except
  end;
end;
function TDBEditorNotify.CanCloseEditor: Boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try
   Passed := true;
   if Assigned(FOnBeforeCloseEditor) then FOnBeforeCloseEditor(Self, Passed);
   result := Passed;
  except
  end;
end;

function TDBEditorNotify.CanSave: Boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try
   Passed := true;
   if Assigned(FOnDBEditorBeforeSave) then FOnDBEditorBeforeSave(Self, Passed);
   result := Passed;
  except
  end;
end;

function TDBEditorNotify.CanModify: Boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try
   Passed := true;
   if Assigned(FOnDBEditorBeforeModify) then FOnDBEditorBeforeModify(Self, Passed);
   result := Passed;
  except
  end;
end;

function TDBEditorNotify.CanReset: boolean;
var
  Passed:Boolean;
begin
  Result := false;
  try
   Passed := true;
   if Assigned(FOnDBEditorBeforeReset) then FOnDBEditorBeforeReset(Self, Passed);
   result := Passed;
  except
  end;
end;

function TDBEditorNotify.TryActivateEditor(
  Active: Boolean): Boolean;
begin
  Result := true;
end;

function TDBEditorNotify.TryInitData: Boolean;
begin
  if Assigned(FOnInit) then FOnInit(Self);
  Result := true;
end;

function TDBEditorNotify.TryDelete: Boolean;
begin
  result := False;
  try
    if Assigned(FOnDBEditorDelete) then
      begin
        WorkBegin(true);
        FOnDBEditorDelete(Self);
        if Assigned(FOnDBEditorAfterDelete) then
          FOnDBEditorAfterDelete(Self);
        EditStatus := DES_NONE;
        result := true;
        WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

function TDBEditorNotify.TryNew: Boolean;
begin
  result := False;
  try
    if Assigned(FOnDBEditorNew) then
      begin
        //WorkBegin(true);
        FOnDBEditorNew(Self);
        if Assigned(FOnDBEditorAfterNew) then
          FOnDBEditorAfterNew(Self);
        EditStatus := DES_NEW;
        result := true;
        //WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        //WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

function TDBEditorNotify.TryModify: Boolean;
begin
  result := False;
  try
    if Assigned(FOnDBEditorModify) then
      begin
        //WorkBegin(true);
        FOnDBEditorModify(Self);
        if Assigned(FOnDBEditorAfterModify) then
          FOnDBEditorAfterModify(Self);
        EditStatus := DES_EDIT;
        result := true;
        //WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

function TDBEditorNotify.TrySave: boolean;
begin
  result := False;
  try
    if Assigned(FOnDBEditorSave) then
      begin
        WorkBegin(true);
        FOnDBEditorSave(Self);
        if Assigned(FOnDBEditorAfterSave) then
          FOnDBEditorAfterSave(Self);
        EditStatus := EditStatusAfterSave;
        result := true;
        WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

function TDBEditorNotify.TryReset: Boolean;
begin
  result := False;
  try
    if Assigned(FOnDBEditorReset) then
      begin
        WorkBegin(true);
        FOnDBEditorReset(Self);
        if Assigned(FOnDBEditorAfterReset) then
          FOnDBEditorAfterReset(Self);
        EditStatus := DES_NONE;
        result := true;
        WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

procedure TDBEditorNotify.SetFCaption(const Value: string);
begin
  FCaption := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorDelete(const Value: TNotifyEvent);
begin
  FOnDBEditorDelete := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorModify(const Value: TNotifyEvent);
begin
  FOnDBEditorModify := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorNew(const Value: TNotifyEvent);
begin
  FOnDBEditorNew := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorQuery(const Value: TNotifyEvent);
begin
  FOnDBEditorQuery := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorSave(const Value: TNotifyEvent);
begin
  FOnDBEditorSave := Value;
end;

procedure TDBEditorNotify.SetEditStatus(const Value: TDBEditorStatus);
begin
  FEditStatus := Value;
  if Assigned(FOnDBEditorStatusChanged) then FOnDBEditorStatusChanged(Self);
end;

procedure TDBEditorNotify.SetOnDBEditorAfterDelete(
  const Value: TNotifyEvent);
begin
  FOnDBEditorAfterDelete := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorAfterModify(
  const Value: TNotifyEvent);
begin
  FOnDBEditorAfterModify := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorAfterNew(const Value: TNotifyEvent);
begin
  FOnDBEditorAfterNew := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorAfterQuery(
  const Value: TNotifyEvent);
begin
  FOnDBEditorAfterQuery := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorAfterReset(
  const Value: TNotifyEvent);
begin
  FOnDBEditorAfterReset := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorAfterSave(
  const Value: TNotifyEvent);
begin
  FOnDBEditorAfterSave := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeDelete(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeDelete := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeModify(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeModify := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeNew(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeNew := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeQuery(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeQuery := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeReset(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeReset := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorBeforeSave(
  const Value: TDBEditorTryEvent);
begin
  FOnDBEditorBeforeSave := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorReset(const Value: TNotifyEvent);
begin
  FOnDBEditorReset := Value;
end;

procedure TDBEditorNotify.SetOnDBEditorStatusChanged(
  const Value: TNotifyEvent);
begin
  FOnDBEditorStatusChanged := Value;
end;

procedure TDBEditorNotify.SetEditStatusAfterSave(
  const Value: TDBEditorStatus);
begin
  if (Value = DES_NONE) or (Value = DES_BROWSE) or (Value = DES_NEW) then FEditStatusAfterSave := Value;
end;

function TDBEditorNotify.MessageBox(Info: String;
  BtnAndIcon: Integer=-1): Integer;
begin
  if BtnAndIcon=-1 then BtnAndIcon := MB_OK OR MB_ICONINFORMATION;
  result := Windows.MessageBox(GetForegroundWindow(), PChar(Info), PChar(Caption), BtnAndIcon);
end;

{
  return true if data doesn't need saving
}
function TDBEditorNotify.LocalTryAskDirtyDataAction(): Boolean;
var
  iReply:integer;
begin
  Result := false;
  if (EditStatus=DES_EDIT) or (EditStatus=DES_NEW) then
    begin
      iReply := MessageBox(AskSaveQuestion, MB_YESNOCANCEL or MB_ICONQUESTION);
      case iReply of
       IDCANCEL :
         EXIT;
       IDYES:
         begin
           if CanSave() then
             if not TrySave() then exit else
           else
             exit;
         end;
      end;
    end;
  Result := true;
end;

procedure TDBEditorNotify.SetAskSaveQuestion(const Value: String);
begin
  FAskSaveQuestion := Value;
end;

procedure TDBEditorNotify.SetOnInit(const Value: TNotifyEvent);
begin
  FOnInit := Value;
end;

procedure TDBEditorNotify.SetOnActiveEditor(const Value: TNotifyEvent);
begin
  FOnActiveEditor := Value;
end;

procedure TDBEditorNotify.SetOnBeginTransaction(const Value: TNotifyEvent);
begin
  FOnBeginTransaction := Value;
end;

procedure TDBEditorNotify.SetOnEndTransaction(const Value: TNotifyEvent);
begin
  FOnEndTransaction := Value;
end;

procedure TDBEditorNotify.WorkBegin(BeginTrans: Boolean);
begin
  if BeginTrans then
    begin
      if Assigned(FOnBeginTransaction) then FOnBeginTransaction(Self);
    end
  else
    begin
      if Assigned(FOnEndTransaction) then FOnEndTransaction(Self);
    end;
end;

procedure TDBEditorNotify.SetOnRollBackTransaction(
  const Value: TNotifyEvent);
begin
  FOnRollBackTransaction := Value;
end;

procedure TDBEditorNotify.WorkRollBack;
begin
  if Assigned(FOnRollBackTransaction) then FOnRollBackTransaction(Self);
end;

procedure TDBEditorNotify.SetOnAfterCloseEditor(
  const Value: TNotifyEvent);
begin
  FOnAfterCloseEditor := Value;
end;

procedure TDBEditorNotify.SetOnBeforeCloseEditor(
  const Value: TDBEditorTryEvent);
begin
  FOnBeforeCloseEditor := Value;
end;

function TDBEditorNotify.TryCloseEditor: Boolean;
begin
  result := False;
  try
    result := true;
    if Assigned(FOnAfterCloseEditor) then
      begin
        WorkBegin(true);
        FOnAfterCloseEditor(Self);
        WorkBegin(false);
      end;
  except
    on E:Exception do
      begin
        WorkRollBack;
        MessageBox(PChar(e.Message), MB_OK OR MB_ICONERROR);
      end;
  end;
end;

end.