{
===============================================================================
  Copyright (©) 2002. Rodax Software.
===============================================================================
  Los contenidos de este fichero son propiedad de Rodax Software titular del
  copyright. Este fichero sólo podrá ser copiado, distribuido y utilizado,
  en su totalidad o en parte, con el permiso escrito de Rodax Software, o de
  acuerdo con los términos y condiciones establecidas en el acuerdo/contrato
  bajo el que se suministra.
  -----------------------------------------------------------------------------
  Web:  www.rodax-software.com
===============================================================================
  Fecha primera versión: 26-01-2003
  Versión actual: 1.0.1
  Fecha versión actual: 07-06-2003
===============================================================================
  Modificaciones:

    Fecha         Comentarios
    ---------------------------------------------------------------------------
    07-06-2003    Revisadas las sentencias SQL para que no meta valores directos
                  en el campo 'TIPOENTRADA'.
===============================================================================
}

unit TablaLibros;

interface

uses
  //Generales
  SysUtils, Classes, Controls, IBSQL, cxGridDBTableView, cxCustomData, DB,
  //Particulares
  IBCustomDataSet, cxImageComboBox, Variants, RdxFrame, TablaPagosProveedor,

   cxDropDownEdit,

  //Aplicacion
  Framework, StrFunc, Entidades, Constantes, BaseDatos, RdxEmpresaActiva,

  // Contador
  Contadores, RdxGestorContadores, ImgList;

type
//TIPOSLIBRO
//Tipo enumerado correspondiente a los tipos de libro que manejara la aplicacion
  TTiposLibro = (ttlCaja, ttlBanco);

////////////////////////////////////////////////////////////////////////////////
//TListaLibros
////////////////////////////////////////////////////////////////////////////////
  TListaComboTiposLibro = (tltDefecto, tltTodos);
  TDatosLibro = class(TPersistent)
  public
    Codigo : String;
    Nombre : String;
    Predeterminado : Boolean;
  end;

  TListaLibros = class(TListaObjetos)
  private
    FSQL : TStringList;

    function GetDatosLibro(Index: Integer): TDatosLibro;
    procedure inicializarSQL(TipoLista:TListaComboTiposLibro);
  protected
    procedure AssignTo(Dest: TPersistent); override;
    procedure ObtenerListaBD; overload;
    procedure ObtenerLista; overload; override;
  public
    property Items[Index: Integer] : TDatosLibro read GetDatosLibro;
    constructor Create(TipoLista: TListaComboTiposLibro); overload;
    destructor Destroy; override;

    function cargarLista(Objcbx: TcxComboBox): Integer;
  end;

  TDatosDetalleLibro = class(TPersistent)
  public
    CodigoEmpresa : Integer;
    TipoLibro : String;
    NumEntrada : String;
    TipoEntrada : String;
    FechaAlta : String;
    Usuario : String;
    FechaEntrada : String;
    Descripcion : String;
    Cuantia : Double;
    ImporteAnt : Double;
    ImportePos : Double;
  end;

type
  TdmTablaLibros = class(TDataModule)
    imgGridLibros: TImageList;
  private
    procedure IniciarSQL;

    function darTipoLibro(TipoLibro: TTiposLibro): String;
    function darDescripcionLibro(TipoLibro: TTiposLibro): String; overload;
    function existenLibros(CodigoEmpresa: Variant): Boolean;
    function insertarLibro(TipoLibro: TTiposLibro; CodigoEmpresa: Variant): Boolean;
    function insertarLibros(CodigoEmpresa: Variant): Boolean;

  public
    //DETALLES LIBRO
    sqlInsertarDetalleLibro : TStrings;
    sqlModificarDetalleLibro : TStrings;
    sqlConsultarDetalleLibro : TStrings;
    sqlEliminarDetalleLibro : TStrings;
    sqlGridDetallesLibro : TStrings;
    sqlConsultarLibros : TStrings;

    //Metodos que llamaran a contador de CAJA
    function DarNuevoCodigoCaja : String;
    function IncrementarCodigoCaja: boolean;
    function InsertarContadorCaja : boolean;
    function ValidarCodigoCaja(Codigo : String) : Boolean;
    function FormatearCodigoCaja(Codigo : String) : String;

    //Metodos que llamaran a contador de BANCO
    function DarNuevoCodigoBanco : String;
    function IncrementarCodigoBanco: boolean;
    function InsertarContadorBanco : boolean;
    function ValidarCodigoBanco(Codigo : String) : Boolean;
    function FormatearCodigoBanco(Codigo : String) : String;

    function darNumEntrada(psTipoLibro: String): Variant;
    function incrementarNumEntrada(psTipoLibro: String): Boolean;

    constructor Create (AOwner : TComponent); override;
    destructor Destroy; override;

    //LIBRO
    function crearLibros(CodigoEmpresa: Variant): boolean;
    //    function darCodigoLibro(Descripcion : String) : String;


    function darLibros: TStrings; overload;
    procedure darLibros(var LibroTipo, TipoLibro: TStringList); overload;
    procedure darLibros(var TipoLibro: TStringList); overload;
    function darUltimoImportePos(TipoLibro: String): Double;

    //DETALLES LIBRO
    function existeDetalleLibro(TipoLibro, NumEntrada: String): Boolean;
    function darDatosDetalleLibro(var Datos: TDatosDetalleLibro): Boolean;
    function CerrarLibro(TipoLibro: String): Boolean;
    function EliminarDetallesLibro(TipoLibro: String): Boolean;
    function AnadirDetalleLibro(Datos: TDatosDetalleLibro): Boolean;

    function anadirEntradaLibro(Entidad: TRdxEntidad; Modo: TRdxModo; Datos: TDatosPago) : Boolean;
    function anularEntradaLibro(Entidad: TRdxEntidad; Modo: TRdxModo; Datos: TDatosPago) : Boolean;

    procedure InicializarGridDetallesLibro(var vGrid: TcxGridDBTableView);
    procedure InicializarTablaDetallesLibro(Tabla: TPTabla);
  end;

