LuisLeon_FactuGES/Source/Modulos/Remesas de proveedor/Controller/uRemesasProveedorController.pas

unit uRemesasProveedorController;

interface


uses
  Classes, SysUtils, uDADataTable, uControllerBase, uEditorDBItem,
  uIDataModuleRemesasProveedor, uBizRemesasProveedor, uProveedoresController,
  uBizContactos, uRecibosProveedorController;

type
  IRemesasProveedorController = interface(IObservador)
  ['{C14143FE-0806-4E64-93E2-A2C0170BBD41}']
    function Buscar(const ID: Integer): IBizRemesaProveedor;
    function BuscarTodos: IBizRemesaProveedor; overload;
    procedure Ver(ARemesaProveedor : IBizRemesaProveedor);
    procedure VerTodos(ARemesasProveedor: IBizRemesaProveedor);
    function Nuevo : IBizRemesaProveedor;
    procedure Anadir(ARemesaProveedor : IBizRemesaProveedor);
    function Eliminar(const ID : Integer): Boolean; overload;
    function Eliminar(ARemesaProveedor : IBizRemesaProveedor): Boolean; overload;
    function Guardar(ARemesaProveedor : IBizRemesaProveedor): Boolean;
    procedure DescartarCambios(ARemesaProveedor : IBizRemesaProveedor);
    function Existe(const ID: Integer) : Boolean;
    procedure Preview(ARemesaProveedor : IBizRemesaProveedor);
    procedure Print(ARemesaProveedor : IBizRemesaProveedor);

    function ElegirRecibosProveedor(ARemesaProveedor : IBizRemesaProveedor): Boolean;
    procedure EliminarReciboProveedor(ARemesaProveedor : IBizRemesaProveedor);
    function GetRecibosProveedorController: IRecibosProveedorController;
    property RecibosProveedorController: IRecibosProveedorController read GetRecibosProveedorController;

    procedure RecuperarRecibos(ARemesaProveedor: IBizRemesaProveedor);
    function ExtraerSeleccionados(ARemesasProveedor: IBizRemesaProveedor) : IBizRemesaProveedor;
  end;

  TRemesasProveedorController = class(TObservador, IRemesasProveedorController)
  protected
    FDataModule : IDataModuleRemesasProveedor;
    FRecibosProveedorController: IRecibosProveedorController;
    function GetRecibosProveedorController: IRecibosProveedorController;

    procedure RecibirAviso(ASujeto: ISujeto; ADataTable: IDAStronglyTypedDataTable); override;
    procedure AsignarID(ARemesaProveedor: IBizRemesaProveedor; const IDNuevo: Integer); virtual;
    function CreateEditor(const AName : String; const IID: TGUID; out Intf): Boolean;
    function _Vacio : IBizRemesaProveedor;

    procedure FiltrarEmpresa(ARemesaProveedor: IBizRemesaProveedor);
    function ValidarRemesaProveedor(ARemesaProveedor: IBizRemesaProveedor): Boolean; virtual;

    procedure RecuperarRecibos(ARemesaProveedor: IBizRemesaProveedor);
    procedure RecuperarObjetos(ARemesaProveedor: IBizRemesaProveedor); virtual;
    procedure AsignarDataModule; virtual;

  public
    property RecibosProveedorController: IRecibosProveedorController read GetRecibosProveedorController;

    constructor Create; virtual;
    destructor Destroy; override;

    function Eliminar(const ID : Integer): Boolean; overload;
    function Eliminar(ARemesaProveedor : IBizRemesaProveedor): Boolean; overload;
    function Guardar(ARemesaProveedor : IBizRemesaProveedor): Boolean;
    procedure DescartarCambios(ARemesaProveedor : IBizRemesaProveedor); virtual;
    function Existe(const ID: Integer) : Boolean; virtual;
    procedure Anadir(ARemesaProveedor : IBizRemesaProveedor); virtual;
    function Buscar(const ID: Integer): IBizRemesaProveedor; virtual;
    function BuscarTodos: IBizRemesaProveedor; overload;
    function Nuevo : IBizRemesaProveedor; virtual;
    procedure Ver(ARemesaProveedor : IBizRemesaProveedor); virtual;
    procedure VerTodos(ARemesasProveedor: IBizRemesaProveedor); virtual;
    procedure Preview(ARemesaProveedor : IBizRemesaProveedor); virtual;
    procedure Print(ARemesaProveedor : IBizRemesaProveedor); virtual;

    function ExtraerSeleccionados(ARemesasProveedor: IBizRemesaProveedor) : IBizRemesaProveedor; virtual;
    function ElegirRecibosProveedor(ARemesaProveedor : IBizRemesaProveedor): Boolean;
    procedure EliminarReciboProveedor(ARemesaProveedor : IBizRemesaProveedor);
  end;