var
  dmTablaLibros: TdmTablaLibros;

implementation

{$R *.DFM}

uses Mensajes, Literales, TablaEmpresas;

const

    CaptionsTiposLibro : array [TTiposLibro] of string = (
               ('C'),                 //ttlCaja
               ('B')                  //ttlBanco
    );

    CaptionsDescripcionLibro : array [TTiposLibro] of string = (
               ('CAJA'),              //ttlCaja
               ('BANCO')              //ttlBanco
    );


constructor TdmTablaLibros.Create (AOwner : TComponent);
begin
  inherited;
  //DETALLES LIBRO
  sqlInsertarDetalleLibro := TStringList.Create;
  sqlModificarDetalleLibro := TStringList.Create;
  sqlConsultarDetalleLibro := TStringList.Create;
  sqlEliminarDetalleLibro := TStringList.Create;
  sqlGridDetallesLibro := TStringList.Create;
  sqlConsultarLibros := TStringList.Create;
  IniciarSQL;
end;

destructor TdmTablaLibros.Destroy;
begin
  //DETALLES LIBRO
  sqlInsertarDetalleLibro.Free;
  sqlModificarDetalleLibro.Free;
  sqlConsultarDetalleLibro.Free;
  sqlEliminarDetalleLibro.Free;
  sqlGridDetallesLibro.Free;
  sqlConsultarLibros.Free;
  inherited;
end;

procedure TdmTablaLibros.IniciarSQL;
begin
  with sqlInsertarDetalleLibro do
  begin
    Add('INSERT INTO DETALLESLIBROS (CODIGOEMPRESA, TIPOLIBRO, NUMENTRADA, TIPOENTRADA, FECHAALTA, USUARIO, ');
    Add('FECHAENTRADA, DESCRIPCION, CUANTIA, IMPORTEANT, IMPORTEPOS) ');
    Add('VALUES (:CODIGOEMPRESA, :TIPOLIBRO, :NUMENTRADA, :TIPOENTRADA, :FECHAALTA, :USUARIO, ');
    Add(':FECHAENTRADA, :DESCRIPCION, :CUANTIA, :IMPORTEANT, :IMPORTEPOS) ');
  end;

  with sqlModificarDetalleLibro do
  begin
    Add('update DETALLESLIBROS set ');
    Add('DESCRIPCION = :DESCRIPCION ');
    Add('where (CODIGOEMPRESA = :CODIGOEMPRESA ');
    Add('and TIPOLIBRO = :TIPOLIBRO ');
    Add('and NUMENTRADA = :NUMENTRADA)');
  end;

  with sqlConsultarDetalleLibro do
  begin
    Add('SELECT * FROM DETALLESLIBROS ');
    Add('where (CODIGOEMPRESA = :CODIGOEMPRESA ');
    Add('and TIPOLIBRO = :TIPOLIBRO ');
    Add('and NUMENTRADA = :NUMENTRADA)');
  end;

  with sqlEliminarDetalleLibro do
  begin
    Add('DELETE FROM DETALLESLIBROS ');
    Add('where (CODIGOEMPRESA = :CODIGOEMPRESA ');
    Add('and TIPOLIBRO = :TIPOLIBRO ');
    Add('AND NUMENTRADA = :NUMENTRADA)');
  end;

  with sqlGridDetallesLibro do
  begin
    Add('SELECT CODIGOEMPRESA, TIPOLIBRO, NUMENTRADA, TIPOENTRADA, FECHAENTRADA, DESCRIPCION, ');
    Add('CUANTIA, IMPORTEANT, IMPORTEPOS ');
    Add('FROM DETALLESLIBROS ');
    Add('WHERE CODIGOEMPRESA = :CODIGOEMPRESA ');
    Add('AND TIPOLIBRO = :TIPOLIBRO ');
  end;

  with sqlConsultarLibros do
  begin
    Add('select TIPO, DESCRIPCION ');
    Add('from LIBROS ');
    Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    Add('order by TIPO');
  end;
end;

function TdmTablaLibros.DarNuevoCodigoCaja : String;
begin
  Result := GestorContadores.darNuevoCodigo(contCaja);
end;

function TdmTablaLibros.DarNuevoCodigoBanco : String;
begin
  Result := GestorContadores.darNuevoCodigo(contBanco);
end;