implementation

uses
  cxControls, DB, uEditorRegistryUtils, schRemesasProveedorClient_Intf,
  schRecibosProveedorClient_Intf, uIEditorRemesasProveedor, uIEditorRemesaProveedor,
  Dialogs, uDataModuleRemesasProveedor, uDataModuleUsuarios, uDAInterfaces,
  uDataTableUtils, uDateUtils, uROTypes, DateUtils, Controls, Windows,
  uBizRecibosProveedor, Variants, uRemesasProveedorReportController;

{ TRemesasProveedorController }

procedure TRemesasProveedorController.Anadir(ARemesaProveedor: IBizRemesaProveedor);
begin
  ARemesaProveedor.Insert;
end;

procedure TRemesasProveedorController.EliminarReciboProveedor(ARemesaProveedor: IBizRemesaProveedor);
var
  ARecibosRemesa : IBizRecibosProveedor;
begin
  inherited;
  ARecibosRemesa := ARemesaProveedor.Recibos;
  RecibosProveedorController.QuitarRemesa(ARecibosRemesa);
  //Quitamos el recibo de la remesa sin que el servidor se entere para que no elimine el recibo
  DesconectarTabla(ARecibosRemesa.DataTable);
  ARecibosRemesa.DataTable.Delete;
  ConectarTabla(ARecibosRemesa.DataTable);
  ARecibosRemesa := Nil;
end;

procedure TRemesasProveedorController.AsignarDataModule;
begin
  FDataModule := TDataModuleRemesasProveedor.Create(Nil);
  FRecibosProveedorController := TRecibosProveedorController.Create;
end;

procedure TRemesasProveedorController.AsignarID(ARemesaProveedor: IBizRemesaProveedor; const IDNuevo: Integer);
begin
  if not Assigned(ARemesaProveedor) then
    raise Exception.Create ('RemesaProveedor no asignado');

  ARemesaProveedor.Edit;
  ARemesaProveedor.ID := IDNuevo;
  ARemesaProveedor.Post;
end;

function TRemesasProveedorController.Buscar(const ID: Integer): IBizRemesaProveedor;
begin
  Result := (FDataModule as IDataModuleRemesasProveedor).GetItem(ID);
  FiltrarEmpresa(Result);
end;

function TRemesasProveedorController.BuscarTodos: IBizRemesaProveedor;
begin
  Result := FDataModule.GetItems;
  FiltrarEmpresa(Result);
end;

constructor TRemesasProveedorController.Create;
begin
  AsignarDataModule;
end;

function TRemesasProveedorController.CreateEditor(const AName: String;
  const IID: TGUID; out Intf): Boolean;
begin
  Result := Supports(EditorRegistry.CreateEditor(AName), IID, Intf);
end;

procedure TRemesasProveedorController.DescartarCambios(ARemesaProveedor: IBizRemesaProveedor);
begin
  if not Assigned(ARemesaProveedor) then
    raise Exception.Create ('RemesaProveedor no asignado');

  ShowHourglassCursor;
  try
    if (ARemesaProveedor.State in dsEditModes) then
      ARemesaProveedor.Cancel;

    ARemesaProveedor.DataTable.CancelUpdates;
  finally
    HideHourglassCursor;
  end;
end;

destructor TRemesasProveedorController.Destroy;
begin
  FDataModule := Nil;
  FRecibosProveedorController := Nil;  
  inherited;
end;

function TRemesasProveedorController.ValidarRemesaProveedor(ARemesaProveedor: IBizRemesaProveedor): Boolean;
begin
  Result := False;

  if not Assigned(ARemesaProveedor) then
    raise Exception.Create ('Remesa no asignada');

  if (ARemesaProveedor.DataTable.State in dsEditModes) then
      ARemesaProveedor.DataTable.Post;

  if ARemesaProveedor.DataTable.FieldByName(fld_RemesasProveedorFECHA_REMESA).IsNull then
     raise Exception.Create('Debe indicar la fecha de esta remesa.');

  if ARemesaProveedor.ID_DATOS_BANCO < 1 then
     raise Exception.Create('Debe la cuenta bancaria sobre la que realizar<61> la remesa.');

  // Asegurarse de valores en campos "autom<6F>ticos"
  ARemesaProveedor.Edit;
  try
    ARemesaProveedor.USUARIO := dmUsuarios.LoginInfo.Usuario;

    Result := True;
  finally
    ARemesaProveedor.Post;
  end;
end;

procedure TRemesasProveedorController.Ver(ARemesaProveedor: IBizRemesaProveedor);
var
  AEditor : IEditorRemesaProveedor;
begin
  AEditor := NIL;
  ShowHourglassCursor;
  try
    RecuperarObjetos(ARemesaProveedor);

    CreateEditor('EditorRemesaProveedor', IEditorRemesaProveedor, AEditor);
    with (AEditor as IEditorRemesaProveedor) do
    begin
      Controller := Self; //OJO ORDEN MUY IMPORTANTE
      RemesaProveedor := ARemesaProveedor;
    end;
  finally
    HideHourglassCursor;
  end;

  if Assigned(AEditor) then
    try
      AEditor.ShowModal;
      AEditor.Release;
    finally
      AEditor := NIL;
    end;
end;

procedure TRemesasProveedorController.VerTodos(ARemesasProveedor: IBizRemesaProveedor);
var
  AEditor : IEditorRemesasProveedor;
begin
  AEditor := NIL;
  ShowHourglassCursor;
  try
    CreateEditor('EditorRemesasProveedor', IEditorRemesasProveedor, AEditor);
    with (AEditor as IEditorRemesasProveedor) do
    begin
      Controller := Self; //OJO ORDEN MUY IMPORTANTE
      RemesasProveedor := ARemesasProveedor;
    end;
  finally
    HideHourglassCursor;
  end;

  if Assigned(AEditor) then
    AEditor.ShowEmbedded;
end;

function TRemesasProveedorController._Vacio: IBizRemesaProveedor;
begin
  Result := Buscar(ID_NULO);
end;

function TRemesasProveedorController.Eliminar(const ID: Integer): Boolean;
var
  ARemesaProveedor : IBizRemesaProveedor;
begin
  ARemesaProveedor := Buscar(ID);

  if not Assigned(ARemesaProveedor) then
    raise Exception.Create(Format('No se ha encontrado la remesa con ID = %d', [ID]));

  Result := Eliminar(ARemesaProveedor);
  ARemesaProveedor := NIL;
end;

function TRemesasProveedorController.ElegirRecibosProveedor(ARemesaProveedor: IBizRemesaProveedor): Boolean;
var
  ARecibosRemesa : IBizRecibosProveedor;
  ARecibosSeleccionados : IBizRecibosProveedor;