function TdmTablaLibros.IncrementarCodigoCaja : boolean;
begin
  Result := GestorContadores.IncrementarValor(contCaja);
end;

function TdmTablaLibros.IncrementarCodigoBanco : boolean;
begin
  Result := GestorContadores.IncrementarValor(contBanco);
end;

function TdmTablaLibros.FormatearCodigoCaja(Codigo : String) : String;
begin
  Result := GestorContadores.formatearCodigo(contCaja, Codigo);
end;

function TdmTablaLibros.FormatearCodigoBanco(Codigo : String) : String;
begin
  Result := GestorContadores.formatearCodigo(contBanco, Codigo);
end;

function TdmTablaLibros.ValidarCodigoCaja(Codigo: String): Boolean;
begin
  Result := GestorContadores.validarCodigo(contCaja, Codigo);
end;

function TdmTablaLibros.ValidarCodigoBanco(Codigo: String): Boolean;
begin
  Result := GestorContadores.validarCodigo(contBanco, Codigo);
end;

function TdmTablaLibros.InsertarContadorCaja: boolean;
begin
  Result := GestorContadores.InsertarContador(contCaja);
end;

function TdmTablaLibros.InsertarContadorBanco: boolean;
begin
  Result := GestorContadores.InsertarContador(contBanco);
end;


////////////////////////////////////////////////////////////////////
//LIBRO
////////////////////////////////////////////////////////////////////
{
function TdmTablaLibros.darCodigoLibro(Descripcion: String): String;
var
  oSQL : TIBSQL;

begin
  Result := '';

  if EsCadenaVacia(Descripcion) then
    Exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select CODIGO ');
    SQL.Add('from LIBROS ');
    SQL.Add('where DESCRIPCION = :DESCRIPCION');
    ParamByName('DESCRIPCION').AsString := Descripcion;
    try
      Prepare;
      ExecQuery;
      Result := Fields[0].AsString;
    finally
      Close;
      Transaction := NIL;
      Free;
    end;
  end;
end;
}
function TdmTablaLibros.darLibros: TStrings;
var
  oSQL : TIBSQL;
  Lista : TStringList;
begin
  oSQL := TIBSQL.Create(Self);
  Lista := TStringList.Create;

  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select DESCRIPCION from LIBROS');
    SQL.Add(' where CODIGOEMPRESA = :CODIGOEMPRESA');
    SQL.Add(' order by DESCRIPCION');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    Prepare;
    ExecQuery;
    while not EOF do begin
      Lista.Append(Fields[0].AsString);
      Next;
    end;
    result := Lista;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

procedure TdmTablaLibros.darLibros(var LibroTipo, TipoLibro: TStringList);
var
  oSQL : TIBSQL;
begin
  if (LibroTipo = nil) or (TipoLibro = nil) then
    Exit;

  //Limpiamos los valores que tubieran antes (por si acaso)
  LibroTipo.Clear;
  TipoLibro.Clear;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;

    SQL.Add('select TIPO, DESCRIPCION from LIBROS ');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('order by TIPO');
  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    Prepare;
    ExecQuery;
    while not EOF do
    begin
      LibroTipo.Values[FieldByName('DESCRIPCION').AsString] := FieldByName('TIPO').AsString;
      TipoLibro.Values[FieldByName('TIPO').AsString] := FieldByName('DESCRIPCION').AsString;
      Next;
    end;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

procedure TdmTablaLibros.darLibros(var TipoLibro: TStringList);
var
  oSQL : TIBSQL;
begin
  if (TipoLibro = nil) then
    Exit;

  //Limpiamos los valores que tubieran antes (por si acaso)
  TipoLibro.Clear;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;

    SQL.Add('select TIPO, DESCRIPCION from LIBROS ');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('order by TIPO');
  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    Prepare;
    ExecQuery;
    while not EOF do
    begin
      TipoLibro.Values[FieldByName('TIPO').AsString] := FieldByName('DESCRIPCION').AsString;
      Next;
    end;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.darUltimoImportePos(TipoLibro: String): Double;
var
  oSQL : TIBSQL;