begin
  Result := False;

  ARecibosSeleccionados := (FRecibosProveedorController.ElegirRecibos(FRecibosProveedorController.BuscarRecibosARemesar, 'Elija uno o m<>s recibos para incluirlos en esta remesa', True) as IBizRecibosProveedor);
  if Assigned(ARecibosSeleccionados) then
  begin
     ShowHourglassCursor;
     try
       ARecibosRemesa := ARemesaProveedor.Recibos;
       //Copia los recibos seleccionados a los recibos de la remesa sin que el servidor se entere de
       //las inserciones
       DuplicarRegistros(ARecibosSeleccionados.DataTable,ARecibosRemesa.DataTable, mdrTodos, False, False, True);
       FRecibosProveedorController.SetSituacionCobrados(ARecibosRemesa);
       Result := True;
     finally
       HideHourglassCursor;
     end;
  end;

  ARecibosRemesa := Nil;
  ARecibosSeleccionados := Nil;
end;

function TRemesasProveedorController.Eliminar(ARemesaProveedor: IBizRemesaProveedor): Boolean;
begin
  Result := False;

  if not Assigned(ARemesaProveedor) then
    raise Exception.Create ('RemesaProveedor no asignada');

  ShowHourglassCursor;
  try
    if (ARemesaProveedor.State in dsEditModes) then
      ARemesaProveedor.Cancel;

    //Si la llamada a eliminar es por el editor RemesasProveedor, debo recuperar los recibos
    //de la remesa a eliminar, en caso de venir por el editor RemesaProveedor ya los tengo
    if not Assigned(ARemesaProveedor.Recibos) then
       RecuperarRecibos(ARemesaProveedor);
    //Eliminaremos la remesa de los recibos asociados
    With ARemesaProveedor.Recibos.DataTable do
    begin
      First;
      While not Eof do
      begin
        RecibosProveedorController.QuitarRemesa(ARemesaProveedor.Recibos);
        Next;
      end;
    end;

    //Como no est<73>n declarados como maestro-detalles debemos hacer el applyupdates nosotros
    ARemesaProveedor.Recibos.DataTable.ApplyUpdates;

    //Si todo ha ido bien podremos eliminar la remesa
    ARemesaProveedor.Delete;
    ARemesaProveedor.DataTable.ApplyUpdates;

    HideHourglassCursor;
    Result := True;
  except
    //Hay algun recibo de la remesa que tiene movimientos (Cobros/Devoluciones) posteriores al cobro inicial de la remesa
    on E: Exception do
    begin
      ARemesaProveedor.Recibos.DataTable.CancelUpdates;
      ARemesaProveedor.DataTable.CancelUpdates;
      HideHourglassCursor;
      MessageBox(0, 'Exiten movimientos (Cobros/Devoluciones) en los recibos posteriores al cobro inicial de la remesa', 'Atenci<63>n', MB_ICONWARNING or MB_OK);
    end;
  end;
end;

procedure TRemesasProveedorController.RecibirAviso(ASujeto: ISujeto; ADataTable: IDAStronglyTypedDataTable);
begin
  inherited;
//
end;

procedure TRemesasProveedorController.RecuperarObjetos(ARemesaProveedor: IBizRemesaProveedor);
begin
  RecuperarRecibos(ARemesaProveedor);
end;

procedure TRemesasProveedorController.RecuperarRecibos(ARemesaProveedor: IBizRemesaProveedor);
begin
  ARemesaProveedor.Recibos := RecibosProveedorController.BuscarRecibosRemesa(ARemesaProveedor.ID);
end;

function TRemesasProveedorController.Existe(const ID: Integer): Boolean;
var
  ARemesaProveedor : IBizRemesaProveedor;
begin
  try
    ARemesaProveedor := Buscar(ID);
    Result := Assigned(ARemesaProveedor) and (ARemesaProveedor.ID = ID);
  finally
    ARemesaProveedor := NIL;
  end;
end;

function TRemesasProveedorController.ExtraerSeleccionados(ARemesasProveedor: IBizRemesaProveedor): IBizRemesaProveedor;
var
  ASeleccionados : IBizRemesaProveedor;