begin
  Result := -1;

  if EsCadenaVacia(TipoLibro) then
    Exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('SELECT IMPORTEPOS ');
    SQL.Add('FROM DETALLESLIBROS ');
    SQL.Add('WHERE CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('AND TIPOLIBRO = :TIPOLIBRO ');
    SQL.Add('AND NUMENTRADA = (SELECT MAX(NUMENTRADA) ');
    SQL.Add('FROM DETALLESLIBROS ');
    SQL.Add('WHERE CODIGOEMPRESA = :CODIGOEMPRESA');
    SQL.Add('AND TIPOLIBRO = :TIPOLIBRO)');

    try
      ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
      ParamByName('TIPOLIBRO').AsString := TipoLibro;
      Prepare;
      ExecQuery;
      if RecordCount <> 0 then
        Result := Fields[0].AsDouble
      else
        Result := 0;
    finally
      Close;
      Transaction := NIL;
      Free;
    end;
  end;
end;


////////////////////////////////////////////////////////////////////
//DETALLE LIBRO
////////////////////////////////////////////////////////////////////

function TdmTablaLibros.existeDetalleLibro(TipoLibro, NumEntrada: String): Boolean;
{Comprueba si existe un articulo en un determinado almacen, pasandole por
 parametro el codigo de articulo y el del almacen, devuelve true o false
 dependiendo si existe o no}
var
  oSQL : TIBSQL;
  Codigo : String;
begin
  Result := False;
  if (Length(Trim(TipoLibro)) = 0) or (Length(Trim(NumEntrada)) = 0) then
    Exit;

  oSQL := TIBSQL.Create(Self);

  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select TIPOLIBRO ');
    SQL.Add('from DETALLESLIBROS ');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('and TIPOLIBRO = :TIPOLIBRO ');
    SQL.Add('and NUMENTRADA = :NUMENTRADA ');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    ParamByName('TIPOLIBRO').AsString := TipoLibro;
    ParamByName('NUMENTRADA').AsString := NumEntrada;
    Prepare;
    ExecQuery;

    Codigo := FieldByName('TIPOLIBRO').AsString;
    Result := (TipoLibro = Codigo);
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.darDatosDetalleLibro(var Datos: TDatosDetalleLibro): Boolean;
{Devuelve los datos del articulo pasado por parametro si este existe en el
 almacen correspondiente, en caso de no existir devuelve false y rellena
 dichos datos con 0,0 y 1000 respectibamente}
var
  oSQL : TIBSQL;
begin
  Result := False;
  if (length(Datos.TipoLibro)= 0) or (length(Datos.NumEntrada)= 0) then
  begin
    //Para que cuando un articulo libre que no encuentra las existencias en
    //el almacen esten a cero
    Datos.Cuantia := 0;
    Exit;
  end;

  oSQL := TIBSQL.Create(Self);

  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select * ');
    SQL.Add('from DETALLESLIBROS ');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('and TIPOLIBRO = :TIPOLIBRO ');
    SQL.Add('and NUMENTRADA = :NUMENTRADA ');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    ParamByName('TIPOLIBRO').AsString := Datos.TipoLibro;
    ParamByName('NUMENTRADA').AsString := Datos.NumEntrada;
    Prepare;
    ExecQuery;

    if (RecordCount > 0) then
    begin
      Datos.TipoEntrada := FieldByName('TIPOENTRADA').AsString;
      Datos.FechaAlta := FieldByName('FECHAALTA').AsString;
      Datos.Usuario := FieldByName('USUARIO').AsString;
      Datos.FechaEntrada := FieldByName('FECHAENTRADA').AsString;
      Datos.Descripcion := FieldByName('DESCRIPCION').AsString;
      Datos.Cuantia := FieldByName('CUANTIA').AsDouble;
      Datos.ImporteAnt := FieldByName('IMPORTEANT').AsDouble;
      Datos.ImportePos := FieldByName('IMPORTEPOS').AsDouble;
      Result := True;
    end
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.EliminarDetallesLibro(TipoLibro: String): Boolean;
var
  oSQL : TIBSQL;
begin
  Result := False;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('delete from DETALLESLIBRO ');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA ');
    SQL.Add('and TIPOLIBRO = :TIPOLIBRO ');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    ParamByName('TIPOLIBRO').AsString := TipoLibro;
    Prepare;
    ExecQuery;
    Result := True;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

procedure TdmTablaLibros.InicializarGridDetallesLibro(var vGrid: TcxGridDBTableView);
var
  Columna : TcxGridDBColumn;
  ItemAux : TcxImageComboBoxItem;
begin

  with vGrid do begin
    OptionsView.Footer := True;

    {Columna TIPOLIBRO}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'TIPOLIBRO';
    Columna.Caption := 'Libro';
    Columna.Width := tamColCodigo;
    Columna.Options.Filtering := False;
    Columna.Visible := False;

    {Columna FECHAENTRADA}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'FECHAENTRADA';
    Columna.Caption := 'Fecha entrada';
    Columna.Width := tamColFechaEntrada;
    Columna.Options.Filtering := False;

    with TcxGridDBTableSummaryItem(DataController.Summary.FooterSummaryItems.Add) do
    try
      try
        BeginUpdate;
        Column := Columna;
        FieldName := Columna.DataBinding.FieldName;
        Format := 'Total: 0 entradas';
        Kind := skCount;
      finally
        EndUpdate;
      end;
    except
      DataController.Summary.FooterSummaryItems.Delete(DataController.Summary.FooterSummaryItems.Count-1);
    end;

    {Columna NUMENTRADA}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'NUMENTRADA';
    Columna.Caption := 'Nº entrada';
    Columna.Width := tamColNumEntrada;
    Columna.Options.Filtering := False;
    Columna.SortOrder := soDescending;

    {Columna TIPOENTRADA}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'TIPOENTRADA';
    Columna.Caption := 'Tipo';
    Columna.Width := tamColTipoEntrada;
    Columna.Options.Filtering := False;
    Columna.Visible := True;
    Columna.PropertiesClassName := 'TcxImageComboBoxProperties';
    with TcxImageComboBoxProperties(Columna.Properties) do
    begin
      DropDownRows := 2;
      Images := imgGridLibros;

      with TcxImageComboBoxItem(Items.Add) do
      begin
        ImageIndex := 0;
        Value := CTE_ENT;
        Description := 'Entrada';
      end;
      with TcxImageComboBoxItem(Items.Add) do
      begin
        ImageIndex := 1;
        Value := CTE_SAL;
        Description := 'Salida';
      end;
      with TcxImageComboBoxItem(Items.Add) do
      begin
        ImageIndex := 2;
        Value := CTE_CIERRE;
        Description := 'Cierre';
      end;
    end;

    {Columna DESCRIPCION}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'DESCRIPCION';
    Columna.Caption := 'Descripción';
    Columna.Width := tamColDescripcion;
    Columna.Options.Filtering := False;

    {Columna CUANTIA}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'CUANTIA';
    Columna.Caption := 'Cuantia';
    Columna.Width := tamColImporte;
    Columna.Options.Filtering := False;
    {with TcxGridDBTableSummaryItem(DataController.Summary.FooterSummaryItems.Add) do
    try
      try
        BeginUpdate;
        Column := Columna;
        FieldName := Columna.DataBinding.FieldName;
        Format := '#,0.00# €';
        Kind := skSum;
      finally
        EndUpdate;
      end;
    except
      DataController.Summary.FooterSummaryItems.Delete(DataController.Summary.FooterSummaryItems.Count-1);
    end;}

    {Columna IMPORTEANT}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'IMPORTEANT';
    Columna.Caption := 'Importe anterior';
    Columna.Width := tamColImporte;
    Columna.Options.Filtering := False;
    {with TcxGridDBTableSummaryItem(DataController.Summary.FooterSummaryItems.Add) do
    try
      try
        BeginUpdate;
        Column := Columna;
        FieldName := Columna.DataBinding.FieldName;
        Format := '#,0.00# €';
        Kind := skSum;
      finally
        EndUpdate;
      end;
    except
      DataController.Summary.FooterSummaryItems.Delete(DataController.Summary.FooterSummaryItems.Count-1);
    end;}

    {Columna IMPORTEPOS}
    Columna := CreateColumn;
    Columna.DataBinding.FieldName := 'IMPORTEPOS';
    Columna.Caption := 'Importe posterior';
    Columna.Width := tamColImporte;
    Columna.Options.Filtering := False;
    {with TcxGridDBTableSummaryItem(DataController.Summary.FooterSummaryItems.Add) do
    try
      try
        BeginUpdate;
        Column := Columna;
        FieldName := Columna.DataBinding.FieldName;
        Format := '#,0.00# €';
        Kind := skSum;
      finally
        EndUpdate;
      end;
    except
      DataController.Summary.FooterSummaryItems.Delete(DataController.Summary.FooterSummaryItems.Count-1);
    end;}

  end;
end;

procedure TdmTablaLibros.InicializarTablaDetallesLibro(Tabla: TPTabla);
begin
  with Tabla^.Fields do
  begin
    if FindField('CUANTIA') <> NIL then
      with (FieldByName('CUANTIA') as TIBBCDField) do begin
        DisplayFormat := DISPLAY_EUROS2;
        EditFormat := EDIT_EUROS2;
      end;
    if FindField('IMPORTEANT') <> NIL then
      with (FieldByName('IMPORTEANT') as TIBBCDField) do begin
        DisplayFormat := DISPLAY_EUROS2;
        EditFormat := EDIT_EUROS2;
      end;
    if FindField('IMPORTEPOS') <> NIL then
      with (FieldByName('IMPORTEPOS') as TIBBCDField) do begin
        DisplayFormat := DISPLAY_EUROS2;
        EditFormat := EDIT_EUROS2;
      end;
  end;
end;

function TdmTablaLibros.AnadirDetalleLibro(Datos: TDatosDetalleLibro): Boolean;
var
  oSQL : TIBSQL;
begin
  Result := False;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('insert into DETALLESLIBROS (CODIGOEMPRESA, TIPOLIBRO, NUMENTRADA, TIPOENTRADA, FECHAALTA, ');
    SQL.Add('USUARIO, FECHAENTRADA, DESCRIPCION, CUANTIA, IMPORTEANT, IMPORTEPOS) ');
    SQL.Add('VALUES (:CODIGOEMPRESA, :TIPOLIBRO, :NUMENTRADA, :TIPOENTRADA, :FECHAALTA, :USUARIO, :FECHAENTRADA, ');
    SQL.Add(':DESCRIPCION, :CUANTIA, :IMPORTEANT, :IMPORTEPOS)');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    ParamByName('TIPOLIBRO').AsString := Datos.TipoLibro;
    ParamByName('NUMENTRADA').AsString := Datos.NumEntrada;
    ParamByName('TIPOENTRADA').AsString := Datos.TipoEntrada;
    ParamByName('FECHAALTA').AsString := Datos.FechaAlta;
    ParamByName('USUARIO').AsString := Datos.Usuario;
    ParamByName('FECHAENTRADA').AsString := Datos.FechaEntrada;
    ParamByName('DESCRIPCION').AsString := Datos.Descripcion;
    ParamByName('CUANTIA').AsDouble := Datos.Cuantia;
    ParamByName('IMPORTEANT').AsDouble := Datos.ImporteAnt;
    ParamByName('IMPORTEPOS').AsDouble := Datos.ImportePos;

    Prepare;
    ExecQuery;
    Result := True;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.CerrarLibro(TipoLibro : String): Boolean;
var
  oSQL : TIBSQL;
begin
  Result := False;

  if esCadenaVacia(TipoLibro) then
    Exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('insert into DETALLESLIBROS (CODIGOEMPRESA, TIPOLIBRO, NUMENTRADA, TIPOENTRADA, FECHAALTA, ');
    SQL.Add('USUARIO, FECHAENTRADA, DESCRIPCION, CUANTIA, IMPORTEANT, IMPORTEPOS) ');
    SQL.Add('VALUES (:CODIGOEMPRESA, :TIPOLIBRO, :NUMENTRADA, :TIPOENTRADA, :FECHAALTA, :USUARIO, :FECHAENTRADA, ');
    SQL.Add(':DESCRIPCION, :CUANTIA, :IMPORTEANT, :IMPORTEPOS)');

  try
    ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
    ParamByName('TIPOLIBRO').AsString := TipoLibro;
    ParamByName('NUMENTRADA').AsString := darNumEntrada(TipoLibro);
    ParamByName('TIPOENTRADA').AsString := CTE_CIERRE;
    ParamByName('FECHAALTA').AsString := DateToStr(dmBaseDatos.darFecha);
    ParamByName('USUARIO').AsString := dmBaseDatos.Usuario;
    ParamByName('FECHAENTRADA').AsString := ParamByName('FECHAALTA').AsString;
    ParamByName('DESCRIPCION').AsString := msgLibCierre;
    ParamByName('CUANTIA').AsDouble := 0;
    ParamByName('IMPORTEANT').AsDouble := darUltimoImportePos(TipoLibro);
    ParamByName('IMPORTEPOS').AsDouble := darUltimoImportePos(TipoLibro);

    Prepare;
    ExecQuery;

    if incrementarNumEntrada(TipoLibro)
    then Result := True;
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.darNumEntrada(psTipoLibro: String): Variant;
begin
  if (psTipoLibro = 'C') then
    Result := dmTablaLibros.DarNuevoCodigoCaja
  else if (psTipoLibro = 'B') then
    Result := dmTablaLibros.DarNuevoCodigoBanco
  else begin
    VerMensaje('Log: Error el codigo de libro no existe');
    Result := Null;
  end;
end;

function TdmTablaLibros.incrementarNumEntrada(psTipoLibro: String): Boolean;
begin
    if (psTipoLibro = 'C') then dmTablaLibros.IncrementarCodigoCaja
    else if (psTipoLibro = 'B') then dmTablaLibros.IncrementarCodigoBanco
    else begin
      VerMensaje('Log: Error el codigo de libro no existe');
      Result := False;
    end;
    Result := True;
end;
{
function TdmTablaLibros.darDescripcionLibro(Codigo: String): String;
var
  oSQL : TIBSQL;

begin
  Result := '';

  if EsCadenaVacia(Codigo) then
    Exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select DESCRIPCION ');
    SQL.Add('from LIBROS ');
    SQL.Add('where CODIGO = :CODIGO');
    ParamByName('CODIGO').AsString := Codigo;
    try
      Prepare;
      ExecQuery;
      Result := Fields[0].AsString;
    finally
      Close;
      Transaction := NIL;
      Free;
    end;
  end;
end;
}
function TdmTablaLibros.anadirEntradaLibro(Entidad: TRdxEntidad;
  Modo: TRdxModo; Datos: TDatosPago): Boolean;

var
  lDatosDetalleLibro : TDatosDetalleLibro;
  lsAux : String;
  Importe : Double;
  lsNumEntrada : Variant;
  lsTipoEntrada : Variant;

begin
  Result := False;

  try
    //Detalle libro
    lDatosDetalleLibro := TDatosDetalleLibro.Create;
    //Descripcion
    lsAux := msgCliSep1;
    lsAux := lsAux + Datos.TipoPago;

    Importe := Datos.Importe;
    case Entidad of
      entPagoProveedor :  begin
                            lsAux := lsAux + msgCliSep9;
                            lsTipoEntrada := CTE_SAL;
                          end;
      entAbonoProveedor : begin
                            lsAux := lsAux + msgCliSep9;
                            lsTipoEntrada := CTE_ENT;
                          end;
      entCobroCliente :   begin
                            lsAux := lsAux + msgCliSep2;
                            lsTipoEntrada := CTE_ENT;
                          end;
      entAbonoCliente :   begin
                            lsAux := lsAux + msgCliSep2;
                            lsTipoEntrada := CTE_SAL;
                          end;
      else begin
        VerMensaje('Log: la entidad no se corresponde con ningun tipo de pago');
        lDatosDetalleLibro.Free;
        exit;
      end;
    end;

    lDatosDetalleLibro.TipoLibro := Datos.TipoLibro;
    lDatosDetalleLibro.NumEntrada := Datos.NumEntrada;
    //Cabecera
    lDatosDetalleLibro.FechaAlta := Datos.FechaAlta;
    lDatosDetalleLibro.Usuario := Datos.Usuario;
    lDatosDetalleLibro.FechaEntrada := Datos.FechaPago;
    //Descripcion
    lsAux := lsAux + Datos.Codigo;
    lsAux := lsAux + msgCliSep3;
    lsAux := lsAux + Datos.Nombre;
    lsAux := lsAux + msgCliSep4;
    lDatosDetalleLibro.Descripcion := lsAux + Datos.Descripcion;

    lDatosDetalleLibro.TipoEntrada := lsTipoEntrada;
    lDatosDetalleLibro.Cuantia := Importe;
    lDatosDetalleLibro.ImporteAnt := darUltimoImportePos(lDatosDetalleLibro.TipoLibro);
    lDatosDetalleLibro.ImportePos := lDatosDetalleLibro.ImporteAnt + Importe;

    if AnadirDetalleLibro(lDatosDetalleLibro) then begin
      if incrementarNumEntrada(lDatosDetalleLibro.TipoLibro)
      then Result := True;
    end;

  finally
    lDatosDetalleLibro.Free;
  end;
end;

function TdmTablaLibros.anularEntradaLibro(Entidad: TRdxEntidad;
  Modo: TRdxModo; Datos: TDatosPago): Boolean;

var
  lDatosDetalleLibro : TDatosDetalleLibro;
  lsAux : String;
  Importe : Double;
  lsNumEntrada : Variant;
  lsTipoEntrada : Variant;

begin
  Result := False;

  try
    //Detalle libro
    lDatosDetalleLibro := TDatosDetalleLibro.Create;
    lDatosDetalleLibro.TipoLibro := Datos.TipoLibro;
    lsNumEntrada := dmTablaLibros.darNumEntrada(lDatosDetalleLibro.TipoLibro);
    if (esCadenaVacia(lsNumEntrada)) then begin
      VerMensaje('Log: A fallado el NumEntrada ');
      lDatosDetalleLibro.Free;
      exit;
    end;

    lDatosDetalleLibro.NumEntrada := lsNumEntrada;
    //Cabecera
    lDatosDetalleLibro.FechaAlta := DateToStr(dmBaseDatos.darFecha);
    lDatosDetalleLibro.Usuario := dmBaseDatos.Usuario;
    lDatosDetalleLibro.FechaEntrada := lDatosDetalleLibro.FechaAlta;
    //Descripcion
    lsAux := msgCliSep5;
    lsAux := lsAux + Datos.NumEntrada;
    case Modo of
      Modificar : lsAux := lsAux + msgCliSep6;
      Eliminar : lsAux := lsAux + msgCliSep7;
      else begin
        VerMensaje('Log: el modo no se corresponde con ningun tipo de pago');
        lDatosDetalleLibro.Free;
        exit;
      end;
    end;
    lsAux := lsAux + Datos.TipoPago;
    lsAux := lsAux + msgCliSep8;
    lsAux := lsAux + Datos.Codigo;
    lsAux := lsAux + msgCliSep4;
    lsAux := lsAux + Datos.Descripcion;
    lDatosDetalleLibro.Descripcion := lsAux;

    Importe := (-1) * Datos.Importe;
    case Entidad of
      entPagoProveedor  : lsTipoEntrada := CTE_ENT;
      entAbonoProveedor : lsTipoEntrada := CTE_SAL;
      entCobroCliente   : lsTipoEntrada := CTE_SAL;
      entAbonoCliente   : lsTipoEntrada := CTE_ENT;
      else begin
        VerMensaje('Log: la entidad no se corresponde con ningun tipo de pago');
        lDatosDetalleLibro.Free;
        exit;
      end;
    end;

    lDatosDetalleLibro.TipoEntrada := lsTipoEntrada;
    lDatosDetalleLibro.Cuantia := Importe;
    lDatosDetalleLibro.ImporteAnt := dmTablaLibros.darUltimoImportePos(lDatosDetalleLibro.TipoLibro);
    lDatosDetalleLibro.ImportePos := lDatosDetalleLibro.ImporteAnt + Importe;

    if dmTablaLibros.AnadirDetalleLibro(lDatosDetalleLibro) then begin
      if dmTablaLibros.incrementarNumEntrada(lDatosDetalleLibro.TipoLibro)
      then Result := True;
    end;

  finally
    lDatosDetalleLibro.Free;
  end;
end;

function TdmTablaLibros.crearLibros(CodigoEmpresa: Variant): boolean;
begin
  Result := True;

  if not existenLibros(CodigoEmpresa) then
     Result := insertarLibros(CodigoEmpresa);
end;

function TdmTablaLibros.existenLibros(CodigoEmpresa: Variant): Boolean;
var
  oSQL : TIBSQL;
begin
  Result := False;

  if VarIsNull(CodigoEmpresa) then
     exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('select count(CODIGOEMPRESA) as NUMLIBROS');
    SQL.Add('from LIBROS');
    SQL.Add('where CODIGOEMPRESA = :CODIGOEMPRESA');
  try
    ParamByName('CODIGOEMPRESA').AsInteger := CodigoEmpresa;
    Prepare;
    ExecQuery;
    Result := (FieldByName('NUMLIBROS').AsInteger <> 0);
  finally
    Close;
    Transaction := NIL;
    Free;
  end;
  end;
end;

function TdmTablaLibros.insertarLibro(TipoLibro: TTiposLibro; CodigoEmpresa: Variant): Boolean;
var
  oSQL : TIBSQL;

begin
  Result := False;

  if VarIsNull(CodigoEmpresa) then
    exit;

  oSQL := TIBSQL.Create(Self);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Add('insert into LIBROS');
    SQL.Add('(CODIGOEMPRESA, TIPO, DESCRIPCION) ');
    SQL.Add('VALUES ');
    SQL.Add('(:CODIGOEMPRESA, :TIPO, :DESCRIPCION)');

    ParamByName('CODIGOEMPRESA').AsVariant := CodigoEmpresa;
    ParamByName('TIPO').AsString := darTipoLibro(TipoLibro);
    ParamByName('DESCRIPCION').AsString := darDescripcionLibro(TipoLibro);
    try
      Prepare;
      ExecQuery;
      Result := True;
    finally
      Close;
      Transaction := NIL;
      Free;
    end;
  end;
end;

function TdmTablaLibros.insertarLibros(CodigoEmpresa: Variant): Boolean;
begin
  Result := False;

  if not insertarLibro(ttlCaja, CodigoEmpresa) then begin
    exit;
  end;

  if not insertarLibro(ttlBanco, CodigoEmpresa) then begin
    exit;
  end;

  Result := True;
end;

function TdmTablaLibros.darDescripcionLibro(TipoLibro: TTiposLibro): String;
begin
  Result := StrCapitalize(CaptionsDescripcionLibro [TipoLibro]);
end;

function TdmTablaLibros.darTipoLibro(TipoLibro: TTiposLibro): String;
begin
  Result := StrCapitalize(CaptionsTiposLibro [TipoLibro]);
end;

{ TListaLibros }

procedure TListaLibros.AssignTo(Dest: TPersistent);
begin
//
end;

function TListaLibros.cargarLista(Objcbx: TcxComboBox): Integer;
//Carga todos los libros en el combox y devuelve el elemento determinado por defecto
var i, j : integer;
begin
  Result := 0;
  //Recorremos lista
  j := -1;
  for i := 0 to FLista.Count - 1 do
  begin
    Objcbx.Properties.Items.Add(Self.Items[i].Nombre);
    j := j + 1;

    if Self.Items[i].Predeterminado then
       Result := j;
  end;
end;

constructor TListaLibros.Create(TipoLista: TListaComboTiposLibro);
begin
  inherited Create;
  FSQL := TStringList.Create;

  case (TipoLista) of
  tltDefecto: ObtenerLista;
  tltTodos:   begin
               inicializarSQL(TipoLista);
               ObtenerListaBD;
              end;
  end;
end;

destructor TListaLibros.Destroy;
begin
  FSQL.Free;
  FSQL := nil;
  inherited Destroy;
end;

function TListaLibros.GetDatosLibro(Index: Integer): TDatosLibro;
begin
  Result := TDatosLibro(FLista.Items[Index]);
end;

procedure TListaLibros.inicializarSQL(TipoLista: TListaComboTiposLibro);
begin
  case (TipoLista) of
  tltTodos: begin
        with FSQL do
        begin
          Add('select LI.CODIGOEMPRESA, LI.TIPO, LI.DESCRIPCION, EM.LIBRODEFECTO');
          Add('from LIBROS LI, EMPRESAS EM');
          Add('where LI.CODIGOEMPRESA = :CODIGOEMPRESA');
          Add('and EM.CODIGO = LI.CODIGOEMPRESA');
        end;
     end;
  end;
end;

procedure TListaLibros.ObtenerLista;
var
  FLibro : TDatosLibro;
begin
  FLibro := TDatosLibro.Create();
  FLibro.Codigo := dmTablaLibros.darTipoLibro(ttlCaja);
  FLibro.Nombre := dmTablaLibros.darDescripcionLibro(ttlCaja);
  FLista.Add(FLibro);

  FLibro := TDatosLibro.Create();
  FLibro.Codigo := dmTablaLibros.darTipoLibro(ttlBanco);
  FLibro.Nombre := dmTablaLibros.darDescripcionLibro(ttlBanco);
  FLista.Add(FLibro);
end;

procedure TListaLibros.ObtenerListaBD;
var
  oSQL : TIBSQL;
  FLibro : TDatosLibro;
begin
  oSQL := TIBSQL.Create(nil);
  with oSQL do
  begin
    Database := dmBaseDatos.BD;
    Transaction := dmBaseDatos.Transaccion;
    SQL.Text := FSQL.Text;
    try
      ParamByName('CODIGOEMPRESA').AsInteger := EmpresaActiva.Codigo;
      Prepare;
      ExecQuery;
      while not EOF do begin
        FLibro := TDatosLibro.Create();
        FLibro.Codigo := FieldByName('TIPO').AsString;
        FLibro.Nombre := FieldByName('DESCRIPCION').AsString;
        FLibro.Predeterminado := (FieldByName('LIBRODEFECTO').AsString = FLibro.Codigo);
        FLista.Add(FLibro);
        Next;
      end;
    finally
      Close;
      Transaction := NIL;
      Free;
    end;
  end;
end;

end.