begin
  ASeleccionados := (Self.Buscar(ID_NULO) as IBizRemesaProveedor);
  CopyDataTable(ARemesasProveedor.DataTable, ASeleccionados.DataTable, True);
  Result := ASeleccionados;
end;

procedure TRemesasProveedorController.FiltrarEmpresa(ARemesaProveedor: IBizRemesaProveedor);
begin
  if ARemesaProveedor.DataTable.Active then
    ARemesaProveedor.DataTable.Active := False;

  // Filtrar los contactos actuales por empresa
  with ARemesaProveedor.DataTable.Where do
  begin
    if NotEmpty then
      AddOperator(opAND);
    // Para evitar ambig<69>edades en la SQL del servidor
    AddText(fld_RemesasProveedorID_EMPRESA + ' = ' + IntToStr(dmUsuarios.IDEmpresaActual));
//    AddCondition('##' + fld_RemesasProveedorID_EMPRESA, cEqual, dmUsuarios.IDEmpresaActual);
  end;
end;

function TRemesasProveedorController.GetRecibosProveedorController: IRecibosProveedorController;
begin
  Result := FRecibosProveedorController;
end;

function TRemesasProveedorController.Guardar(ARemesaProveedor: IBizRemesaProveedor): Boolean;
var
  NuevoID: Integer;
  bEsNuevo: Boolean;
begin
  Result := False;

  if ValidarRemesaProveedor(ARemesaProveedor) then
  begin
    ShowHourglassCursor;
    try
      bEsNuevo := ARemesaProveedor.EsNuevo;
      if (bEsNuevo) then
         NuevoID := FDataModule.GetNextID(ARemesaProveedor.DataTable.LogicalName)
      else
         NuevoID := ARemesaProveedor.ID;

      AsignarID(ARemesaProveedor, NuevoID);
      //Si es nuevo debemos hacer el applyupdates por la integridad referencial de BD
      if bEsNuevo then
         ARemesaProveedor.DataTable.ApplyUpdates;

      //Si todo ha ido bien, asignamos la remesa a los recibos asociados
      //Como no est<73>n declarados como maestro-detalles debemos hacer el applyupdates nosotros
      RecibosProveedorController.AsignarRemesa(ARemesaProveedor.Recibos, NuevoID);
      ARemesaProveedor.Recibos.DataTable.ApplyUpdates; //En este applyupdates tambien se realizar<61>n todos los cambios acumulados sobre los recibos asociados (EliminarReciboProveedor/ ElegirRecibosProveedor)

      //Es necesario ya que no se refrescan bien los deltas y despues del applyupdates siguen
      //existiendo deltas, de esta forma los limpiamos
      if ARemesaProveedor.Recibos.DataTable.HasDelta then
         ARemesaProveedor.Recibos.DataTable.Refresh;

      ARemesaProveedor.DataTable.ApplyUpdates;
      
      Result := True;
    finally
      HideHourglassCursor;
    end;
  end;
end;

function TRemesasProveedorController.Nuevo: IBizRemesaProveedor;
var
  ARemesaProveedor : IBizRemesaProveedor;
begin
  ARemesaProveedor := FDataModule.NewItem;
  FiltrarEmpresa(ARemesaProveedor);
  ARemesaProveedor.DataTable.Active := True;
  ARemesaProveedor.Insert;
  Result := ARemesaProveedor;
end;

procedure TRemesasProveedorController.Preview(ARemesaProveedor: IBizRemesaProveedor);
var
  AReportController : IRemesasProveedorReportController;
begin
  AReportController := TRemesasProveedorReportController.Create;
  try
    AReportController.Preview(ARemesaProveedor.ID);
  finally
    AReportController := NIL;
  end;
end;

procedure TRemesasProveedorController.Print(ARemesaProveedor: IBizRemesaProveedor);
var
  AReportController : IRemesasProveedorReportController;
begin
  AReportController := TRemesasProveedorReportController.Create;
  try
    AReportController.Print(ARemesaProveedor.ID);
  finally
    AReportController := NIL;
  end;
end;

end.