//---------------------------------------------------------------------------
#include <vcl.h>
#include <string.h>
#include "Esergui.h"
#include "stdlib.h"
#include "stdio.h"
#include <alloc.h>
#pragma hdrstop
//---------------------------------------------------------------------------
// class TAutorizacion
// {
//  protected:
//  private:	// Declaraciones
//        DatosAutorizacion sDatos;
//        bool ComprobarCaducidad(dbiTabla Tabla,char *Campo);
//        unsigned int IndRegORC;
//  public:  	//Declaracion de funciones Locales
//        TAutorizacion(void);
//        void CapturarFechaGen(char *pszFechaActual);
//        int ComprobarEstado(char *Estado,char *Valor,char *Campo,hDBIDb hBaseDatos);
//        int ComprobarConductor(char *pszCodConductor,hDBIDb hBaseDatos);
//        int ComprobarCisterna(char *pszCodCisterna,hDBIDb hBaseDatos);
//        int ComprobarTractor(char *pszMatriculaTra,char *pszInternoTra,hDBIDb hBaseDatos);
//        int ComprobarSuministrador(char *pszCodSum,hDBIDb hBaseDatos);
//        int ComprobarPedidos(char *pszCodPed,hDBIDb hBaseDatos);
//        int CalcularPesoVolCarga(hDBIDb hBaseDatos);
//        int ComprobarPesoCarga(hDBIDb hBaseDatos);
//        int ComprobarDistribucionCarga(void);
//        bool Cabe_Cis (void);
//        bool Capacidad_Ok(int n_Prod,int *psnCapacidad_Prod,int *psnCantidad_Prod);
//        void ActualizaEstado(char *pszEstado,bool bActualizaOrden,hDBIDb hBaseDatos);
//        void BuscarNumeroViaje(hDBIDb hBaseDatos);
//        void RellenarSIMICCAR(dbiTabla TCAR);
//        void ReservarMemoriaEstructura(hDBIDb hBaseDatos);
//        void LiberarEstructura(void);
//        void LeerEstructura(DatosAutorizacion *psDat);
//        void InicializaEstructura(void);
// };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Constructor de la clase Autorizacion
//---------------------------------------------------------------------------
TAutorizacion::TAutorizacion(void)
{
}

//---------------------------------------------------------------------------
// bool ComprobarCaducidad(dbiTabla Tabla,char *pszCampo);
//
// Entrada:
//              Tabla: Tabla con la que se va a trabajar
//              Campo: Campo de la tabla a comprobar
//
// Salida:
//              true: No ha caducado
//              false: Si ha caducado
//
// Descripcion: Comprueba si el carnet de conducir esta caducado
//---------------------------------------------------------------------------
bool TAutorizacion::ComprobarCaducidad(dbiTabla Tabla,char *pszCampo)
{
    bool bCorrecto;
    char szFecha[TAM_FECHA];
    char szFechaCampo[TAM_FECHA];
    //Obtenemos la fecha actual
    CapturarFechaGen(szFecha);
    //Leemos la fecha de caducidad del carnet
    LeerCampoNBDE(&Tabla,pszCampo,szFechaCampo,NULL);
    //Comprobamos si el carnet caduco
    if((strcmp(szFechaCampo,szFecha))>0)
        bCorrecto=true;
    else
        bCorrecto=false;
    //Devolvemos el resultado
    return bCorrecto;
}

//---------------------------------------------------------------------------
// int ComprobarConductor(char *pszCodConductor,hDBIDb hBaseDatos)
//
// Entrada:
//              CodConductor: codigo NMT del conductor
//              hBaseDatos: Base de Datos a emplear
//
// Salida:
//              Error si lo hubo sino un cero
//
// Descripcion: Comprueba si esta borrada la Tabla SIMICCON,
//              si caduco el carnet de conducir y
//              si caduco el ADR
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarConductor(char *pszCodConductor,hDBIDb hBaseDatos)
{
    bool bCorrecto;
    int nValorDevuelto;
    dbiTabla TConductor;

    //Inicializamos variable de devolucion
    nValorDevuelto=AUT_CON_CORRECTO;

    //Abrimos la la tabla de conductor
    if(!AbrirTablaBDE(&TConductor,"SIMICCON","CONNTMCON",false,hBaseDatos))
    {
        //Busca cadena de entrada
        if(!BuscarValorExactoBDE(&TConductor,pszCodConductor,NULL))
        {
            //Vemos si esta marcado como borrado
            if(!EstaRegBorBDE (&TConductor,&bCorrecto))
            {
                sDatos.bBorradoCon=bCorrecto;
                if(!bCorrecto)
                {
                    //Almacenamos variables
                    LeerCampoNBDE(&TConductor,"CONNTMCON",sDatos.pszCodigoCon,NULL);
                    LeerCampoNBDE(&TConductor,"CONCCACON",sDatos.pszCadCarnetCon,NULL);
                    LeerCampoNBDE(&TConductor,"CONCADCON",sDatos.pszCadADRCon,NULL);
                    LeerCampoNBDE(&TConductor,"CONNOMCON",sDatos.pszNombreCon,NULL);
                    LeerCampoNBDE(&TConductor,"CONNCACON",sDatos.pszCarnetCon,NULL);
                    LeerCampoNBDE(&TConductor,"CONINTCON",sDatos.pszInternoCon,NULL);

                    //Comprobamos si el carnet esta caducado
                    bCorrecto=ComprobarCaducidad(TConductor,"CONCCACON");
                    if(bCorrecto)
                    {
                        //Comprobamos si el ADR esta caducado
                        bCorrecto=ComprobarCaducidad(TConductor,"CONCADCON");
                        if(!bCorrecto)
                            nValorDevuelto=AUT_CON_ADR_CADUCADO;
                    }
                    else
                        nValorDevuelto=AUT_CON_CARNET_CADUCADO;
                }
                else
                    nValorDevuelto=AUT_CON_BORRADO;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=AUT_CON_VALOR_NO_ENCONTRADO;
    }
    else
        nValorDevuelto=ERROR_BDE;

    if(CerrarTablaBDE(&TConductor) && nValorDevuelto==AUT_CON_CORRECTO)
            nValorDevuelto=ERROR_BDE;
    //Guardamos el valor del resultado
    sDatos.nResultadoCon=nValorDevuelto;
    //Devolvemos el resultado
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int ComprobarCisterna(char *pszCodCisterna,hDBIDb hBaseDatos)
//
// Entrada:
//              CodCisterna: codigo NMT de la cisterna
//              hBaseDatos: Base de Datos a emplear
//
// Salida:
//              Error si lo hubo sino un cero
//
// Descripcion: Comprueba si esta borrada la Tabla SIMICCIS,
//              Comprueba si la tarjeta de transporte esta caducada
//              Comprueba si el ADR esta caducado
//              Comprueba si la ITV esta caducada
//              Comprueba si el Seguro esta caducado
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarCisterna(char *pszCodCisterna,hDBIDb hBaseDatos)
{
    bool bCorrecto;
    int nValorDevuelto;
    dbiTabla TCisterna,TTRP;

    //Inicializamos variable de devolucion
    nValorDevuelto=AUT_CIS_CORRECTO;

    //Abrimos la la tabla de Cisterna
    if(!AbrirTablaBDE(&TCisterna,"SIMICCIS","CISNTMCIS",false,hBaseDatos))
    {
        //Busca cadena de entrada
        if(!BuscarValorExactoBDE(&TCisterna,pszCodCisterna,NULL))
        {
            //Vemos si esta marcado como borrado
            if(!EstaRegBorBDE(&TCisterna,&bCorrecto))
            {
                sDatos.bBorradoCis=bCorrecto;
                if(!bCorrecto)
                {
                    //Almacenamos variables
                    LeerCampoNBDE(&TCisterna,"CISNTMCIS",sDatos.pszCodigoCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCTRCIS",sDatos.pszCTRCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCODTRP",sDatos.pszCodTransCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISNOMTRP",sDatos.pszNombreTransCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCTTCIS",sDatos.pszCadTarjetaCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCADCIS",sDatos.pszCadADRCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCITCIS",sDatos.pszCadITVCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCASCIS",sDatos.pszCadSeguroCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISINTCIS",sDatos.pszInternoCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISTARCIS",sDatos.pszTaraCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISBRUCIS",sDatos.pszBrutoCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISCAMCIS",sDatos.pszCamionCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISMATCIS",sDatos.pszMatriculaCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISMATTRA",sDatos.pszMatriculaTraCis,NULL);
                    LeerCampoNBDE(&TCisterna,"CISEJECIS",sDatos.pszNumeroEjesCis,NULL);
                    LeerArrayCampoBDE(&TCisterna,"CISVOLCIS",sDatos.pszsVolumenCis,NUM_MAXIMO_COMPARTIMENTO);

                    //Comprobamos si la Tarjeta Transporte esta caducada
                    bCorrecto=ComprobarCaducidad(TCisterna,"CISCTTCIS");
                    if(bCorrecto)
                    {
                        //Comprobamos el ADR
                        bCorrecto=ComprobarCaducidad(TCisterna,"CISCADCIS");
                        if(bCorrecto)
                        {
                            //Comprobamos la ITV
                            bCorrecto=ComprobarCaducidad(TCisterna,"CISCITCIS");
                            if(bCorrecto)
                            {
                                //Comprobamos el Seguro
                                bCorrecto=ComprobarCaducidad(TCisterna,"CISCASCIS");
                                if(!bCorrecto)
                                    nValorDevuelto=AUT_CIS_SEGURO_CADUCADO;
                                else
                                {
                                    //Abrimos la tabla de transportista
                                    if(!AbrirTablaBDE(&TTRP,"SIMICTRP","TRPCODTRP",false,hBaseDatos))
                                    {
                                        //Busca cadena de entrada
                                        if(!BuscarValorExactoBDE(&TTRP,sDatos.pszCodTransCis,NULL))
                                        {
                                            LeerCampoNBDE(&TTRP,"TRPCIFTRP",sDatos.pszCIFTRP,NULL);
                                        }
                                        else
                                            nValorDevuelto=AUT_CIF_TRP_NO_ECONTRADO;
                                    }
                                    else
                                        nValorDevuelto=ERROR_BDE;

                                    //Cerramos la tabla
                                    if(CerrarTablaBDE(&TTRP) && nValorDevuelto==AUT_CIS_CORRECTO)
                                          nValorDevuelto=ERROR_BDE;
                                }
                            }
                            else
                                nValorDevuelto=AUT_CIS_ITV_CADUCADO;
                        }
                        else
                            nValorDevuelto=AUT_CIS_ADR_CADUCADO;
                    }
                    else
                        nValorDevuelto=AUT_CIS_TARJETA_CADUCADA;
                }
                else
                    nValorDevuelto=AUT_CIS_BORRADO;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=AUT_CIS_VALOR_NO_ENCONTRADO;
    }
    else
        nValorDevuelto=ERROR_BDE;

    if(CerrarTablaBDE(&TCisterna) && nValorDevuelto==AUT_CIS_CORRECTO)
          nValorDevuelto=ERROR_BDE;
    //Guardamos el valor del resultado
    sDatos.nResultadoCis=nValorDevuelto;
    //Devolvemos el resultado
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int ComprobarTractor(char *pszMatriculaTra,char *pszInternoTra,hDBIDb hBaseDatos)
//
// Entrada:
//              pszMatriculaTra: Matricula del Tractor
//              pszInternoTra: Codigo interno del Tractor
//              hBaseDatos: Base de Datos a emplear
//
// Salida:
//              Error si lo hubo sino un cero
//
// Descripcion: Comprueba si esta borrada la Tabla SIMICCON,
//              si caduco el carnet de conducir y
//              si caduco el ADR
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarTractor(char *pszMatriculaTra,char *pszInternoTra,hDBIDb hBaseDatos)
{
    bool bCorrecto;
    int nValorDevuelto;
    dbiTabla TTractor;
    char *pszIndiceDeBusqueda;
    char sCampo[9];

    //Inicializamos variable de devolucion
    nValorDevuelto=AUT_TRA_CORRECTO;

    if(pszMatriculaTra==NULL)
    {
        strcpy(sCampo,"TRAINTTRA");
        pszIndiceDeBusqueda = (char *) malloc ( StrLen(pszInternoTra) );
        strcpy(pszIndiceDeBusqueda,pszInternoTra);
    }
    else
    {
        strcpy(sCampo,"TRAMATTRA");
        pszIndiceDeBusqueda = (char *) malloc ( StrLen(pszMatriculaTra) );
        strcpy(pszIndiceDeBusqueda,pszMatriculaTra);
    }

    //Abrimos la la tabla de Tractor
    if(!AbrirTablaBDE(&TTractor,"SIMICTRA",sCampo,false,hBaseDatos))
    {
        //Busca cadena de entrada
        if(!BuscarValorExactoBDE(&TTractor,pszIndiceDeBusqueda,NULL))
        {
            //Vemos si esta marcador como borrado
            if(!EstaRegBorBDE(&TTractor,&bCorrecto))
            {
                sDatos.bBorradoTra=bCorrecto;
                if(!bCorrecto)
                {
                    //Almacenamos variables
                    LeerCampoNBDE(&TTractor,"TRAINTTRA",sDatos.pszInternoTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRAMATTRA",sDatos.pszMatriculaTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRACTTTRA",sDatos.pszCadTarjetaTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRACADTRA",sDatos.pszCadADRTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRACITTRA",sDatos.pszCadITVTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRACASTRA",sDatos.pszCadSeguroTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRATARTRA",sDatos.pszTaraTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRABRUTRA",sDatos.pszBrutoTra,NULL);
                    LeerCampoNBDE(&TTractor,"TRAEJETRA",sDatos.pszNumeroEjesTra,NULL);
                    //Comprobamos si la Tarjeta Transporte esta caducada
                    bCorrecto=ComprobarCaducidad(TTractor,"TRACTTTRA");
                    if(bCorrecto)
                    {
                        //Comprobamos el ADR
                        bCorrecto=ComprobarCaducidad(TTractor,"TRACADTRA");
                        if(bCorrecto)
                        {
                            //Comprobamos la ITV
                            bCorrecto=ComprobarCaducidad(TTractor,"TRACITTRA");
                            if(bCorrecto)
                            {
                                //Comprobamos el Seguro
                                bCorrecto=ComprobarCaducidad(TTractor,"TRACASTRA");
                                if(!bCorrecto)
                                    nValorDevuelto=AUT_TRA_SEGURO_CADUCADO;
                            }
                            else
                                nValorDevuelto=AUT_TRA_ITV_CADUCADO;
                        }
                        else
                            nValorDevuelto=AUT_TRA_ADR_CADUCADO;
                    }
                    else
                        nValorDevuelto=AUT_TRA_TARJETA_CADUCADA;
                }
                else
                    nValorDevuelto=AUT_TRA_BORRADO;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=AUT_TRA_VALOR_NO_ENCONTRADO;
    }
    else
        nValorDevuelto=ERROR_BDE;

    if(CerrarTablaBDE(&TTractor) && nValorDevuelto==AUT_TRA_CORRECTO)
             nValorDevuelto=ERROR_BDE;
    //Liberamos memoria
    free(pszIndiceDeBusqueda);
    //Guardamos el valor del resultado
    sDatos.nResultadoTra=nValorDevuelto;
    //Devolvemos el resultado
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int ComprobarSuministrador(char *pszCodSum,hDBIDb hBaseDatos)
//
// Entrada:
//              CodSum: codigo del Suministrador
//              hBaseDatos: Base de Datos a emplear
//
// Salida:
//              Error si lo hubo sino un cero
//
// Descripcion: Comprueba si esta borrada la Tabla SIMICSUM,
//              si esta marcada como borrado
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarSuministrador(char *pszCodSum,hDBIDb hBaseDatos)
{
    bool bCorrecto;
    int nValorDevuelto;
    dbiTabla TSuministrador;

    //Inicializamos variable de devolucion
    nValorDevuelto=AUT_SUM_CORRECTO;

    //Abrimos la la tabla Suministrador
    if(!AbrirTablaBDE(&TSuministrador,"SIMICSUM","SUMCODSUM",false,hBaseDatos))
    {
        //Busca cadena de entrada
        if(!BuscarValorExactoBDE(&TSuministrador,pszCodSum,NULL))
        {
            //Vemos si esta marcador como borrado
            if(!EstaRegBorBDE(&TSuministrador,&bCorrecto))
            {
                sDatos.bBorradoSum=bCorrecto;
                if(!bCorrecto)
                {
                    //Asignamos valores
                    LeerCampoNBDE(&TSuministrador,"SUMCODSUM",sDatos.pszCodigoSum,NULL);
                    LeerCampoNBDE(&TSuministrador,"SUMNOMSUM",sDatos.pszNombreSum,NULL);
                    nValorDevuelto=AUT_SUM_CORRECTO;
                }
                else
                nValorDevuelto=AUT_SUM_BORRADO;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=AUT_SUM_VALOR_NO_ENCONTRADO;
    }
    else
        nValorDevuelto=ERROR_BDE;

    if(CerrarTablaBDE(&TSuministrador) && nValorDevuelto==AUT_SUM_CORRECTO)
        nValorDevuelto=ERROR_BDE;

    //Guardamos el valor del resultado
    sDatos.nResultadoSum=nValorDevuelto;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int ComprobarEstado(char *pszEstado,char *pszValor,char *pszCampo,hDBIDb hBaseDatos)
//
// Entrada:
//              Estado: Estado en el que se encuentra
//              Valor: Valor a buscar
//              Campo: Campo de busqueda
//              hBaseDatos: Base de Datos a emplear
//
// Salida:
//              Error si lo hubo sino un cero
//
// Descripcion: Comprueba el valor del estado
//
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarEstado(hDBIDb hBaseDatos)
{
    int nValorDevuelto;
    dbiTabla TCAR;
    DBIResult Error;
    int nNumReg;
    char *pszCARINTCIS;
    char *pszCARINTCON;
    char *pszCARINTTRA;
    bool bEncontrado;
    bool bBorrado;

    //Inicilizamos las variables
    nValorDevuelto=AUT_EST_CORRECTO;

    //Abrimos la tabla SIMICCAR para saber el Estado del proceso
    Error=AbrirTablaBDE(&TCAR,"SIMICCAR",NULL,true,hBaseDatos);
    if(!Error)
    {
        //Pedimos memoria para la variable temporal
        pszCARINTCIS=ReservarMemoria(&TCAR,"CARINTCIS");
        pszCARINTCON=ReservarMemoria(&TCAR,"CARINTCON");
        pszCARINTTRA=ReservarMemoria(&TCAR,"CARINTTRA");
        //Nos situamos al principio
        ContarRegBDE(&TCAR,&nNumReg);
        if(nNumReg)
        {
            //comprobamos hasta el final o encontrado
            bEncontrado=false;
            while(Error==BDE_SIN_ERROR && bEncontrado==false)
            {
                //Leemos los campos
                LeerCampoNBDE(&TCAR,"CARINTCIS",pszCARINTCIS,NULL);
                LeerCampoNBDE(&TCAR,"CARINTCON",pszCARINTCON,NULL);
                LeerCampoNBDE(&TCAR,"CARINTTRA",pszCARINTTRA,NULL);
                //Comprobamos los campos
                if(strcmp(sDatos.pszInternoCis,pszCARINTCIS))
                {
                    if(strcmp(sDatos.pszInternoCon,pszCARINTCON))
                    {
                        if(strcmp(sDatos.pszInternoTra,pszCARINTTRA))
                            bEncontrado=false;
                        else
                        {
                            bEncontrado=true;
                            nValorDevuelto=AUT_EST_TRA_YA_DENTRO;
                        }
                    }
                    else
                    {
                        bEncontrado=true;
                        nValorDevuelto=AUT_EST_CON_YA_DENTRO;
                    }
                }
                else
                {
                    bEncontrado=true;
                    nValorDevuelto=AUT_EST_CIS_YA_DENTRO;
                }

                nValorDevuelto=5;
                //Vamos al siguiente registro
                Error=IrSiguienteRegBDE(&TCAR,&bBorrado);
            }

            if(bEncontrado==false && Error==BDE_FIN_FICHERO)//fin de registro
                nValorDevuelto=AUT_EST_CORRECTO;
        }

        //Liberamos la memoria pedida
        LiberarMemoria(pszCARINTCIS);
        LiberarMemoria(pszCARINTCON);
        LiberarMemoria(pszCARINTTRA);
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Si no ha habido Errores rellenamos la tabla simiccar
    if(nValorDevuelto==AUT_EST_CORRECTO)
        RellenarSIMICCAR(TCAR);

    //Cerramos la tabla SIMICCAR
    if(CerrarTablaBDE(&TCAR))
        nValorDevuelto=ERROR_BDE;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// void ReservarMemoriaEstructura(hDBIDb hBaseDatos)
//
// Entrada:
//              hDBIDb hBaseDatos: Cabecera de la Base de datos
//
// Descripcion: Reserva Memoria para la Estructura de Autorizacion
//
//---------------------------------------------------------------------------
void TAutorizacion::ReservarMemoriaEstructura(hDBIDb hBaseDatos)
{
    BYTE byi,byj;
    char *pszCadena;
    dbiTabla TConductor;
    dbiTabla TCisterna;
    dbiTabla TTractor;
    dbiTabla TSuministrador;
    dbiTabla TOrden;
    dbiTabla TLinea;
    dbiTabla TTRP;

    //Reservamos memoria para el conductor
    AbrirTablaBDE(&TConductor,"SIMICCON","CONNTMCON",false,hBaseDatos);
    sDatos.pszCadCarnetCon=ReservarMemoria(&TConductor,"CONCCACON");
    sDatos.pszCadADRCon=ReservarMemoria(&TConductor,"CONCADCON");
    sDatos.pszNombreCon=ReservarMemoria(&TConductor,"CONNOMCON");
    sDatos.pszCarnetCon=ReservarMemoria(&TConductor,"CONNCACON");
    sDatos.pszInternoCon=ReservarMemoria(&TConductor,"CONINTCON");
    sDatos.pszCodigoCon=ReservarMemoria(&TConductor,"CONNTMCON");
    CerrarTablaBDE(&TConductor);

    //Reservamos memoria para la cisterna
    AbrirTablaBDE(&TCisterna,"SIMICCIS","CISNTMCIS",false,hBaseDatos);
    sDatos.pszCodTransCis=ReservarMemoria(&TCisterna,"CISCODTRP");
    sDatos.pszCTRCis=ReservarMemoria(&TCisterna,"CISCTRCIS");
    sDatos.pszNombreTransCis=ReservarMemoria(&TCisterna,"CISNOMTRP");
    sDatos.pszCadTarjetaCis=ReservarMemoria(&TCisterna,"CISCTTCIS");
    sDatos.pszCadADRCis=ReservarMemoria(&TCisterna,"CISCADCIS");
    sDatos.pszCadITVCis=ReservarMemoria(&TCisterna,"CISCITCIS");
    sDatos.pszCadSeguroCis=ReservarMemoria(&TCisterna,"CISCASCIS");
    sDatos.pszInternoCis=ReservarMemoria(&TCisterna,"CISINTCIS");
    sDatos.pszTaraCis=ReservarMemoria(&TCisterna,"CISTARCIS");
    sDatos.pszBrutoCis=ReservarMemoria(&TCisterna,"CISBRUCIS");
    sDatos.pszCamionCis=ReservarMemoria(&TCisterna,"CISCAMCIS");
    sDatos.pszMatriculaCis=ReservarMemoria(&TCisterna,"CISMATCIS");
    sDatos.pszMatriculaTraCis=ReservarMemoria(&TCisterna,"CISMATTRA");
    sDatos.pszCodigoCis=ReservarMemoria(&TCisterna,"CISNTMCIS");
    sDatos.pszNumeroEjesCis=ReservarMemoria(&TCisterna,"CISEJECIS");
    pszCadena=(char *)malloc(strlen("CISVOLCIS")+2);
    for(byi=1;byi<(NUM_MAXIMO_COMPARTIMENTO+1);byi++)
    {
        strcpy(pszCadena,"CISVOLCIS");
        itoa(byi,pszCadena+strlen(pszCadena),10);
        sDatos.pszsVolumenCis[byi-1]=ReservarMemoria(&TCisterna,pszCadena);
    }
    free(pszCadena);

    CerrarTablaBDE(&TCisterna);

    //Reservamos memoria para el Tractor
    AbrirTablaBDE(&TTractor,"SIMICTRA","TRAMATTRA",false,hBaseDatos);
    sDatos.pszCadTarjetaTra=ReservarMemoria(&TTractor,"TRACTTTRA");
    sDatos.pszCadADRTra=ReservarMemoria(&TTractor,"TRACADTRA");
    sDatos.pszCadITVTra=ReservarMemoria(&TTractor,"TRACITTRA");
    sDatos.pszCadSeguroTra=ReservarMemoria(&TTractor,"TRACASTRA");
    sDatos.pszInternoTra=ReservarMemoria(&TTractor,"TRAINTTRA");
    sDatos.pszTaraTra=ReservarMemoria(&TTractor,"TRATARTRA");
    sDatos.pszBrutoTra=ReservarMemoria(&TTractor,"TRABRUTRA");
    sDatos.pszMatriculaTra=ReservarMemoria(&TTractor,"TRAMATTRA");
    sDatos.pszNumeroEjesTra=ReservarMemoria(&TTractor,"TRAEJETRA");
    CerrarTablaBDE(&TTractor);

    //Reservamos memoria para el Suministrador
    AbrirTablaBDE(&TSuministrador,"SIMICSUM","SUMCODSUM",false,hBaseDatos);
    sDatos.pszCodigoSum=ReservarMemoria(&TSuministrador,"SUMCODSUM");
    sDatos.pszNombreSum=ReservarMemoria(&TSuministrador,"SUMNOMSUM");
    CerrarTablaBDE(&TSuministrador);

    //Reservamos memoria para el Tranportista
    AbrirTablaBDE(&TTRP,"SIMICTRP","TRPCODTRP",false,hBaseDatos);
    sDatos.pszCIFTRP=ReservarMemoria(&TTRP,"TRPCIFTRP");
    CerrarTablaBDE(&TTRP);

    //Reservamos memoria para el Pedido
    AbrirTablaBDE(&TOrden,"SIMICORC","ORCMATCIS",false,hBaseDatos);

    //Reservamos memoria para el numero de ordenes
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
    {
        sDatos.sOrden[byi].pszPedidoOrd=ReservarMemoria(&TOrden,"ORCPEDORC");
        sDatos.sOrden[byi].pszNombreDesOrd=ReservarMemoria(&TOrden,"ORCNOMDES");
        sDatos.sOrden[byi].pszMatriculaCisOrd=ReservarMemoria(&TOrden,"ORCMATCIS");
        sDatos.sOrden[byi].pszCodigoSumOrd=ReservarMemoria(&TOrden,"ORCCODSUM");
        sDatos.sOrden[byi].pszNumeroOrd=ReservarMemoria(&TOrden,"ORCNUMORC");
        sDatos.sOrden[byi].pszCodigoCliOrd=ReservarMemoria(&TOrden,"ORCCODCLI");
        sDatos.sOrden[byi].pszCodigoCliDesOrd=ReservarMemoria(&TOrden,"ORCCCLDES");
        sDatos.sOrden[byi].pszUnidadOrd=ReservarMemoria(&TOrden,"ORCUNIPRO");
        sDatos.sOrden[byi].pszFechaEntOrd=ReservarMemoria(&TOrden,"ORCENTORC");
        sDatos.sOrden[byi].pszFechaCargaOrd=ReservarMemoria(&TOrden,"ORCFCAORC");
    }
    CerrarTablaBDE(&TOrden);

    //Pedimos memoria para las densidades
    AbrirTablaBDE(&TLinea,"SIMICPRO","PROCODPRO",false,hBaseDatos);
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
    {
        for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
        {
            sDatos.sOrden[byi].sLinea[byj].pszInternoPro=ReservarMemoria(&TLinea,"PROINTPRO");
            sDatos.sOrden[byi].sLinea[byj].pszDensidadPro=ReservarMemoria(&TLinea,"PROD15TAN");
            sDatos.sOrden[byi].sLinea[byj].pszPorcentajeMaxPro=ReservarMemoria(&TLinea,"PROMAXPRO");
        }
    }
    CerrarTablaBDE(&TLinea);

    //Pedimos memoria para las lineas
    AbrirTablaBDE(&TLinea,"SIMICORL","ORLNUMORC",false,hBaseDatos);
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
    {
        for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
        {
            sDatos.sOrden[byi].sLinea[byj].pszNombrePro=ReservarMemoria(&TLinea,"ORLNOMPRO");
            sDatos.sOrden[byi].sLinea[byj].pszCodigoPro=ReservarMemoria(&TLinea,"ORLCODPRO");
            sDatos.sOrden[byi].sLinea[byj].pszImpuestoPro=ReservarMemoria(&TLinea,"ORLTIMORL");
            sDatos.sOrden[byi].sLinea[byj].pszCantidadPro=ReservarMemoria(&TLinea,"ORLCANORL");
            sDatos.sOrden[byi].sLinea[byj].pszCodAdiPro=ReservarMemoria(&TLinea,"ORLCODADI");
        }
    }
    CerrarTablaBDE(&TLinea);

    //Inicializamos el resto de las variables
    InicializaEstructura();
}

//---------------------------------------------------------------------------
// void LiberarEstructura(void)
//
// Descripcion: Liberamos la Memoria Reservada  para la Estructura de Autorizacion
//
//---------------------------------------------------------------------------
void TAutorizacion::LiberarEstructura(void)
{
    BYTE byi,byj;

    //Liberamos variables del conductor
    LiberarMemoria(sDatos.pszCadCarnetCon);
    LiberarMemoria(sDatos.pszCadADRCon);
    LiberarMemoria(sDatos.pszNombreCon);
    LiberarMemoria(sDatos.pszCarnetCon);
    LiberarMemoria(sDatos.pszInternoCon);

    //Liberamos variables de la cisterna
    LiberarMemoria(sDatos.pszCodTransCis);
    LiberarMemoria(sDatos.pszCTRCis);
    LiberarMemoria(sDatos.pszNombreTransCis);
    LiberarMemoria(sDatos.pszCadTarjetaCis);
    LiberarMemoria(sDatos.pszCadADRCis);
    LiberarMemoria(sDatos.pszCadITVCis);
    LiberarMemoria(sDatos.pszCadSeguroCis);
    LiberarMemoria(sDatos.pszInternoCis);
    LiberarMemoria(sDatos.pszTaraCis);
    LiberarMemoria(sDatos.pszCadITVCis);
    LiberarMemoria(sDatos.pszBrutoCis);
    LiberarMemoria(sDatos.pszCamionCis);
    LiberarMemoria(sDatos.pszMatriculaCis);
    LiberarMemoria(sDatos.pszMatriculaTraCis);
    LiberarMemoria(sDatos.pszCodigoCis);
    LiberarMemoria(sDatos.pszNumeroEjesCis);
    for(byi=0;byi<NUM_MAXIMO_COMPARTIMENTO;byi++)
        LiberarMemoria(sDatos.pszsVolumenCis[byi]);

    //Liberamos variables de Tractor
    LiberarMemoria(sDatos.pszCadTarjetaTra);
    LiberarMemoria(sDatos.pszCadADRTra);
    LiberarMemoria(sDatos.pszCadITVTra);
    LiberarMemoria(sDatos.pszCadSeguroTra);
    LiberarMemoria(sDatos.pszInternoTra);
    LiberarMemoria(sDatos.pszTaraTra);
    LiberarMemoria(sDatos.pszBrutoTra);
    LiberarMemoria(sDatos.pszMatriculaTra);
    LiberarMemoria(sDatos.pszNumeroEjesTra);

    //Liberamos variables del Suministrador
    LiberarMemoria(sDatos.pszCodigoSum);
    LiberarMemoria(sDatos.pszNombreSum);

    //Liberamos variables del Transportista
    LiberarMemoria(sDatos.pszCIFTRP);

    //Liberamos variables de ordenes
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
    {
        LiberarMemoria(sDatos.sOrden[byi].pszPedidoOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszNombreDesOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszMatriculaCisOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszCodigoSumOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszUnidadOrd);
//        LiberarMemoria(sDatos.sOrden[byi].pszNumeroOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszCodigoCliOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszCodigoCliDesOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszFechaEntOrd);
        LiberarMemoria(sDatos.sOrden[byi].pszFechaCargaOrd);
    }
    //Liberamos variables de las lineas
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
        for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
        {
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszPorcentajeMaxPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszDensidadPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszNombrePro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszCodAdiPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszImpuestoPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszCodigoPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszInternoPro);
            LiberarMemoria(sDatos.sOrden[byi].sLinea[byj].pszCantidadPro);
        }
}

//---------------------------------------------------------------------------
// void LeerEstructura(DatosAutorizacion *pszsDat)
//
// Entrada:
//          DatosAutorizacion *pszsDat: Variable de estructura de Autorizacion
//
// Descripcion: Copia la estructura de Autorizacion que hay en memoria
//              En la estructura que le pasan por parametro
//
//---------------------------------------------------------------------------
void TAutorizacion::LeerEstructura(DatosAutorizacion *pszsDat)
{
    memcpy(pszsDat,&sDatos,sizeof(sDatos));
}

//---------------------------------------------------------------------------
// int ComprobarPedidos(char *pszCodPed,hDBIDb hBaseDatos)
//
// Entrada:
//          char *pszCodPed: codigo del pedido a buscar
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un codigo de Error si lo hubo
//
// Descripcion: Gestiona las Ordenes de Carga existentes
//
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarPedidos(char *pszCodPed,hDBIDb hBaseDatos)
{
    dbiTabla TOrden;
    BYTE byNumeroOrden;
    bool bSalir;
    bool bCorrecto;
    int nValorDevuelto;
    char *pszCodSumTemp;
    char *pszCodCisTemp;
    char *pszEstadoTemp;
    char *pszFechaTemp;
    char szFecha[TAM_FECHA];

    //Inicializamos las variables
    nValorDevuelto=AUT_ORC_CORRECTO;

    //Guardamos el codigo del pedido
    byNumeroOrden=0;
    bSalir=false;
    while(byNumeroOrden<NUM_MAXIMO_ORDENES && !bSalir)
    {
        if(!(*sDatos.sOrden[byNumeroOrden].pszPedidoOrd))
        {
            strcpy(sDatos.sOrden[byNumeroOrden].pszPedidoOrd,pszCodPed);
            bSalir=true;
        }
        else
        {
            if( !strcmp( (sDatos.sOrden[byNumeroOrden].pszPedidoOrd),pszCodPed) )
            {
                nValorDevuelto=AUT_ORC_PEDIDO_DUPLICADO;
                bSalir=true;
            }
            else
                byNumeroOrden++;
        }
    }

    //Abrimos la la tabla de Ordenes de Carga
    if(!AbrirTablaBDE(&TOrden,"SIMICORC","ORCPEDORC",false,hBaseDatos))
    {
        //Pedimos memoria para las variables Temporales
        pszCodSumTemp=ReservarMemoria(&TOrden,"ORCCODSUM");
        pszCodCisTemp=ReservarMemoria(&TOrden,"ORCMATCIS");
        pszEstadoTemp=ReservarMemoria(&TOrden,"ORCCARORC");
        pszFechaTemp=ReservarMemoria(&TOrden,"ORCENTORC");

        //Busca cadena de entrada
        if(!BuscarValorExactoBDE(&TOrden,pszCodPed,NULL))
        {
            //Vemos si esta marcado como borrado
            if(!EstaRegBorBDE(&TOrden,&bCorrecto))
            {
                sDatos.bBorradoSum=bCorrecto;
                if(!bCorrecto)
                {
                    //Leemos variables temporales
                    LeerCampoNBDE(&TOrden,"ORCCARORC",pszEstadoTemp,NULL);
                    LeerCampoNBDE(&TOrden,"ORCCODSUM",pszCodSumTemp,NULL);
                    LeerCampoNBDE(&TOrden,"ORCMATCIS",pszCodCisTemp,NULL);

                    //Comprobamos si esta pendiente el pedido
                    if(strstr(pszEstadoTemp,PENDIENTE))
                    {
                        //Comprobamos que el codigo del suministrador y de la cisterna coninciden
                        if(!strcmp(pszCodSumTemp,sDatos.pszCodigoSum))
                        {
                            if(!strcmp(pszCodCisTemp,sDatos.pszMatriculaCis))
                            {
                                //Leemos la fecha de la orden
                                LeerCampoNBDE(&TOrden,"ORCENTORC",pszFechaTemp,NULL);
                                //Obtenemos la fecha actual
                                CapturarFechaGen(szFecha);
                                //Comprobamos si la fecha actual es menor o igual a la fecha de la orden
                                if(strcmp(pszFechaTemp,szFecha)>=0)
                                {
                                    //Asignamos valores
                                    strcpy(sDatos.sOrden[byNumeroOrden].pszMatriculaCisOrd,sDatos.pszMatriculaCis);
                                    strcpy(sDatos.sOrden[byNumeroOrden].pszCodigoSumOrd,sDatos.pszCodigoSum);
                                    LeerCampoNBDE(&TOrden,"ORCPEDORC",sDatos.sOrden[byNumeroOrden].pszNumeroOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCNOMDES",sDatos.sOrden[byNumeroOrden].pszNombreDesOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCENTORC",sDatos.sOrden[byNumeroOrden].pszFechaEntOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCFCAORC",sDatos.sOrden[byNumeroOrden].pszFechaCargaOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCCODCLI",sDatos.sOrden[byNumeroOrden].pszCodigoCliOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCCCLDES",sDatos.sOrden[byNumeroOrden].pszCodigoCliDesOrd,NULL);
                                    LeerCampoNBDE(&TOrden,"ORCUNIPRO",sDatos.sOrden[byNumeroOrden].pszUnidadOrd,NULL);
                                    nValorDevuelto=AUT_ORC_CORRECTO;
                                }
                                else
                                    nValorDevuelto=AUT_ORC_FECHA_MENOR_QUE_HOY;
                            }
                            else
                                nValorDevuelto=AUT_ORC_OTRA_CISTERNA;
                        }
                        else
                            nValorDevuelto=AUT_ORC_OTRO_SUMINISTRADOR;
                    }
                    else
                        nValorDevuelto=AUT_ORC_ESTADO_ACABADO;
                }
                else
                    nValorDevuelto=AUT_ORC_BORRADO;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=AUT_ORC_VALOR_NO_ENCONTRADO;

        //Liberamos variables Temporales
        LiberarMemoria(pszCodSumTemp);
        LiberarMemoria(pszCodCisTemp);
        LiberarMemoria(pszEstadoTemp);
        LiberarMemoria(pszFechaTemp);
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Cerramos la tabla SIMIORC
    if(CerrarTablaBDE(&TOrden) && nValorDevuelto==AUT_ORC_CORRECTO)
        nValorDevuelto=ERROR_BDE;

    //almacenamos el valor devuelto
    sDatos.sOrden[byNumeroOrden].nResultadoOrd=nValorDevuelto;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int CalcularPesoVolCarga(hDBIDb hBaseDatos)
//
// Entrada:
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un codigo de Error si lo hubo
//
// Descripcion: Calcula el peso y el volumen de la carga y dice si es correcto
//
//---------------------------------------------------------------------------
int TAutorizacion::CalcularPesoVolCarga(hDBIDb hBaseDatos)
{
    DBIResult FinFichero;
    dbiTabla TLinea,TProducto;
    BYTE byi,byj,byk;
    int nValorDevuelto;
    char *pszCodProTemp,*pszNumOrcTemp;
    char *pszCodAdiTemp[NUM_MAXIMO_ADITIVO];
    bool bBorrado,bVacio,bSalir;

    bVacio=false;
    //Inicializamos el Peso total del producto
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
        sDatos.sOrden[byi].nPesoOrd=0;

    //Abrimos las tablas
    if(!AbrirTablaBDE(&TLinea,"SIMICORL","ORLNUMORC",false,hBaseDatos))
    {
        if(!AbrirTablaBDE(&TProducto,"SIMICPRO","PROCODPRO",false,hBaseDatos))
        {
            //Reservamos memoria para la variable temporal
            pszCodProTemp=ReservarMemoria(&TProducto,"PROCODPRO");
            pszNumOrcTemp=ReservarMemoria(&TLinea,"ORLNUMORC");
            //Inicializamos variables
            nValorDevuelto=AUT_VIA_CORRECTO;
            byi=0;

            //Mientras haya orden y no alcanzemos el maximo numero de ordenes
            while( (*sDatos.sOrden[byi].pszNumeroOrd) && (byi<NUM_MAXIMO_ORDENES) && nValorDevuelto==AUT_VIA_CORRECTO)
            {
                //Iniciamos variables
                byj=0;
                FinFichero=0;
                //Busca cadena de entrada
                if(!BuscarValorExactoBDE(&TLinea,sDatos.sOrden[byi].pszNumeroOrd,NULL))
                {
                    //Leemos el numero de la orden de la tabla ORL
                    LeerCampoNBDE(&TLinea,"ORLNUMORC",pszNumOrcTemp,&bBorrado);

                    while(!strcmp(sDatos.sOrden[byi].pszNumeroOrd,pszNumOrcTemp) && byj<NUM_MAXIMO_LINEAS && FinFichero!=BDE_FIN_FICHERO && nValorDevuelto==AUT_VIA_CORRECTO)
                    {
                        if(!bBorrado)
                        {
                            LeerCampoNBDE(&TLinea,"ORLCODPRO",sDatos.sOrden[byi].sLinea[byj].pszCodigoPro,NULL);
                            LeerCampoNBDE(&TLinea,"ORLNOMPRO",sDatos.sOrden[byi].sLinea[byj].pszNombrePro,NULL);
                            LeerCampoNBDE(&TLinea,"ORLCANORL",sDatos.sOrden[byi].sLinea[byj].pszCantidadPro,NULL);
                            LeerCampoNBDE(&TLinea,"ORLTIMORL",sDatos.sOrden[byi].sLinea[byj].pszImpuestoPro,NULL);
                            LeerCampoNBDE(&TLinea,"ORLCODADI",sDatos.sOrden[byi].sLinea[byj].pszCodAdiPro,&bVacio);
                            if(!BuscarValorExactoBDE(&TProducto,sDatos.sOrden[byi].sLinea[byj].pszCodigoPro,NULL))
                            {
                                LeerCampoNBDE(&TProducto,"PROINTPRO",sDatos.sOrden[byi].sLinea[byj].pszInternoPro,NULL);
                                LeerCampoNBDE(&TProducto,"PROD15TAN",sDatos.sOrden[byi].sLinea[byj].pszDensidadPro,NULL);
                                LeerCampoNBDE(&TProducto,"PROMAXPRO",sDatos.sOrden[byi].sLinea[byj].pszPorcentajeMaxPro,NULL);
                                sDatos.sOrden[byi].sLinea[byj].nPesoPro=(int)(( atoi(sDatos.sOrden[byi].sLinea[byj].pszCantidadPro) * atof(sDatos.sOrden[byi].sLinea[byj].pszDensidadPro) )/1000);
                                sDatos.sOrden[byi].sLinea[byj].nVolumenPro=(int)( ( ( atoi(sDatos.sOrden[byi].sLinea[byj].pszCantidadPro) * 100) / atof(sDatos.sOrden[byi].sLinea[byj].pszPorcentajeMaxPro) ) );
                                sDatos.sOrden[byi].nPesoOrd=sDatos.sOrden[byi].nPesoOrd+sDatos.sOrden[byi].sLinea[byj].nPesoPro;
                                if(!bVacio)
                                {
                                    //Reservamos memoria para la variable temporal
                                    for(byk=0;byk<NUM_MAXIMO_ADITIVO;byk++)
                                        pszCodAdiTemp[byk]=ReservarMemoria(&TProducto,"PROCODADI1");
                                    //Inicializamos variables
                                    bSalir=false;
                                    byk=0;
                                    //Leemos el array de codigos de Aditivos
                                    LeerArrayCampoBDE(&TProducto,"PROCODADI",pszCodAdiTemp,NUM_MAXIMO_ADITIVO);
                                    //Mientras no encontremos algo o hallamos mirado todos los aditivos
                                    while(!bSalir && byk<NUM_MAXIMO_ADITIVO)
                                    {
                                        if( !strcmp(pszCodAdiTemp[byk],sDatos.sOrden[byi].sLinea[byj].pszCodAdiPro) )
                                        {
                                            bSalir=true;
                                            sDatos.sOrden[byi].sLinea[byj].byIndAdiPro=byk;
                                        }
                                        byk++;
                                    }
                                    //Liberamos la memoria pedida
                                    for(byk=0;byk<NUM_MAXIMO_ADITIVO;byk++)
                                        LiberarMemoria(pszCodAdiTemp[byk]);
                                }
                            }
                            else
                                nValorDevuelto=AUT_VIA_PRO_NO_ENCONTRADO;
                            byj++;
                        }
                        FinFichero=IrSiguienteRegBDE(&TLinea,&bBorrado);
                        LeerCampoNBDE(&TLinea,"ORLNUMORC",pszNumOrcTemp,NULL);
                    }
                }
                else
                    nValorDevuelto=AUT_VIA_ORL_NO_ENCONTRADO;
            byi++;
            }
        }
        else
            nValorDevuelto=ERROR_BDE;
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Cerramos la tabla SIMIORC
    if(CerrarTablaBDE(&TLinea) && nValorDevuelto==AUT_VIA_CORRECTO)
        nValorDevuelto=ERROR_BDE;

    //Cerramos la tabla SIMIORC
    if(CerrarTablaBDE(&TProducto) && nValorDevuelto==AUT_VIA_CORRECTO)
        nValorDevuelto=ERROR_BDE;

    //Liberamos la memoria de la variable temporal
    LiberarMemoria(pszCodProTemp);
    LiberarMemoria(pszNumOrcTemp);

    //Devolvemos el resultado
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// void InicializaEstructura(void)
//
// Descripcion: Inicializa todas las variables de la estructura de Autorizacion
//
//---------------------------------------------------------------------------
void TAutorizacion::InicializaEstructura(void)
{
    int byi,byj;

    //Inicializa Variables de conductor
    sDatos.bBorradoCon=false;
    sDatos.nResultadoCon=0;
    *sDatos.pszCadCarnetCon=0;
    *sDatos.pszCadADRCon=0;
    *sDatos.pszNombreCon=0;
    *sDatos.pszCarnetCon=0;
    *sDatos.pszInternoCon=0;
    *sDatos.pszCodigoCon=0;

    //Inicializa Variables de la cisterna
    sDatos.bBorradoCis=false;
    sDatos.nResultadoCis=0;
    sDatos.nSobrePesoCis=0;
    *sDatos.pszNombreTransCis=0;
    *sDatos.pszCTRCis=0;
    *sDatos.pszCodTransCis=0;
    *sDatos.pszCadTarjetaCis=0;
    *sDatos.pszCadADRCis=0;
    *sDatos.pszCadITVCis=0;
    *sDatos.pszCadSeguroCis=0;
    *sDatos.pszInternoCis=0;
    *sDatos.pszTaraCis=0;
    *sDatos.pszBrutoCis=0;
    *sDatos.pszCamionCis=0;
    *sDatos.pszMatriculaCis=0;
    *sDatos.pszMatriculaTraCis=0;
    *sDatos.pszCodigoCis=0;
    *sDatos.pszNumeroEjesCis=0;
    for(byi=0;byi<NUM_MAXIMO_COMPARTIMENTO;byi++)
        *sDatos.pszsVolumenCis[byi]=0;

    //Inicializa Variables de el Tractor
    sDatos.bBorradoTra=false;
    sDatos.nResultadoTra=0;
    sDatos.nSobrePesoTra=0;
    *sDatos.pszCadTarjetaTra=0;
    *sDatos.pszCadADRTra=0;
    *sDatos.pszCadITVTra=0;
    *sDatos.pszCadSeguroTra=0;
    *sDatos.pszInternoTra=0;
    *sDatos.pszTaraTra=0;
    *sDatos.pszBrutoTra=0;
    *sDatos.pszMatriculaTra=0;
    *sDatos.pszNumeroEjesTra=0;

    //Inicializamos las variables del suministrador
    sDatos.bBorradoSum=false;
    sDatos.nResultadoSum=0;
    *sDatos.pszCodigoSum=0;
    *sDatos.pszNombreSum=0;

    //Variables del Transportista
    *sDatos.pszCIFTRP=0;

    //Inicializamos las variables de ordenes y lineas
    for(byi=0;byi<NUM_MAXIMO_ORDENES;byi++)
    {
        sDatos.sOrden[byi].nPesoOrd=0;
        sDatos.sOrden[byi].bBorradoOrd=false;
        sDatos.sOrden[byi].nResultadoOrd=0;
        *sDatos.sOrden[byi].pszMatriculaCisOrd=0;
        *sDatos.sOrden[byi].pszCodigoSumOrd=0;
        *sDatos.sOrden[byi].pszNombreDesOrd=0;
        *sDatos.sOrden[byi].pszCodigoCliOrd=0;
        *sDatos.sOrden[byi].pszCodigoCliDesOrd=0;
        *sDatos.sOrden[byi].pszNumeroOrd=0;
        *sDatos.sOrden[byi].pszPedidoOrd=0;
        *sDatos.sOrden[byi].pszUnidadOrd=0;
        *sDatos.sOrden[byi].pszFechaEntOrd=0;
        *sDatos.sOrden[byi].pszFechaCargaOrd=0;

        for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
        {
            sDatos.sOrden[byi].sLinea[byj].nVolumenPro=0;
            sDatos.sOrden[byi].sLinea[byj].nPesoPro=0;
            sDatos.sOrden[byi].sLinea[byj].nResultadoPesoCarga=0;
            *sDatos.sOrden[byi].sLinea[byj].pszPorcentajeMaxPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszDensidadPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszInternoPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszNombrePro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszCodigoPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszImpuestoPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszCantidadPro=0;
            *sDatos.sOrden[byi].sLinea[byj].pszCodAdiPro=0;
        }
    }
    sDatos.nPesoDeProducto=0;

    //Inicializamos los Compartimentos
    for(byi=0;byi<NUM_MAXIMO_COMPARTIMENTO;byi++)
        sDatos.nProducto_Dep[byi]=0;
}

//---------------------------------------------------------------------------
// int TAutorizacion::ComprobarPesoCarga(hDBIDb hBaseDatos)
//
// Entrada:
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un codigo de Error si lo hubo
//
// Descripcion:
//          Comprobamos si esta perimitido el peso de carga
//
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarPesoCarga(hDBIDb hBaseDatos)
{
    int nValorDevuelto,byi;
    int nNumeroTotalEjes;
    int nCapacidadCis;
    int nCapacidadArrastreTra;
    int nPesoMaximoPermitido;
    int nPesoTotalDeCarga;
    char *pszPesoPermitido;
    dbiTabla TParametro,TLinea;

    //Inicializamos la variable
    nValorDevuelto=AUT_VIA_CORRECTO;
    nPesoMaximoPermitido=0;
    nPesoTotalDeCarga=0;

    //Abrimos las tabla de Ejes
    if(!AbrirTablaBDE(&TParametro,"SIMICPRM",NULL,false,hBaseDatos))
    {
        //Pedimos memoria para el PesoPermitido y lo inicializamos
        pszPesoPermitido=ReservarMemoria(&TParametro,"PRM3EJPRM");

        //Calculamos el peso total del producto
        byi=0;
        while(sDatos.sOrden[byi].nPesoOrd)
        {
            sDatos.nPesoDeProducto=sDatos.nPesoDeProducto+sDatos.sOrden[byi].nPesoOrd;
            byi++;
        }

        nPesoTotalDeCarga=sDatos.nPesoDeProducto;

        //Aņadimos al peso total de carga el peso de la cisterna vacia
        nPesoTotalDeCarga=nPesoTotalDeCarga+atoi(sDatos.pszTaraCis);

        //Calculamos la capacidad de la cisterna
        nCapacidadCis=atoi(sDatos.pszBrutoCis)-atoi(sDatos.pszTaraCis);

        //Calculamos la diferencia de peso
        sDatos.nSobrePesoCis=sDatos.nPesoDeProducto-nCapacidadCis;

        //Comprobamos si el producto cabe en la Cisterna
        if( sDatos.nSobrePesoCis <= 0)
        {
            if( (*sDatos.pszCamionCis) != 'F' )
            {
                //Calculamos el numero total de ejes
                nNumeroTotalEjes=atoi(sDatos.pszNumeroEjesCis)+atoi(sDatos.pszNumeroEjesTra);

                //Buscamos el peso permitido para ese numero de ejes
                if(nNumeroTotalEjes<=3)
                       LeerCampoNBDE(&TLinea,"PRM3EJPRM",pszPesoPermitido,NULL);
                else if(nNumeroTotalEjes==4)
                       LeerCampoNBDE(&TLinea,"PRM4EJPRM",pszPesoPermitido,NULL);
                else if(nNumeroTotalEjes>=5)
                       LeerCampoNBDE(&TLinea,"PRM5EJPRM",pszPesoPermitido,NULL);

                //Guardamos el peso maximo permitido
                nPesoMaximoPermitido=atoi(pszPesoPermitido);

                //Calculamos la capacidad de arrastre del tractor
                nCapacidadArrastreTra=atoi(sDatos.pszBrutoTra);

                //Cogemos la cantidad mas restrictiva
                if(nPesoMaximoPermitido>nCapacidadArrastreTra)
                    nPesoMaximoPermitido=nCapacidadArrastreTra;

                //Aņadimos al peso total de carga el peso del tractor
                nPesoTotalDeCarga=nPesoTotalDeCarga+atoi(sDatos.pszTaraTra);

                //Comprobamos si el tractor puede con todo el peso
                sDatos.nSobrePesoTra=nPesoTotalDeCarga-nCapacidadArrastreTra;
                if( sDatos.nSobrePesoTra <= 0)
                    nValorDevuelto=AUT_VIA_CORRECTO;
                else
                    nValorDevuelto=AUT_VIA_PESO_MAYOR_CAP_TRA;
            }
            else
                nValorDevuelto=AUT_VIA_CORRECTO;
        }
        else
            nValorDevuelto=AUT_VIA_PROD_MAYOR_CAP_CIS;

        //Liberamos la memoria pedida para el peso permitido
        LiberarMemoria(pszPesoPermitido);
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Cerramos las tablas
        if(CerrarTablaBDE(&TLinea) && nValorDevuelto==AUT_VIA_CORRECTO)
            nValorDevuelto=ERROR_BDE;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int TAutorizacion::ComprobarDistribucionCarga(void)
//
// Devuelve:
//          int nValorDevuelto: Devuelve un codigo de Error si lo hubo
//
// Descripcion:
//          Comprobamos si se puede repartir la carga en los depositos
//
//---------------------------------------------------------------------------
int TAutorizacion::ComprobarDistribucionCarga(void)
{
    int nValorDevuelto;

    nValorDevuelto=AUT_VIA_CORRECTO;

    if(Cabe_Cis())
        nValorDevuelto=AUT_VIA_CORRECTO;
    else
        nValorDevuelto=AUT_VIA_VOL_MAYOR_CAP_CIS;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// bool TAutorizacion::Capacidad_Ok(int n_Prod,int *psnCapacidad_Prod,int *psnCantidad_Prod)
//
// Devuelve:
//          bool: Devuelve si cabe 1, sino 0
//
// Descripcion:
//          Comprobamos si la capacidad del deposito puede admitir la cantidad de producto
//
//---------------------------------------------------------------------------
bool TAutorizacion::Capacidad_Ok(int n_Prod,int *psnCapacidad_Prod,int *psnCantidad_Prod)
{
  int nP;

  nP = n_Prod - 1 ;
  while ((nP >= 0) && (*(psnCapacidad_Prod+nP) >= *(psnCantidad_Prod+nP)))
        nP--;
  return (nP < 0);
}

//---------------------------------------------------------------------------
// bool TAutorizacion::Cabe_Cis(void)
//
// Devuelve:
//          bool: Devuelve si cabe 1, sino 0
//
// Descripcion:
//          Comprueba si los productos caben en la cisterna
//
//---------------------------------------------------------------------------
bool TAutorizacion::Cabe_Cis(void)
{
  BYTE byNumeroLineas,byi,byj;
  int  nDep,nProd,nSalta;
  int  nNum_Prod,nNum_Dep;
  int  nCapacidad_Prod[NUM_MAXIMO_COMPARTIMENTO];
  int  nCantidad_Prod[NUM_MAXIMO_COMPARTIMENTO];

  //Inicializamos la variable
  nNum_Prod=0;
  byi=0;
  byNumeroLineas=0;
  for(byj=0;byj<9;byj++)
        nCantidad_Prod[byj]=0;

  //Asignamos los volumenes disponibles al Array Capacidad Prod
  byj=0;
  while(sDatos.sOrden[byi].sLinea[byj].nVolumenPro && byNumeroLineas<9)
  {
        while(sDatos.sOrden[byi].sLinea[byj].nVolumenPro)
        {
            nCantidad_Prod[byNumeroLineas]=sDatos.sOrden[byi].sLinea[byj].nVolumenPro;
            byNumeroLineas++;
        byj++;
        }
  byj=0;
  byi++;
  }

  if(byNumeroLineas<NUM_MAXIMO_LINEAS)
  {
        //Seguimos
        while ((nNum_Prod<NUM_MAXIMO_COMPARTIMENTO) && nCantidad_Prod[nNum_Prod])
            nNum_Prod++;
        nNum_Dep=0;
        while ((nNum_Dep<NUM_MAXIMO_COMPARTIMENTO) && (*sDatos.pszsVolumenCis[nNum_Dep]))
            nNum_Dep++;
        if (nNum_Prod==0)
            return (true);
        else  if (nNum_Prod > nNum_Dep)
                return (false);
              else
              {
                    for(nProd=0;nProd<nNum_Prod;nCapacidad_Prod[nProd++]=0);
                    for (nDep=0;nDep<nNum_Dep;nDep++)
                    {
                        nCapacidad_Prod[0]+=atoi(sDatos.pszsVolumenCis[nDep]);
                        sDatos.nProducto_Dep[nDep]=0;
                    }
                    while ((nDep >= 0) && !Capacidad_Ok(nNum_Prod,nCapacidad_Prod,nCantidad_Prod))
                    {
                          nDep=nNum_Dep-1;
                          do
                          {
                                nSalta=0;
	                            nCapacidad_Prod[sDatos.nProducto_Dep[nDep]]-=atoi(sDatos.pszsVolumenCis[nDep]);
                                sDatos.nProducto_Dep[nDep]++;
                                if (sDatos.nProducto_Dep[nDep] < nNum_Prod)
                                    nCapacidad_Prod[sDatos.nProducto_Dep[nDep]]+=atoi(sDatos.pszsVolumenCis[nDep]);
                                else
                                {
                                    sDatos.nProducto_Dep[nDep]=0;
                                    nCapacidad_Prod[0]+=atoi(sDatos.pszsVolumenCis[nDep]);
                                    nDep--;
                                    nSalta=1;
                                }
                          }
                          while ((nDep >= 0) && nSalta);
                    }

              return (nDep >= 0);
              }
  }
  else
      return (false);
}

//---------------------------------------------------------------------------
// void TAutorizacion::RellenarSIMICCAR(dbiTabla TCAR)
//
// Entrada:
//          dbiTabla TCAR: Cabecera de la Tabla de SIMICCAR
//
// Descripcion:
//          Rellenamos la tabla SIMICCAR con los datos de la estructura de Autorizacion
//
//---------------------------------------------------------------------------
void TAutorizacion::RellenarSIMICCAR(dbiTabla TCAR)
{
    BYTE byi,byj;
    char szFecha[TAM_FECHA];
    char szFechaActual[TAM_FECHA];
    char szHora[TAM_HORA];
    char szNumViajeOrd[2];
    char *pszNombreProTemp[NUM_MAXIMO_LINEAS];
    char *pszCodigoProTemp[NUM_MAXIMO_LINEAS];
    char *pszInternoProTemp[NUM_MAXIMO_LINEAS];
    char *pszImpuestoProTemp[NUM_MAXIMO_LINEAS];
    char *pszIndAdiProTemp[NUM_MAXIMO_ADITIVO];

    //Obtenemos la fecha actual
    CapturarFechaHora(szFechaActual,szHora);
    CapturarFechaGen(szFecha);

    //Reservamos memoria para las variables temporales
    for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
    {
        //Reservamos memoria
        pszNombreProTemp[byj]=ReservarMemoria(&TCAR,"CARNOMPRO1");
        pszCodigoProTemp[byj]=ReservarMemoria(&TCAR,"CARCODPRO1");
        pszInternoProTemp[byj]=ReservarMemoria(&TCAR,"CARINTPRO1");
        pszImpuestoProTemp[byj]=ReservarMemoria(&TCAR,"CARTIMORL1");
        pszIndAdiProTemp[byj]=ReservarMemoria(&TCAR,"CARINDADI1");
    }

    byi=0;
    while((*sDatos.sOrden[byi].pszNumeroOrd) && byi<NUM_MAXIMO_ORDENES)
    {
        //Convertimos el numero del viaje a char[2]
        itoa(sDatos.sOrden[byi].byNumeroViajeOrd,szNumViajeOrd,10);

        //Aņadimos un registro en blanco
        AnadirRegBDE(&TCAR);

        //Rellenamos los Campos del 1 al 26
        ModificarCampoNBDE(&TCAR,"CARENTCAR",szFecha);
        ModificarCampoNBDE(&TCAR,"CARVIACAR",szNumViajeOrd);
        ModificarCampoNBDE(&TCAR,"CARMATCIS",sDatos.pszMatriculaCis);
        ModificarCampoNBDE(&TCAR,"CARNTMCIS",sDatos.pszCodigoCis);
        ModificarCampoNBDE(&TCAR,"CARINTCIS",sDatos.pszInternoCis);
        ModificarCampoNBDE(&TCAR,"CARCTRCIS",sDatos.pszCTRCis);
        ModificarCampoNBDE(&TCAR,"CARORCCAR",sDatos.sOrden[byi].pszNumeroOrd);
        ModificarCampoNBDE(&TCAR,"CARPEDORC",sDatos.sOrden[byi].pszPedidoOrd);
        ModificarCampoNBDE(&TCAR,"CARMATTRA",sDatos.pszMatriculaTra);
        ModificarCampoNBDE(&TCAR,"CARINTTRA",sDatos.pszInternoTra);
        ModificarCampoNBDE(&TCAR,"CARNOMCON",sDatos.pszNombreCon);
        ModificarCampoNBDE(&TCAR,"CARNTMCON",sDatos.pszCodigoCon);
        ModificarCampoNBDE(&TCAR,"CARINTCON",sDatos.pszInternoCon);
        ModificarCampoNBDE(&TCAR,"CARNCACON",sDatos.pszCarnetCon);
        ModificarCampoNBDE(&TCAR,"CARCODSUM",sDatos.pszCodigoSum);
        ModificarCampoNBDE(&TCAR,"CARCODCLI",sDatos.sOrden[byi].pszCodigoCliOrd);
        ModificarCampoNBDE(&TCAR,"CARCCLDES",sDatos.sOrden[byi].pszCodigoCliDesOrd);
        ModificarCampoNBDE(&TCAR,"CARESTCAR",AUTORIZADA);
//        ModificarCampoNBDE(&TCAR,"CARPENCAR",);
//        ModificarCampoNBDE(&TCAR,"CARPSACAR",);
        ModificarCampoNBDE(&TCAR,"CARUNIPRO",sDatos.sOrden[byi].pszUnidadOrd);
        ModificarCampoNBDE(&TCAR,"CARFAUCAR",szFecha);
        ModificarCampoNBDE(&TCAR,"CARHAUCAR",szHora);
        ModificarCampoNBDE(&TCAR,"CARNOMTRP",sDatos.pszNombreTransCis);
        ModificarCampoNBDE(&TCAR,"CARCODTRP",sDatos.pszCodTransCis);
        ModificarCampoNBDE(&TCAR,"CARCIFTRP",sDatos.pszCIFTRP);

        //Rellenamos los Campos del 27 al 89
        for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
        {
            //Asignamos valores
            strcpy(pszNombreProTemp[byj],sDatos.sOrden[byi].sLinea[byj].pszNombrePro);
            strcpy(pszCodigoProTemp[byj],sDatos.sOrden[byi].sLinea[byj].pszCodigoPro);
            strcpy(pszInternoProTemp[byj],sDatos.sOrden[byi].sLinea[byj].pszInternoPro);
            strcpy(pszImpuestoProTemp[byj],sDatos.sOrden[byi].sLinea[byj].pszImpuestoPro);
            itoa(sDatos.sOrden[byi].sLinea[byj].byIndAdiPro,pszIndAdiProTemp[byj],10);
        }

        EscribirArrayCampoBDE(&TCAR,"CARNOMPRO",pszNombreProTemp,NUM_MAXIMO_PRODUCTO);
        EscribirArrayCampoBDE(&TCAR,"CARCODPRO",pszCodigoProTemp,NUM_MAXIMO_PRODUCTO);
        EscribirArrayCampoBDE(&TCAR,"CARINTPRO",pszInternoProTemp,NUM_MAXIMO_PRODUCTO);
        EscribirArrayCampoBDE(&TCAR,"CARTIMORL",pszImpuestoProTemp,NUM_MAXIMO_LINEAS);
        EscribirArrayCampoBDE(&TCAR,"CARINDADI",pszIndAdiProTemp,NUM_MAXIMO_ADITIVO);
//        EscribirArrayCampoBDE(&TCAR,"CARCANCAR",,NUM_MAXIMO_CARGA);
//        EscribirArrayCampoBDE(&TCAR,"CARNOMCAR",,NUM_MAXIMO_CARGA);
        //Rellenamos los Volumenes de los compartimentos
        EscribirArrayCampoBDE(&TCAR,"CARVOLDEP",sDatos.pszsVolumenCis,NUM_MAXIMO_COMPARTIMENTO);

    byi++;
    }

    //Liberamos memoria
    for(byj=0;byj<NUM_MAXIMO_LINEAS;byj++)
    {
         free(pszNombreProTemp[byj]);
         free(pszCodigoProTemp[byj]);
         free(pszInternoProTemp[byj]);
         free(pszImpuestoProTemp[byj]);
         free(pszIndAdiProTemp[byj]);
    }

}

//---------------------------------------------------------------------------
// void BuscarNumeroViaje(hDBIDb hBaseDatos)
//
// Entrada:
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Descripcion:
//          Busca el numero del viaje del pedido
//
//---------------------------------------------------------------------------
void TAutorizacion::BuscarNumeroViaje(hDBIDb hBaseDatos)
{
    dbiTabla TOrden;
    DatosAutorizacion sDatos;
    BYTE byNumeroOrden,byNumeroViaje;
    char *pszFechaViaMat;
    char cNumViaTemp[2];
    char EspacioEnBlanco[1]=" ";
    bool bSalir;

    Autorizacion->LeerEstructura(&sDatos);
    //Abrimos la tabla
    if(!AbrirTablaBDE(&TOrden,"SIMICORC","ORCEVCORC",false,hBaseDatos))
    {
        //Pedimos memoria
        pszFechaViaMat=(char *)malloc(strlen(sDatos.sOrden[0].pszFechaCargaOrd)+strlen(EspacioEnBlanco)+strlen(cNumViaTemp)+strlen(sDatos.pszMatriculaCis));
        //Inicializamos variables
        byNumeroOrden=0;
        bSalir=false;
        while(!bSalir)
        {
            if(!(*sDatos.sOrden[byNumeroOrden].pszNumeroOrd))
                bSalir=true;
            else
            {
                bSalir=false;
                byNumeroViaje=1;
                while(byNumeroViaje<NUM_MAXIMO_VIAJES && !bSalir)
                {
                    //Ponemos el numero viaje segun corresponda
                    itoa(byNumeroViaje,cNumViaTemp,10);
                    //Inicializamos variable
                    memset( pszFechaViaMat,0,strlen(sDatos.sOrden[0].pszFechaCargaOrd)+strlen(EspacioEnBlanco)+strlen(cNumViaTemp)+strlen(sDatos.pszMatriculaCis) );
                    //Asignamos variables
                    memcpy( pszFechaViaMat,sDatos.sOrden[byNumeroOrden].pszFechaCargaOrd,strlen(sDatos.sOrden[byNumeroOrden].pszFechaCargaOrd) );
                    if(byNumeroViaje<9)
                    {
                        memcpy( pszFechaViaMat+strlen(sDatos.sOrden[byNumeroOrden].pszFechaEntOrd),EspacioEnBlanco,strlen(EspacioEnBlanco)-1 );
                        memcpy( pszFechaViaMat+strlen(sDatos.sOrden[byNumeroOrden].pszFechaEntOrd)+1,cNumViaTemp,strlen(cNumViaTemp) );
                        memcpy( pszFechaViaMat+strlen(sDatos.sOrden[byNumeroOrden].pszFechaEntOrd)+strlen(cNumViaTemp)+1,sDatos.pszMatriculaCis,strlen(sDatos.pszMatriculaCis) );
                    }
                    else
                    {
                        memcpy( pszFechaViaMat+strlen(sDatos.sOrden[byNumeroOrden].pszFechaEntOrd),cNumViaTemp,strlen(cNumViaTemp) );
                        memcpy( pszFechaViaMat+strlen(sDatos.sOrden[byNumeroOrden].pszFechaEntOrd)+strlen(cNumViaTemp),sDatos.pszMatriculaCis,strlen(sDatos.pszMatriculaCis) );
                    }
                    //Buscamos
                    if(!BuscarValorExactoBDE(&TOrden,pszFechaViaMat,NULL))
                    {
                        ShowMessage("Los codigo fueron encontrados");
                        byNumeroViaje++;
                    }
                    else
                    {
                        ShowMessage("No se encontro");
                        bSalir=true;
                    }
                }
                //Almacenamos el numero de viaje si se encontro si no lo ponemos a 0
                if(byNumeroViaje==NUM_MAXIMO_VIAJES && !bSalir)
                    sDatos.sOrden[byNumeroOrden].byNumeroViajeOrd=0;
                else
                    sDatos.sOrden[byNumeroOrden].byNumeroViajeOrd=byNumeroViaje;

                bSalir=false;
            }
            byNumeroOrden++;
        }
        //Liberamos memoria
        LiberarMemoria(pszFechaViaMat);
    }
    else
        ShowMessage("Hubo un error");

    //Cerramos la tabla
    if(CerrarTablaBDE(&TOrden))
        ShowMessage("Hubo un error");

}

//---------------------------------------------------------------------------
// void ActualizaEstado(hDBIDb hBaseDatos)
//
// Entrada:
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Descripcion:
//          Actualiza el Estado de las tablas
//
//---------------------------------------------------------------------------
void TAutorizacion::ActualizaEstado(hDBIDb hBaseDatos)
{
    dbiTabla TOrden;
    BYTE byNumeroOrden;

    //Actualizamos conductor, cisterna y tractor
    ActualizaEstadoGen(sDatos.pszCodigoCis,sDatos.pszMatriculaTra,sDatos.pszCodigoCon,AUTORIZADA,hBaseDatos);

    //Abrimos la tabla de Ordenes y actualizamos
    if(!AbrirTablaBDE(&TOrden,"SIMICORC","ORCNUMORC",false,hBaseDatos))
    {
        byNumeroOrden=0;
        while(!(*sDatos.sOrden[byNumeroOrden].pszNumeroOrd) && byNumeroOrden<NUM_MAXIMO_ORDENES)
        {
            if(!BuscarValorExactoBDE(&TOrden,sDatos.sOrden[byNumeroOrden].pszNumeroOrd,NULL))
            {
                ModificarCampoNBDE(&TOrden,"ORCESTORC",AUTORIZADA);
                ModificarCampoNBDE(&TOrden,"ORCMATTRA",sDatos.pszMatriculaTra);
                ModificarCampoNBDE(&TOrden,"ORCNCACON",sDatos.pszCarnetCon);
                ModificarCampoNBDE(&TOrden,"ORCNOMCON",sDatos.pszNombreCon);
            }
        byNumeroOrden++;
        }
    }

    //Cerramos la tabla
    CerrarTablaBDE(&TOrden);
}
//---------------------------------------------------------------------------
// class TPesoEntrada
// {
//  protected:
//  private:	// User declarations
//      DatosPesoEntrada sDatosEnt;
//  public:
//      TPesoEntrada(void);
//      BYTE PesoEntrada(char *pszCodCisterna,char *pszCodTractor,char *pszCodConductor,hDBIDb hBaseDatos);
//      BYTE ComprobarCisterna(char *pszNTMCis,hDBIDb hBaseDatos);
//      BYTE ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR);
//      BYTE ComprobarPeso(char *pszTaraCis,char *pszTaraTra);
//      void CambiarEstado(hDBIDb hBaseDatos);
//      void ReservarMemoriaEstructura(hDBIDb hBaseDatos);
//      void LiberarEstructura(void);
// };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Constructor de la clase
//---------------------------------------------------------------------------
TPesoEntrada::TPesoEntrada(void)
{
}

//---------------------------------------------------------------------------
// int PesoEntrada(char *pszCodCisterna,hDBIDb hBaseDatos)
//
// Entrada:
//          char *pszCodCisterna: Codigo de la cisterna a comprobar
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un Error si lo hubo
//
// Descripcion:
//          Rellena la Estructura Peso de Entrada leyendo de las tablas
//
//---------------------------------------------------------------------------
int TPesoEntrada::PesoEntrada(char *pszCodCisterna,hDBIDb hBaseDatos)
{
    //Declaramos las variables
    dbiTabla TCis,TTra,TCon,TOrc,TPrm,TCar;
    int nValorDevuelto;
    DBIResult Error;
    char *pszCodCisTemp;
    bool bBorrado;

    //Inicializamos las variables
    nValorDevuelto=PEE_CORRECTO;
    Error=0;

    //Abrimos la tabla de Prm para la tolerancia
    if(!AbrirTablaBDE(&TPrm,"SIMICPRM",NULL,false,hBaseDatos))
    {
        //Leemos las tolerancias maxima y minima de la entrada y salida
        LeerCampoNBDE(&TPrm,"PRMTSEPRM",sDatosEnt.pszToleranciaMaxEntPEE,NULL);
        LeerCampoNBDE(&TPrm,"PRMTIEPRM",sDatosEnt.pszToleranciaMinEntPEE,NULL);
    }
    //Cerramos la tabla de Prm
    if(CerrarTablaBDE(&TPrm))
        nValorDevuelto=ERROR_BDE;

    //Abrimos la tabla TCAR en exclusiva
    if(!AbrirTablaBDE(&TCar,"SIMICCAR",NULL,true,hBaseDatos))
    {
        //Asignamos el valor al codigo de cisterna
        strcpy(sDatosEnt.pszCodigoCisPEE,pszCodCisterna);

        //Comprobamos el Estado
        nValorDevuelto=ComprobarEstado(pszCodCisterna,TCar);

        if(nValorDevuelto==PEE_CORRECTO)
        {
            //Leemos el codigo del Tractor y del Conductor
            LeerCampoNBDE(&TCar,"CARMATTRA",sDatosEnt.pszCodigoTraPEE,NULL);
            LeerCampoNBDE(&TCar,"CARNTMCON",sDatosEnt.pszCodigoConPEE,NULL);

            //Abrimos la tabla de Cisterna
            if(!AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos))
            {
                //Buscamos el ntm de la cisterna
                if(!BuscarValorExactoBDE(&TCis,pszCodCisterna,NULL))
                {
                    //Cogemos la Tara de Cisternas
                    LeerCampoNBDE(&TCis,"CISMATCIS",sDatosEnt.pszMatriculaCisPEE,NULL);
                    LeerCampoNBDE(&TCis,"CISTARCIS",sDatosEnt.pszTaraCisPEE,NULL);
                    LeerCampoNBDE(&TCis,"CISCAMCIS",sDatosEnt.pszCamionCisPEE,NULL);

                    //Abrimos la tabla del tractor
                    if(!AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos))
                    {
                        //Si no es un camion
                        if( (*sDatosEnt.pszCamionCisPEE) == 'F' )
                        {
                            //Buscamos el Matricula del Tractor
                            if(!BuscarValorExactoBDE(&TTra,sDatosEnt.pszCodigoTraPEE,NULL))
                                LeerCampoNBDE(&TTra,"TRATARTRA",sDatosEnt.pszTaraTraPEE,NULL);
                            else
                                nValorDevuelto=PEE_TRACTOR_NO_ENCONTRADO;
                        }
                        //Comprobamos el peso
                        nValorDevuelto=ComprobarPeso(sDatosEnt.pszTaraCisPEE,sDatosEnt.pszTaraTraPEE);
                    }
                    else
                        nValorDevuelto=ERROR_BDE;
                }
                else
                    nValorDevuelto=PEE_CISTERNA_NO_ENCONTRADA;
            }
            else
                nValorDevuelto=ERROR_BDE;
        }
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Cerramos la tabla de TCAR
    if(CerrarTablaBDE(&TCar))
        nValorDevuelto=ERROR_BDE;

    //Si todo fue sin errores cambiamos los estados
    if(nValorDevuelto==PEE_CORRECTO)
    {
        //Cambiamos le estado de la Cisterna
        ModificarCampoNBDE(&TCis,"CISESTCIS",PESO_ENTRADA);

        //Cerramos la tabla TCis
        if(CerrarTablaBDE(&TCis))
            nValorDevuelto=ERROR_BDE;

        //Si no es un camion
        if((*sDatosEnt.pszCamionCisPEE) == 'F' )
            //Cambiamos le estado de la cisterna y el Tractor
            ModificarCampoNBDE(&TTra,"TRAESTTRA",PESO_ENTRADA);

        //Cerramos la tabla TTra
        if(CerrarTablaBDE(&TTra))
            nValorDevuelto=ERROR_BDE;

        //Abrimos la tabla de Conductor
        if(!AbrirTablaBDE(&TCon,"SIMICCON","CONNTMCON",false,hBaseDatos))
        {
            //Buscamos el conductor y Cambiamos el estado de conductor
            if(!BuscarValorExactoBDE(&TCon,sDatosEnt.pszCodigoConPEE,NULL))
                ModificarCampoNBDE(&TCon,"CONESTCON",PESO_ENTRADA);
            else
                nValorDevuelto=PEE_CONDUCTOR_NO_ENCONTRADO;
        }
        else
            nValorDevuelto=ERROR_BDE;

        //Cerramos la tabla Tcon
        if(CerrarTablaBDE(&TCon))
            nValorDevuelto=ERROR_BDE;

        //Abrimos la tabla de ORdenes de carga
        if(!AbrirTablaBDE(&TOrc,"SIMICORC","ORCNUMORC",false,hBaseDatos))
        {
            //Actualizamos el Estado de todas las ordenes que correspondan
            //a la cisterna en cuestion
            Error=0;
            //Pedimos memoria para la variable temporal
            pszCodCisTemp=ReservarMemoria(&TOrc,"ORCMATCIS");
            //Mientras no hallamos llegao al final del fichero
            while(Error==0)
            {
                //Leemos el codigo de cisterna de TOrc
                LeerCampoNBDE(&TOrc,"ORCMATCIS",pszCodCisTemp,NULL);
                //Si coincide con la cisterna entrante..
                if(!strcmp(sDatosEnt.pszMatriculaCisPEE,pszCodCisTemp))
                    ModificarCampoNBDE(&TOrc,"ORCESTORC",PESO_ENTRADA);
                Error=IrSiguienteRegBDE(&TOrc,&bBorrado);
            }
            //Liberamos la memoria de la variable temporal
            LiberarMemoria(pszCodCisTemp);
        }
        else
            nValorDevuelto=ERROR_BDE;

        //Cerramos la tabla TOrc
        if(CerrarTablaBDE(&TOrc))
            nValorDevuelto=ERROR_BDE;
    }

    sDatosEnt.nResultadoPesoEntrada=nValorDevuelto;
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// void ReservarMemoriaEstructura(hDBIDb hBaseDatos)
//
// Entrada:
//              hDBIDb hBaseDatos: Cabecera de la Base de datos
//
// Descripcion: Reserva Memoria para la Estructura de PesoEntrada
//
//---------------------------------------------------------------------------
void TPesoEntrada::ReservarMemoriaEstructura(hDBIDb hBaseDatos)
{
    dbiTabla TPrm,TCis,TTra,TCon;

    //Reservamos memoria para la Tolerancia
    AbrirTablaBDE(&TPrm,"SIMICPRM",NULL,false,hBaseDatos);
    sDatosEnt.pszToleranciaMaxEntPEE=ReservarMemoria(&TPrm,"PRMTSEPRM");
    sDatosEnt.pszToleranciaMinEntPEE=ReservarMemoria(&TPrm,"PRMTIEPRM");
    CerrarTablaBDE(&TPrm);

    //Reservamos memoria para la tara de cisterna
    AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos);
    sDatosEnt.pszMatriculaCisPEE=ReservarMemoria(&TCis,"CISMATCIS");
    sDatosEnt.pszCodigoCisPEE=ReservarMemoria(&TCis,"CISNTMCIS");
    sDatosEnt.pszTaraCisPEE=ReservarMemoria(&TCis,"CISTARCIS");
    sDatosEnt.pszCamionCisPEE=ReservarMemoria(&TCis,"CISCAMCIS");
    CerrarTablaBDE(&TCis);

    //Reservamos memoria para la tara del Tractor
    AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos);
    sDatosEnt.pszCodigoTraPEE=ReservarMemoria(&TTra,"TRAMATTRA");
    sDatosEnt.pszTaraTraPEE=ReservarMemoria(&TTra,"TRATARTRA");
    CerrarTablaBDE(&TTra);

    //Reservamos memoria para el conductor
    AbrirTablaBDE(&TCon,"SIMICCON","CONNTMCON",false,hBaseDatos);
    sDatosEnt.pszCodigoConPEE=ReservarMemoria(&TCon,"CONNTMCON");
    CerrarTablaBDE(&TCon);

}

//---------------------------------------------------------------------------
// void LiberarEstructura(void)
//
// Descripcion: Liberamos la Memoria Reservada  para la Estructura de PesoEntrada
//
//---------------------------------------------------------------------------
void TPesoEntrada::LiberarEstructura(void)
{
    //Liberamos las Tolerancias
    LiberarMemoria(sDatosEnt.pszToleranciaMaxEntPEE);
    LiberarMemoria(sDatosEnt.pszToleranciaMinEntPEE);

    //Liberamos variables de la Cisterna
    LiberarMemoria(sDatosEnt.pszMatriculaCisPEE);
    LiberarMemoria(sDatosEnt.pszTaraCisPEE);
    LiberarMemoria(sDatosEnt.pszCamionCisPEE);
    LiberarMemoria(sDatosEnt.pszCodigoCisPEE);

    //Liberamos variables del Tractor
    LiberarMemoria(sDatosEnt.pszCodigoTraPEE);
    LiberarMemoria(sDatosEnt.pszTaraTraPEE);

    //Liberamos variable del Conductor
    LiberarMemoria(sDatosEnt.pszCodigoConPEE);

    //inicializamos la variable de Error
    sDatosEnt.nResultadoPesoEntrada=0;
}

//---------------------------------------------------------------------------
// int ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR)
//
// Entrada:
//          char *pszCodCisterna: Codigo de la cisterna
//          dbiTabla TCAR: cabecera de la tabla SIMICCAR
//
// Salida:
//         int nValorDevuelto: Devuele un Error si lo hubo.
//
// Descripcion: Comprueba el estado de la tabla SIMICCAR
//
//---------------------------------------------------------------------------
int TPesoEntrada::ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR)
{
    int nValorDevuelto;
    DBIResult Error;
    char *pszCodCisTemp,*pszEstadoTemp;
    bool bBorrado;

    //Inicializamos variables
    nValorDevuelto=PEE_CISTERNA_SIN_ORDEN;
    Error=0;

    //Pedimos memoria para la variable temporal
    pszCodCisTemp=ReservarMemoria(&TCAR,"CARNTMCIS");
    pszEstadoTemp=ReservarMemoria(&TCAR,"CARESTCAR");

    //mientras no lleguemos al final de la tabla
    while(Error==0 && nValorDevuelto==PEE_CISTERNA_SIN_ORDEN)
    {
        //Si el codigo de la cisterna coincide vemos su estado
        LeerCampoNBDE(&TCAR,"CARNTMCIS",pszCodCisTemp,NULL);
        if(!strcmp(pszCodCisTemp,pszCodCisterna))
        {
            //Miramos el estado
            LeerCampoNBDE(&TCAR,"CARESTCAR",pszEstadoTemp,NULL);
            if(!strstr(pszEstadoTemp,AUTORIZADA))
               nValorDevuelto=PEE_ESTADO_NO_AUTORIZADO;
            else
               nValorDevuelto=PEE_CORRECTO;
        }
        else
            Error=IrSiguienteRegBDE(&TCAR,&bBorrado);
    }

    //Liberamos memoria
    LiberarMemoria(pszCodCisTemp);
    LiberarMemoria(pszEstadoTemp);

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int TPesoEntrada::ComprobarPeso(char *pszTaraCis,char *pszTaraTra)
//
// Entrada:
//          char *pszTaraCis: Valor de la Tara de la cisterna
//          char *pszTaraTra: Valor de la Tara del Tractor
//
// Salida:
//         int nValorDevuelto: Devuele un Error si lo hubo.
//
// Descripcion: Comprueba el Peso de la Cisterna
//
//---------------------------------------------------------------------------
int TPesoEntrada::ComprobarPeso(char *pszTaraCis,char *pszTaraTra)
{
    int nValorDevuelto;
    int nPesoTotalCis,nTolMaxEnt,nTolMinEnt,nPesoBascula;

    //Inicializamos variable
    nPesoBascula=14700;
    nValorDevuelto=PEE_CORRECTO;
    nTolMaxEnt=atoi(sDatosEnt.pszToleranciaMaxEntPEE);
    nTolMinEnt=atoi(sDatosEnt.pszToleranciaMinEntPEE);

    //Calculamos el Peso Total de la cisterna
    nPesoTotalCis=atoi(pszTaraCis);
    if(strcmp(pszTaraTra,""))
        nPesoTotalCis=nPesoTotalCis+atoi(pszTaraTra);

    //Comprobamos el peso de la cisterna con el de la bascula teniendo encuenta la tolerancia
    if((nPesoBascula>(nPesoTotalCis+nTolMaxEnt)) || (nPesoBascula<(nPesoTotalCis-nTolMinEnt)))
        nValorDevuelto=PEE_PESO_FUERA_DE_TOLERANCIA;

    return nValorDevuelto;
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------------
// class TPesoSalida
// {
//  protected:
//  private:	// User declarations
//      DatosPesoEntrada sDatosEnt;
//  public:
//      TPesoSalida(void);
//      BYTE PesoSalida(char *pszCodCisterna,char *pszCodTractor,char *pszCodConductor,hDBIDb hBaseDatos);
//      BYTE ComprobarCisterna(char *pszNTMCis,hDBIDb hBaseDatos);
//      BYTE ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR);
//      BYTE ComprobarPeso(char *pszTaraCis,char *pszTaraTra);
//      void CambiarEstado(hDBIDb hBaseDatos);
//      void ReservarMemoriaEstructura(hDBIDb hBaseDatos);
//      void LiberarEstructura(void);
// };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Constructor de la clase
//---------------------------------------------------------------------------
TPesoSalida::TPesoSalida(void)
{
}

//---------------------------------------------------------------------------
// int TPesoSalida::PesoSalida(char *pszCodCisterna,hDBIDb hBaseDatos)
//
// Entrada:
//          char *pszCodCisterna: Codigo de la cisterna a comprobar
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un Error si lo hubo
//
// Descripcion:
//          Rellena la Estuctura PEsoSalida leyendo de las tablas
//
//---------------------------------------------------------------------------
int TPesoSalida::PesoSalida(char *pszCodCisterna,hDBIDb hBaseDatos)
{
    dbiTabla TPrm,TCar,TCis,TTra;
    int nValorDevuelto;

    //Inicializamos las variables
    nValorDevuelto=PES_CORRECTO;

    //Abrimos la tabla de Prm para la tolerancia
    if(!AbrirTablaBDE(&TPrm,"SIMICPRM",NULL,false,hBaseDatos))
    {
        //Leemos las tolerancias maxima y minima de la entrada y salida
        LeerCampoNBDE(&TPrm,"PRMTSSPRM",sDatosSal.pszToleranciaMaxSalPES,NULL);
        LeerCampoNBDE(&TPrm,"PRMTISPRM",sDatosSal.pszToleranciaMinSalPES,NULL);
    }
    //Cerramos la tabla de Prm
    if(CerrarTablaBDE(&TPrm))
        nValorDevuelto=ERROR_BDE;

    //Abrimos la tabla TCAR en exclusiva
    if(!AbrirTablaBDE(&TCar,"SIMICCAR",NULL,true,hBaseDatos))
    {
        //Reservamos memoria y asignamos valor para el codigo de la cisterna
        strcpy(sDatosSal.pszCodigoCisPES,pszCodCisterna);

        //Comprobamos el Estado y nos situamos en el registro en cuestion
        nValorDevuelto=ComprobarEstado(pszCodCisterna,TCar);

        //Reservamos memoria y asignamos valor para el codigo del tractor
        LeerCampoNBDE(&TCar,"CARMATTRA",sDatosSal.pszCodigoTraPES,NULL);

        if(nValorDevuelto==PES_CORRECTO)
        {
            //Abrimos la tabla de Cisterna
            if(!AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos))
            {
                //Buscamos el ntm de la cisterna
                if(!BuscarValorExactoBDE(&TCis,pszCodCisterna,NULL))
                {
                    //Cogemos la Tara de Cisternas
                    LeerCampoNBDE(&TCis,"CISTARCIS",sDatosSal.pszTaraCisPES,NULL);
                    LeerCampoNBDE(&TCis,"CISCAMCIS",sDatosSal.pszCamionCisPES,NULL);

                    //Comprobamos si es un camion
                    if( (*sDatosSal.pszCamionCisPES) != 'F' )
                    {
                        //Abrimos la la tabla de Tractor
                        if(!AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos))
                        {
                            //Busca cadena de entrada
                            if(!BuscarValorExactoBDE(&TTra,sDatosSal.pszCodigoTraPES,NULL))
                            {
                                //Cogemos la Tara del Tractor
                                LeerCampoNBDE(&TTra,"TRATARTRA",sDatosSal.pszTaraTraPES,NULL);
                                //Comprobamos el Peso
                                nValorDevuelto=ComprobarPeso(sDatosSal.pszTaraTraPES);
                            }
                            else
                                nValorDevuelto=PES_TRACTOR_NO_ENCONTRADO;
                        }
                        else
                            nValorDevuelto=ERROR_BDE;

                        //Cerramos la tabla de TCar
                        if(CerrarTablaBDE(&TTra))
                        nValorDevuelto=ERROR_BDE;
                    }
                    else
                         nValorDevuelto=ComprobarPeso(sDatosSal.pszTaraCisPES);
                }
                else
                     nValorDevuelto=PES_CISTERNA_NO_ENCONTRADA;
            }
            else
                 nValorDevuelto=ERROR_BDE;

            //Cerramos la tabla de TCar
            if(CerrarTablaBDE(&TCis))
                nValorDevuelto=ERROR_BDE;
        }
    }
    else
        nValorDevuelto=ERROR_BDE;

    //Cerramos la tabla de TCar
    if(CerrarTablaBDE(&TCar))
        nValorDevuelto=ERROR_BDE;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// void LiberarEstructura(void)
//
// Descripcion:
//          Libera la Estuctura de PEsoSalida
//
//---------------------------------------------------------------------------
void TPesoSalida::LiberarEstructura(void)
{
    //Liberamos las Tolerancias
    LiberarMemoria(sDatosSal.pszToleranciaMaxSalPES);
    LiberarMemoria(sDatosSal.pszToleranciaMinSalPES);

    //Liberamos variables de la Cisterna
    LiberarMemoria(sDatosSal.pszTaraCisPES);
    LiberarMemoria(sDatosSal.pszCamionCisPES);
    LiberarMemoria(sDatosSal.pszCodigoCisPES);

    //Liberamos variables del Tractor
    LiberarMemoria(sDatosSal.pszCodigoTraPES);
    LiberarMemoria(sDatosSal.pszTaraTraPES);

    //Liberamos variable del Conductor
    LiberarMemoria(sDatosSal.pszCodigoConPES);

    //inicializamos la variable de Error
    sDatosSal.nResultadoPesoSalida=0;
}

//---------------------------------------------------------------------------
// int ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR)
//
// Entrada:
//          char *pszCodCisterna: Codigo de la cisterna
//          dbiTabla TCAR: cabecera de la tabla SIMICCAR
//
// Salida:
//         int nValorDevuelto: Devuele un Error si lo hubo.
//
// Descripcion: Comprueba el estado de la tabla SIMICCAR
//
//---------------------------------------------------------------------------
int TPesoSalida::ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR)
{
    int nValorDevuelto;
    DBIResult Error;
    char *pszCodCisTemp,*pszEstadoTemp;
    bool bBorrado;

    //Inicializamos variables
    nValorDevuelto=PES_CISTERNA_SIN_ORDEN;
    Error=0;

    //Pedimos memoria para la variable temporal
    pszCodCisTemp=ReservarMemoria(&TCAR,"CARNTMCIS");
    pszEstadoTemp=ReservarMemoria(&TCAR,"CARESTCAR");

    //mientras no lleguemos al final de la tabla
    while(Error==0)
    {
        //Si la el codigo de la cisterna coincide vemos su estado
        LeerCampoNBDE(&TCAR,"CARNTMCIS",pszCodCisTemp,NULL);
        if(!strcmp(pszCodCisTemp,pszCodCisterna))
        {
            //Miramos el estado
            LeerCampoNBDE(&TCAR,"CARESTCAR",pszEstadoTemp,NULL);
            if(!strstr(pszEstadoTemp,CARGADA))
               nValorDevuelto=PES_ESTADO_NO_CARGADO;
            else
               nValorDevuelto=PES_CORRECTO;
        }
        //Vamos al siguiente registro
        Error=IrSiguienteRegBDE(&TCAR,&bBorrado);
    }

    //Liberamos memoria
    LiberarMemoria(pszCodCisTemp);
    LiberarMemoria(pszEstadoTemp);

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int ComprobarPeso(char *pszTaraCis)
//
// Entrada:
//          char *pszTaraCis: Valor de la Tara de la cisterna
//
// Salida:
//         int nValorDevuelto: Devuele un Error si lo hubo.
//
// Descripcion: Comprueba el Peso de la Cisterna
//
//---------------------------------------------------------------------------
int TPesoSalida::ComprobarPeso(char *pszTaraCis)
{
    int nValorDevuelto;
    int nPesoTotalCis,nTolMaxSal,nTolMinSal,nPesoBascula;

    //Inicializamos variable
    nPesoBascula=8000;
    nValorDevuelto=PES_CORRECTO;
    nTolMaxSal=atoi(sDatosSal.pszToleranciaMaxSalPES);
    nTolMinSal=atoi(sDatosSal.pszToleranciaMinSalPES);

    //Calculamos el Peso Total de la cisterna
    nPesoTotalCis=atoi(pszTaraCis);

    //Comprobamos el peso de la cisterna con el de la bascula teniendo encuenta la tolerancia
    if((nPesoBascula>(nPesoTotalCis+nTolMaxSal)) || (nPesoBascula<(nPesoTotalCis-nTolMinSal)))
        nValorDevuelto=PES_PESO_FUERA_DE_TOLERANCIA;

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// void ReservarMemoriaEstructura(hDBIDb hBaseDatos)
//
// Entrada:
//              hDBIDb hBaseDatos: Cabecera de la Base de datos
//
// Descripcion: Reserva Memoria para la Estructura de PesoSalida
//
//---------------------------------------------------------------------------
void TPesoSalida::ReservarMemoriaEstructura(hDBIDb hBaseDatos)
{
    dbiTabla TPrm,TCis,TTra,TCon;

    //Reservamos memoria para la tolerancia
    AbrirTablaBDE(&TPrm,"SIMICPRM",NULL,false,hBaseDatos);
    sDatosSal.pszToleranciaMaxSalPES=ReservarMemoria(&TPrm,"PRMTSSPRM");
    sDatosSal.pszToleranciaMinSalPES=ReservarMemoria(&TPrm,"PRMTISPRM");
    CerrarTablaBDE(&TPrm);

    //Reservamos memoria para la tara de cisterna
    AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos);
    sDatosSal.pszTaraCisPES=ReservarMemoria(&TCis,"CISTARCIS");
    sDatosSal.pszCamionCisPES=ReservarMemoria(&TCis,"CISCAMCIS");
    sDatosSal.pszCodigoCisPES=ReservarMemoria(&TCis,"CISNTMCIS");
    CerrarTablaBDE(&TCis);

    //Reservamos memoria para la tara del Tractor
    AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos);
    sDatosSal.pszTaraTraPES=ReservarMemoria(&TTra,"TRATARTRA");
    sDatosSal.pszCodigoTraPES=ReservarMemoria(&TTra,"TRAMATTRA");
    CerrarTablaBDE(&TTra);

    //Reservamos memoria para el Conductor
    AbrirTablaBDE(&TCon,"SIMICCON","CONNTMCON",false,hBaseDatos);
    sDatosSal.pszCodigoConPES=ReservarMemoria(&TCon,"CONNTMCON");
    CerrarTablaBDE(&TCon);
}
//---------------------------------------------------------------------------
// class TAlbaran
// {
//  protected:
//  private:
//
//  public:
//      TAlbaran(void);
//      BYTE Albaran(hDBIDb hBaseDatos);
//      BYTE ComprobarCisterna(char *pszNTMCis,hDBIDb hBaseDatos);
//      BYTE ComprobarEstado(char *pszCodCisterna,dbiTabla TCAR);
//      BYTE ComprobarPeso(char *pszTaraCis,char *pszTaraTra);
//      void CambiarEstado(hDBIDb hBaseDatos);
//      void ReservarMemoriaEstructura(hDBIDb hBaseDatos);
//      void LiberarEstructura(void);
// };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Constructor de la clase
//---------------------------------------------------------------------------
TAlbaran::TAlbaran(void)
{
}

//---------------------------------------------------------------------------
// void ReservarMemoriaEstructura(hDBIDb hBaseDatos)
//
// Entrada:
//              hDBIDb hBaseDatos: Cabecera de la Base de datos
//
// Descripcion: Reserva Memoria para la Estructura de Albaran
//
//---------------------------------------------------------------------------
void TAlbaran::ReservarMemoriaEstructura(hDBIDb hBaseDatos)
{
    dbiTabla TCis,TTra,TCon,TSum,TCli,TDes,TCar,TTrp;
    BYTE i,j;

    //Pedimos memoria para la Cisterna
    AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
    {
        sDatosAlb.CodIntCisAlb[i]=ReservarMemoria(&TCis,"CISINTCIS");
        sDatosAlb.CodNtmCisAlb[i]=ReservarMemoria(&TCis,"CISNTMCIS");
    }
    CerrarTablaBDE(&TCis);

    //Pedimos memoria para el Tractor
    AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
    {
        sDatosAlb.CodIntTraAlb[i]=ReservarMemoria(&TTra,"TRAINTTRA");
        sDatosAlb.CodMatTraAlb[i]=ReservarMemoria(&TTra,"TRAMATTRA");
    }
    CerrarTablaBDE(&TTra);

    //Pedimos memoria para el Conductor
    AbrirTablaBDE(&TCon,"SIMICCON","CONNTMCON",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
        sDatosAlb.CodIntConAlb[i]=ReservarMemoria(&TCon,"CONINTCON");
    CerrarTablaBDE(&TCon);

    //Pedimos memoria para el Suministrador
    AbrirTablaBDE(&TSum,"SIMICSUM","SUMCODSUM",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
        sDatosAlb.CodSumAlb[i]=ReservarMemoria(&TSum,"SUMCODSUM");
    CerrarTablaBDE(&TSum);

    //Pedimos memoria para el Cliente
    AbrirTablaBDE(&TCli,"SIMICCLI","CLICODCLI",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
        sDatosAlb.CodCliAlb[i]=ReservarMemoria(&TCli,"CLICODCLI");
    CerrarTablaBDE(&TCli);

    //Pedimos memoria para el Destino
    AbrirTablaBDE(&TDes,"SIMICDES","DESCYDDES",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
        sDatosAlb.CclDesAlb[i]=ReservarMemoria(&TDes,"DESCCLDES");
    CerrarTablaBDE(&TDes);

    //Pedimos memoria para el Transportista
    AbrirTablaBDE(&TTrp,"SIMICTRP","TRPCODTRP",false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
        sDatosAlb.CodTrpAlb[i]=ReservarMemoria(&TTrp,"TRPCODTRP");
    CerrarTablaBDE(&TTrp);

    //Pedimos memoria para la Carga
    AbrirTablaBDE(&TCar,"SIMICCAR",NULL,false,hBaseDatos);
    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
    {
        sDatosAlb.PenCarAlb[i]=ReservarMemoria(&TCar,"CARPENCAR");
        sDatosAlb.PsaCarAlb[i]=ReservarMemoria(&TCar,"CARPSACAR");
        for(j=0;j<NUM_MAXIMO_COMPARTIMENTO;j++)
        {
            sDatosAlb.ProDepAlb[j][i]=ReservarMemoria(&TCar,"CARPRODEP1");
            sDatosAlb.TimDepAlb[j][i]=ReservarMemoria(&TCar,"CARTIMDEP1");
            sDatosAlb.AdiDepAlb[j][i]=ReservarMemoria(&TCar,"CARADIDEP1");
            sDatosAlb.ConDepAlb[j][i]=ReservarMemoria(&TCar,"CARCONDEP1");
            sDatosAlb.BruDepAlb[j][i]=ReservarMemoria(&TCar,"CARBRUDEP1");
            sDatosAlb.NetDepAlb[j][i]=ReservarMemoria(&TCar,"CARNETDEP1");
            sDatosAlb.PesDepAlb[j][i]=ReservarMemoria(&TCar,"CARPESDEP1");
            sDatosAlb.D15DepAlb[j][i]=ReservarMemoria(&TCar,"CARD15DEP1");
            sDatosAlb.DtqDepAlb[j][i]=ReservarMemoria(&TCar,"CARDTQDEP1");
            sDatosAlb.TemDepAlb[j][i]=ReservarMemoria(&TCar,"CARTEMDEP1");
            sDatosAlb.TamDepAlb[j][i]=ReservarMemoria(&TCar,"CARTANDEP1");
        }
    }
    CerrarTablaBDE(&TCar);

}

//---------------------------------------------------------------------------
// void LiberarEstructura(void)
//
// Descripcion: Liberamos la Memoria Reservada  para la Estructura de Albaran
//
//---------------------------------------------------------------------------
void TAlbaran::LiberarEstructura(void)
{
    BYTE i,j;

    for(i=0;i<NUM_MAXIMO_ALBARANES;i++)
    {
        //Liberamos variable de Cisterna
        LiberarMemoria(sDatosAlb.CodIntCisAlb[i]);
        LiberarMemoria(sDatosAlb.CodNtmCisAlb[i]);
        //Liberamos variable de Tractor
        LiberarMemoria(sDatosAlb.CodIntTraAlb[i]);
        LiberarMemoria(sDatosAlb.CodMatTraAlb[i]);
        //Liberamos variable de Conductor
        LiberarMemoria(sDatosAlb.CodIntConAlb[i]);
        //Liberamos variable de Suministrador
        LiberarMemoria(sDatosAlb.CodSumAlb[i]);
        //Liberamos variable de Cliente
        LiberarMemoria(sDatosAlb.CodCliAlb[i]);
        //Liberamos variable de Destino
        LiberarMemoria(sDatosAlb.CclDesAlb[i]);
        //Liberamos variable de Carga
        LiberarMemoria(sDatosAlb.PenCarAlb[i]);
        LiberarMemoria(sDatosAlb.PsaCarAlb[i]);
        //Liberamos variable de Tranportista
        LiberarMemoria(sDatosAlb.CodTrpAlb[i]);
        //Liberamos variable de Deposito
        for(j=0;j<NUM_MAXIMO_COMPARTIMENTO;j++)
        {
            LiberarMemoria(sDatosAlb.ProDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.TimDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.AdiDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.ConDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.BruDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.NetDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.PesDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.D15DepAlb[j][i]);
            LiberarMemoria(sDatosAlb.DtqDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.TemDepAlb[j][i]);
            LiberarMemoria(sDatosAlb.TamDepAlb[j][i]);
        }
    }
}

//---------------------------------------------------------------------------
// int TAlbaran::Albaran(char *pszCodCisterna,hDBIDb hBaseDatos)
//
// Entrada:
//          char *pszCodCisterna: Codigo de la cisterna a comprobar
//          hDBIDb hBaseDatos: Cabecera de la Base de Datos
//
// Devuelve:
//          int nValorDevuelto: Devuelve un Error si lo hubo
//
// Descripcion:
//          Rellena la Estructura Albaran leyendo de las tablas
//
//---------------------------------------------------------------------------
int TAlbaran::Albaran(char *pszCodCisterna,hDBIDb hBaseDatos)
{
    dbiTabla TCis,TTra,TCon,TSum,TCli,TDes,TCar,TTrp,TExp;
    BYTE i;
    DBIResult Error;
    bool bBorrado;
    char *pszEstado;
    char *pszNtmCis;
    int nValorDevuelto,nNumeroReg;

    //Inicializamos variable
    nValorDevuelto=ALB_CORRECTO;

    //Comprobamos que el estado de las tablas es PESO_SALIDA
    if(!AbrirTablaBDE(&TCar,"SIMICCAR",NULL,true,hBaseDatos))
    {
        nNumeroReg=ComprobarEstado(TCar,pszCodCisterna);
        if(nNumeroReg)
        {
          //Abrimos la tabla TCis
          if(!AbrirTablaBDE(&TCis,"SIMICCIS","CISNTMCIS",false,hBaseDatos))
          {
            //Abrimos la tabla TTra
            if(!AbrirTablaBDE(&TTra,"SIMICTRA","TRAMATTRA",false,hBaseDatos))
            {
              //Abrimos la tabla TCon
              if(!AbrirTablaBDE(&TCon,"SIMICCON","CONNTMCON",false,hBaseDatos))
              {
                //Abrimos la tabla TSum
                if(!AbrirTablaBDE(&TSum,"SIMICSUM","SUMCODSUM",false,hBaseDatos))
                {
                  //Abrimos la tabla TCli
                  if(!AbrirTablaBDE(&TCli,"SIMICCLI","CLICODCLI",false,hBaseDatos))
                  {
                    //Abrimos la tabla de Destino
                    if(!AbrirTablaBDE(&TDes,"SIMICDES","DESCYDDES",false,hBaseDatos))
                    {
                      //Abrimos la Tabla TTrp
                      if(!AbrirTablaBDE(&TTrp,"SIMICTRP","TRPCODTRP",false,hBaseDatos))
                      {
                        //Abrimos la Tabla TTrp
                        if(!AbrirTablaBDE(&TExp,"SIMICEXP","EXPNOMEXP",false,hBaseDatos))
                        {
                          //Pedimos memoria para el Estado
                          pszEstado=ReservarMemoria(&TCar,"CARESTCAR");
                          pszNtmCis=ReservarMemoria(&TCar,"CARNTMCIS");

                          //Inicializamos variables
                          IrPrimerRegBDE(&TCar,&bBorrado);
                          Error=0;
                          i=0;

                          //Mientras no lleguemos al final de la tabla
                          while(!Error)
                          {
                            //Leemos la Cisterna
                            LeerCampoNBDE(&TCar,"CARNTMCIS",pszNtmCis,NULL);
                            //Si son iguales
                            if(!strcmp(pszNtmCis,pszCodCisterna))
                            {
                                //Rellenamos la Estructura de Albaran
                                LeerCampoNBDE(&TCar,"CARPENCAR",sDatosAlb.PenCarAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARPSACAR",sDatosAlb.PsaCarAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARNTMCIS",sDatosAlb.CodNtmCisAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARMATTRA",sDatosAlb.CodMatTraAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARINTCIS",sDatosAlb.CodIntCisAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARINTTRA",sDatosAlb.CodIntTraAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARINTCON",sDatosAlb.CodIntConAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARCODSUM",sDatosAlb.CodSumAlb[i],NULL);
                                LeerCampoNBDE(&TCar,"CARCODTRP",sDatosAlb.CodTrpAlb[i],NULL);
                                LeerCampoNBDE(&TExp,"EXPNOMEXP",sDatosAlb.ExpNomAlb[i],NULL);
                                LeerArrayCampoBDE(&TCar,"CARPRODEP",sDatosAlb.ProDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARTIMDEP",sDatosAlb.TimDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARADIDEP",sDatosAlb.AdiDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARCONDEP",sDatosAlb.ConDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARBRUDEP",sDatosAlb.BruDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARNETDEP",sDatosAlb.NetDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARPESDEP",sDatosAlb.PesDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARD15DEP",sDatosAlb.D15DepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARDTQDEP",sDatosAlb.DtqDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARTEMDEP",sDatosAlb.TemDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);
                                LeerArrayCampoBDE(&TCar,"CARTAMDEP",sDatosAlb.TamDepAlb[i],NUM_MAXIMO_COMPARTIMENTO);

                                //Generamos el albaran
                                GenerarAlbaran(TCar,TTrp,TCis,TTra,TExp,TSum,TDes,TCli,i,hBaseDatos);

                                //Incrementamos el numero del Array
                                i++;
                            }
                          }
                          //Liberamos memoria
                          LiberarMemoria(pszEstado);
                          LiberarMemoria(pszNtmCis);
                        }
                        else
                            nValorDevuelto=ERROR_BDE;
                      }
                      else
                          nValorDevuelto=ERROR_BDE;
                    }
                    else
                        nValorDevuelto=ERROR_BDE;
                  }
                  else
                      nValorDevuelto=ERROR_BDE;
                }
                else
                    nValorDevuelto=ERROR_BDE;
              }
              else
                  nValorDevuelto=ERROR_BDE;
            }
            else
                nValorDevuelto=ERROR_BDE;
          }
          else
            nValorDevuelto=ERROR_BDE;
        }
        else
            nValorDevuelto=ALB_CAR_NO_ENCONTRADA;

        if(CerrarTablaBDE(&TTrp))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TDes))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TCli))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TSum))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TCon))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TTra))
            nValorDevuelto=ERROR_BDE;

        if(CerrarTablaBDE(&TCis))
            nValorDevuelto=ERROR_BDE;
    }
    else
        nValorDevuelto=ERROR_BDE;

    if(nValorDevuelto==ALB_CORRECTO)
    {
        //Marcamos como borrado
        BorrarRegBDE(&TCar);
        //Empaquetamos
        BlanquearRegBDE(&TCar);
    }

    //Cerramos las tablas
    if(CerrarTablaBDE(&TCar))
        nValorDevuelto=ERROR_BDE;

    //Devolvemos variable
    return nValorDevuelto;
}

//---------------------------------------------------------------------------
// int TAlbaran::ComprobarEstado(dbiTabla TCar,char *pszCodCis)
//
// Entrada:
//          char *pszCodCis: Codigo de la cisterna
//          dbiTabla TCAR: cabecera de la tabla SIMICCAR
//
// Salida:
//         int nValorDevuelto: Devuele un Error si lo hubo.
//
// Descripcion: Comprueba el estado de la tabla SIMICCAR
//
//---------------------------------------------------------------------------
int TAlbaran::ComprobarEstado(dbiTabla TCar,char *pszCodCis)
{
    DBIResult Error;
    int nValorDevuelto;
    bool bBorrado;
    char *pszNtmCis;
    char *pszEstado;

    //Inicializamos las variables
    nValorDevuelto=ALB_CORRECTO;
    Error=0;

    //Reservamos memoria para la variable temporal
    pszNtmCis=ReservarMemoria(&TCar,"CARNTMCIS");
    pszEstado=ReservarMemoria(&TCar,"CARESTCAR");

    //Mientras no lleguemos al final
    IrPrimerRegBDE(&TCar,&bBorrado);
    while(!Error)
    {
        if(!bBorrado)
        {
            //Leemos la Cisterna
            LeerCampoNBDE(&TCar,"CARNTMCIS",pszNtmCis,NULL);
            //Vemos si coincide con la que buscamos
            if(!strcmp(pszNtmCis,pszCodCis))
            {
                //Leemos el Estado y comprobamos
                LeerCampoNBDE(&TCar,"CARESTCAR",pszEstado,NULL);
                if(strstr(pszEstado,PESO_SALIDA))
                    nValorDevuelto++;
            }
        }
        Error=IrSiguienteRegBDE(&TCar,&bBorrado);
    }

    //Liberamos memoria
    LiberarMemoria(pszNtmCis);
    LiberarMemoria(pszEstado);

    //Devolvemos el valor
    return nValorDevuelto;
}
/*//---------------------------------------------------------------------------
BYTE TAlbaran::BuscarEnTCar(dbiTabla TCAR,char *pszCodCisterna)
{
    int nValorDevuelto;
    DBIResult Error;
    char *pszCodCisTemp;
    bool bBorrado;

    //Inicializamos variables
    nValorDevuelto=PEE_CISTERNA_SIN_ORDEN;
    Error=0;

    //Pedimos memoria para la variable temporal
    pszCodCisTemp=ReservarMemoria(&TCAR,"CARNTMCIS");

    //mientras no lleguemos al final de la tabla
    while(Error==0 && nValorDevuelto==PEE_CISTERNA_SIN_ORDEN)
    {
        //Si la el codigo de la cisterna coincide vemos su estado
        LeerCampoNBDE(&TCAR,"CARNTMCIS",pszCodCisTemp,NULL);
        if(!strcmp(pszCodCisTemp,pszCodCisterna))
        {
            //Devolmemos cero y almacenamos variables
            nValorDevuelto=0;
            LeerCampoNBDE(&TCAR,"CARCODCLI",sDatosAlb.CodCliAlb[i],NULL);
            LeerCampoNBDE(&TCAR,"CARCCLDES",sDatosAlb.CclDesAlb[i],NULL);
        }
        else
            Error=IrSiguienteRegBDE(&TCAR,&bBorrado);
    }

    //Liberamos memoria
    LiberarMemoria(pszCodCisTemp);

    return nValorDevuelto;
} */
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// void GenerarAlbaran(dbiTabla TCar,dbiTabla TTrp,dbiTabla TCis,dbiTabla TTra,dbiTabla TExp,dbiTabla TSum,dbiTabla TDes,dbiTabla TCli,BYTE i,hDBIDb hBaseDatos)
//
// Entrada:
//          dbiTabla TCar: cabecera de la tabla SIMICCAR
//          dbiTabla TTrp: cabecera de la tabla SIMICTRP
//          dbiTabla TCis: cabecera de la tabla SIMICCIS
//          dbiTabla TTra: cabecera de la tabla SIMICTRA
//          dbiTabla TExp: cabecera de la tabla SIMICEXP
//          dbiTabla TSum: cabecera de la tabla SIMICSUM
//          dbiTabla TDes: cabecera de la tabla SIMICDES
//          dbiTabla TCli: cabecera de la tabla SIMICCLI
//          BYTE i: Numero del albaran
//          hDBIDb hBaseDatos: cabecera de la Base de Datos
//
// Descripcion: Genera el Albaran a partir de su Estructura
//
//---------------------------------------------------------------------------
void TAlbaran::GenerarAlbaran(dbiTabla TCar,dbiTabla TTrp,dbiTabla TCis,dbiTabla TTra,dbiTabla TExp,dbiTabla TSum,dbiTabla TDes,dbiTabla TCli,BYTE i,hDBIDb hBaseDatos)
{
    dbiTabla TAlb;
    DBIResult Error;
    bool bBorrado;
    char *pszValorCampo;
    char szFecha[TAM_FECHA];
    char szHora[TAM_HORA];


    //Capturamos la fecha y la hora actual
    CapturarFechaHora(szFecha,szHora);
    CapturarFechaGen(szFecha);

    //Rellenamos el registro de la tabal SimicAlb
    //Abrimos la tabla de Albaranes
    if(!AbrirTablaBDE(&TAlb,"SIMICALB","ALBNUMALB",false,hBaseDatos))
    {
        //Aņadimos un registro en blanco
        AnadirRegBDE(&TAlb);

        //Pedimos memoria para la variable temporal
        pszValorCampo=ReservarMemoria(&TCar,"CARNTMCIS");
        Error=0;

        //Mientras no lleguemo al final de SIMICCAR
        while(Error==0)
        {
            //Leemos el campo de la Cisterna
            Error=LeerCampoNBDE(&TCar,"CARNTMCIS",pszValorCampo,NULL);
            //Si es el que corresponde
            if(!strcmp(sDatosAlb.CodNtmCisAlb[i],pszValorCampo))
            {
                //Copiamos las variables pertenecientes a TCar
                ModificarCampoNBDE(&TAlb,"ALBFECALB",szFecha);
                ModificarCampoNBDE(&TAlb,"ALBHSAALB",szHora);
                ModificarCampoNBDE(&TAlb,"ALBOPEALB","V");
                CopiarCampo(&TAlb,"ALBHENALB",&TCar,"CARHAUCAR");
                CopiarCampo(&TAlb,"ALBPENALB",&TCar,"CARPENCAR");
                CopiarCampo(&TAlb,"ALBPSAALB",&TCar,"CARPSACAR");
                CopiarCampo(&TAlb,"ALBMATCIS",&TCar,"CARMATCIS");
                CopiarCampo(&TAlb,"ALBCTRCIS",&TCar,"CARCTRCIS");
                CopiarCampo(&TAlb,"ALBNOMCON",&TCar,"CARNOMCON");
                CopiarCampo(&TAlb,"ALBNCACON",&TCar,"CARNCACON");
                CopiarCampo(&TAlb,"ALBMATTRA",&TCar,"CARMATTRA");
                CopiarCampo(&TAlb,"ALBCODTRP",&TCar,"CARCODTRP");
                CopiarCampo(&TAlb,"ALBNOMTRP",&TCar,"CARNOMTRP");
                CopiarCampo(&TAlb,"ALBNUMORC",&TCar,"CARORCCAR");
                CopiarCampo(&TAlb,"ALBPEDORC",&TCar,"CARPEDORC");

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TTrp,sDatosAlb.CodTrpAlb[i],NULL))
                {
                    //Copiamos las variables pertenecientes a TTrp
                    CopiarCampo(&TAlb,"ALBCIFTRP",&TTrp,"TRPCIFTRP");
                    CopiarCampo(&TAlb,"ALBPOSTRP",&TTrp,"TRPPOSTRP");
                    CopiarCampo(&TAlb,"ALBCPATRP",&TTrp,"TRPCPATRP");
                    CopiarCampo(&TAlb,"ALBDIRTRP",&TTrp,"TRPDIRTRP");
                    CopiarCampo(&TAlb,"ALBLOCTRP",&TTrp,"TRPLOCTRP");
                }

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TCis,sDatosAlb.CodNtmCisAlb[i],NULL))
                {
                    //Copiamos las variables pertenecientes a TCis
                    CopiarCampo(&TAlb,"ALBMARCIS",&TCis,"CISMARCIS");
                    CopiarCampo(&TAlb,"ALBCPACIS",&TCis,"CISCPACIS");
                }

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TTra,sDatosAlb.CodMatTraAlb[i],NULL))
                {
                    //Copiamos las variables pertenecientes a TTra
                    CopiarCampo(&TAlb,"ALBMATTRA",&TTra,"TRAMARTRA");
                    CopiarCampo(&TAlb,"ALBCPATRA",&TTra,"TRACPATRA");
                }

                //Copiamos las variables pertenecientes a TExp
                CopiarCampo(&TAlb,"ALBNOMEXP",&TExp,"EXPNOMEXP");
                CopiarCampo(&TAlb,"ALBINSEXP",&TExp,"EXPINSEXP");
                CopiarCampo(&TAlb,"ALBNIFEXP",&TExp,"EXPNIFEXP");
                CopiarCampo(&TAlb,"ALBCAEEXP",&TExp,"EXPCAEEXP");
                CopiarCampo(&TAlb,"ALBDIREXP",&TExp,"EXPDIREXP");
                CopiarCampo(&TAlb,"ALBLOCEXP",&TExp,"EXPLOCEXP");
                CopiarCampo(&TAlb,"ALBPAIEXP",&TExp,"EXPPAIEXP");
                CopiarCampo(&TAlb,"ALBCPAEXP",&TExp,"EXPCPAEXP");
                CopiarCampo(&TAlb,"ALBPOSEXP",&TExp,"EXPPOSEXP");
                CopiarCampo(&TAlb,"ALBTELEXP",&TExp,"EXPTELEXP");

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TSum,sDatosAlb.CodSumAlb[i],NULL))
                {
                    //Copiamos las variables de TSum
                    CopiarCampo(&TAlb,"ALBCODSUM",&TSum,"CARCODSUM");
                    CopiarCampo(&TAlb,"ALBNOMSUM",&TSum,"SUMNOMSUM");
                    CopiarCampo(&TAlb,"ALBNIFSUM",&TSum,"SUMNIFSUM");
                    CopiarCampo(&TAlb,"ALBDIRSUM",&TSum,"SUMDIRSUM");
                    CopiarCampo(&TAlb,"ALBLOCSUM",&TSum,"SUMLOCSUM");
                    CopiarCampo(&TAlb,"ALBDOCSUM",&TSum,"SUMDOCSUM");
                }

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TDes,sDatosAlb.CclDesAlb[i],NULL))
                {
                    //Copiamos las variables de TDes
                    CopiarCampo(&TAlb,"ALBCCLDES",&TDes,"CARCCLDES");
                    CopiarCampo(&TAlb,"ALBNOMDES",&TDes,"DESNOMDES");
                    CopiarCampo(&TAlb,"ALBCAEDES",&TDes,"DESCAEDES");
                    CopiarCampo(&TAlb,"ALBDIRDES",&TDes,"DESDIRDES");
                    CopiarCampo(&TAlb,"ALBLOCDES",&TDes,"DESLOCDES");
                    CopiarCampo(&TAlb,"ALBPOSDES",&TDes,"DESPOSDES");
                    CopiarCampo(&TAlb,"ALBPAIDES",&TDes,"DESPAIDES");
                    CopiarCampo(&TAlb,"ALBDURDES",&TDes,"DESDURDES");
                    CopiarCampo(&TAlb,"ALBTELDES",&TDes,"DESTELDES");
                    CopiarCampo(&TAlb,"ALBEMBDES",&TDes,"DESEMBDES");
                    CopiarCampo(&TAlb,"ALBAVIDES",&TDes,"DESAVIDES");
                    CopiarCampo(&TAlb,"ALBCADDES",&TDes,"DESCADDES");
                    CopiarCampo(&TAlb,"ALBCPADES",&TDes,"DESCPADES");
                    CopiarCampo(&TAlb,"ALBNADDES",&TDes,"DESNADDES");
                }

                //Buscamo el valor del codigo
                if(!BuscarValorExactoBDE(&TCli,sDatosAlb.CodCliAlb[i],NULL))
                {
                    //Copiamos Las variables de TCli
                    CopiarCampo(&TAlb,"ALBNOMCLI",&TCli,"CLINOMCLI");
                    CopiarCampo(&TAlb,"ALBNIFCLI",&TCli,"CLICIFCLI");
                    CopiarCampo(&TAlb,"ALBDIRCLI",&TCli,"CLIDIRCLI");
                    CopiarCampo(&TAlb,"ALBLOCCLI",&TCli,"CLILOCCLI");
                    CopiarCampo(&TAlb,"ALBPOSCLI",&TCli,"CLIPOSCLI");
                    CopiarCampo(&TAlb,"ALBPAICLI",&TCli,"CLIPAICLI");
                    CopiarCampo(&TAlb,"ALBCPACLI",&TCli,"CLICPACLI");
                }
            }
            Error=IrSiguienteRegBDE(&TCar,&bBorrado);
        }

        //Liberamos memoria temporal
        LiberarMemoria(pszValorCampo);
    }
    //Cerramos la tabla
    CerrarTablaBDE(&TAlb);
}


//---------------------------------------------------------------------------
//                          Rutinas Generales
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  void Copia (char *pszDest,char *pszOrig,int nTamano)
//  Descripcion: Copia una cadena en otra
//---------------------------------------------------------------------------
void Copia (char *pszDest,char *pszOrig,int nTamano)
{
  strncpy (pszDest,pszOrig,nTamano);
  *(pszDest+nTamano-1) = 0;
}

//---------------------------------------------------------------------------
// void Formatea (char *pszStrDest,int nTamano,char *pszFormato,...)
// Descripcion: Formatea una cadena como se le indique
//---------------------------------------------------------------------------
void Formatea (char *pszStrDest,int nTamano,char *pszFormato,...)
{
  va_list pvVar;
  char szDes [255];

  va_start (pvVar,pszFormato);
  vsprintf (szDes,pszFormato,pvVar);
  va_end (pvVar);

  Copia(pszStrDest,szDes,nTamano);
}

//---------------------------------------------------------------------------
// void ActualizaEstadoGen(char *Cis,char *Tra,char *Con,char *pszEstado,hDBIDb hBaseDatos)
//
// Entrada:
//          char *Cis: Codigo de la Cisterna
//          char *Tra: Codigo del tractor
//          char *Con: Codigo del conductor
//          char *pszEstado: Estado a poner
//          hDBIDb hBaseDatos: cabecera de la Base de Datos
//
// Descripcion: Actualiza el estado de las tablas:
//              dbiTabla TCisterna,TTractor,TConductor,TOrden;
//
//---------------------------------------------------------------------------
void ActualizaEstadoGen(char *Cis,char *Tra,char *Con,char *pszEstado,hDBIDb hBaseDatos)
{
    dbiTabla TCisterna,TTractor,TConductor;

    DatosAutorizacion sDatos;

    Autorizacion->LeerEstructura(&sDatos);
    //Abrimos la tabla de Cisterna y actualizamos
    if(!AbrirTablaBDE(&TCisterna,"SIMICCIS","CISNTMCIS",false,hBaseDatos))
    {
        //Busca cadena de entrada y Modificamos el campo
        if(!BuscarValorExactoBDE(&TCisterna,Cis,NULL))
            ModificarCampoNBDE(&TCisterna,"CARESTCAR",pszEstado);
    }
    //Cerramos la tabla
    if(CerrarTablaBDE(&TCisterna))
        ShowMessage("Hubo un error");

    //Abrimos la tabla de Tractor si la cisterna no es un camion y actualizamos
    if( (*sDatos.pszCamionCis) != 'F' )
    {
        if(!AbrirTablaBDE(&TTractor,"SIMICTRA","TRAMATTRA",false,hBaseDatos))
        {
            //Busca cadena de entrada y Modificamos el campo
            if(!BuscarValorExactoBDE(&TTractor,Tra,NULL))
                ModificarCampoNBDE(&TTractor,"TRAESTTRA",pszEstado);
        }
        //Cerramos la tabla
        if(CerrarTablaBDE(&TTractor))
            ShowMessage("Hubo un error");
    }

    //Abrimos la tabla de Conductor y actualizamos
    if(!AbrirTablaBDE(&TConductor,"SIMICCON","CONNTMCON",false,hBaseDatos))
    {
        //Busca cadena de entrada y Modificamos el campo
        if(!BuscarValorExactoBDE(&TConductor,Con,NULL))
            ModificarCampoNBDE(&TConductor,"CONESTCON",pszEstado);
    }
    //Cerramos la tabla
     if(CerrarTablaBDE(&TConductor))
        ShowMessage("Hubo un error");
}

//---------------------------------------------------------------------------
// void CapturarFechaGen(char *pszFechaActual);
//
// Entrada:
//              Fechaactual: Variable donde pondremos la fecha actual
//
// Descripcion: Captura la fecha actual con este formato YYYYMMDD
//              Donde Y=aņo M=Mes D=Dia.
//---------------------------------------------------------------------------
void CapturarFechaGen(char *pszFechaActual)
{
    char szFecha[TAM_FECHA];
    char szHora[TAM_HORA];

    CapturarFechaHora(szFecha,szHora);
    memcpy(pszFechaActual,szFecha+6,4);
    memcpy(pszFechaActual+4,szFecha+3,2);
    memcpy(pszFechaActual+6,szFecha,2);
}

//---------------------------------------------------------------------------
//  class TTransfer
//  {
//    protected:
//    private:	// User declarations
//          ELEDat sELEDat;
//          DRVDat sDRVDat;
//          TRAPERDat sTRAPERDat[NUM_MAX_PER];
//          TRAOCADat sTRAOCADat;
//    public:
//          TTransfer(void);
//          int RellenarEstructuraTransfer(void);
//          void LeerEstructura(TRAPERDat *pTRAPERDat,TRAOCADat *pTRAOCADat);
//          void InicializarEstructuraTransfer(void);
//  };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Constructor de la clase
//---------------------------------------------------------------------------

TTransfer::TTransfer(void)
{
}

//---------------------------------------------------------------------------
//  int RellenarEstructuraTransfer(void)
//
//  Devuelve: Codigo de Error
//
//  Descripcion: Rellena la Estructura del fichero transfer
//
//---------------------------------------------------------------------------

int TTransfer::RellenarEstructuraTransfer(void)
{
    FILE *pElemento,*pDriver;
    BYTE byNumPer,byi;
    bool bEncontrado;
    int  nValorDevuelto;

    //Inicializamos las variables
    for(byi=0;byi<NUM_MAXIMO_ELEMENTOS;byi++)
        sTRAPERDat[byi].lPosicionTRAPER=-1;
    nValorDevuelto=TRANSFER_CORRECTO;
    byNumPer=0;

    //Abrimos el fichero elemento.dat
    if( ( pElemento = fopen("elemento.dat", "rb") ) == NULL)
            nValorDevuelto=ERROR_ABRIR_FICHERO_ELEMENTO;
    else
    {
        if( ( pDriver = fopen("drivers.dat", "rb") ) == NULL)
                nValorDevuelto=ERROR_ABRIR_FICHERO_DRIVERS;
        else
        {
            //Mientras no lleguemos al final del fichero
            while(!feof(pElemento) && nValorDevuelto==TRANSFER_CORRECTO)
            {
                //Leemos la estructura
                fread(&sELEDat, sizeof(sELEDat), 1, pElemento);

                //Ponemos el Fin de cadena
                sELEDat.cNumeroLineaELE[2]=0;
                sELEDat.cTipoELE[3]=0;
                sELEDat.cIdentificaELE[3]=0;
                sELEDat.cNombreDriverELE[6]=0;
                sELEDat.cTimeOutComunicaELE[3]=0;
                sELEDat.cDireccionELE[3]=0;

                bEncontrado=false;

                //Nos situamos al principio del fichero
                fseek(pDriver, 0L, SEEK_SET);

                //Buscamos en drivers.dat el elemento
                while(!feof(pDriver) && !bEncontrado)
                {
                    //Leemos la estructura
                    fread(&sDRVDat, sizeof(sDRVDat), 1, pDriver);

                    //Ponemos el Fin de cadena
                    sDRVDat.cNombreDriverDRV[6]=0;
                    sDRVDat.cTamBufferTraDRV[4]=0;
                    sDRVDat.cTamBufferRecDRV[4]=0;
                    sDRVDat.cTamPeriodicaDRV[4]=0;

                    if(!strcmp(sELEDat.cNombreDriverELE,sDRVDat.cNombreDriverDRV))
                        bEncontrado=true;
                }
                if(bEncontrado)
                {
                    //Copiamos el Tamaņo de la periodica
                    sTRAPERDat[byNumPer].lTamPeriodicaTRAPERDat=atol(sDRVDat.cTamPeriodicaDRV);

                    //Rellenamos estructura tranfers
                    if(byNumPer)
                        sTRAPERDat[byNumPer].lPosicionTRAPER=sTRAPERDat[byNumPer-1].lPosicionTRAPER+sTRAPERDat[byNumPer-1].lTamPeriodicaTRAPERDat;
                    else
                        sTRAPERDat[byNumPer].lPosicionTRAPER=0;

                    //Copiamos el servidor que tiene asociado
                    sTRAPERDat[byNumPer].cServidor=sELEDat.cConcentradorELE;

                    //Copiamos el tipo del elemento y su identificacion
                    strcpy(sTRAPERDat[byNumPer].cTipoIDTRAPER,sELEDat.cTipoELE);
                    StrCat(sTRAPERDat[byNumPer].cTipoIDTRAPER,sELEDat.cIdentificaELE);

                    byNumPer++;
                }
                else
                    nValorDevuelto=DRIVER_NO_ENCONTRADO;
            }
            //Guardamos el inicio de las Ocasionales
            sTRAOCADat.lPosicionTRAOCA=sTRAPERDat[byNumPer-1].lPosicionTRAPER;
        }
        fclose(pDriver);
    }
    fclose(pElemento);

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
//  void TTransfer::InicializarEstructuraTransfer(void)
//
//  Descripcion: Inicializa la Estructura del Transfer
//
//---------------------------------------------------------------------------

void TTransfer::InicializarEstructuraTransfer(void)
{
    BYTE byi,byj;

    for(byi=0;byi<NUM_MAXIMO_PERIODICA;byi++)
    {
        sTRAPERDat[byi].lPosicionTRAPER=0;
        for(byj=0;byj<6;byj++)
            sTRAPERDat[byi].cTipoIDTRAPER[byj]=0;
    }

}

//---------------------------------------------------------------------------
//  void TTransfer::LeerEstructura(TRAPERDat *pTRAPERDat,TRAOCADat *pTRAOCADat)
//
//  Entrada:
//          TRAPERDat *pTRAPERDat: Estructura de Periodica
//          TRAOCADat *pTRAOCADat: Estructura de Ocasional
//
//  Descripcion: Copia la estructura que hay en memoria de la periodica
//               y la ocasional, en el destino indicado.
//---------------------------------------------------------------------------

void TTransfer::LeerEstructura(TRAPERDat *pTRAPERDat,TRAOCADat *pTRAOCADat)
{
    memcpy(pTRAPERDat,&sTRAPERDat,sizeof(sTRAPERDat));
    memcpy(pTRAOCADat,&sTRAOCADat,sizeof(sTRAOCADat));
}

//---------------------------------------------------------------------------
// int TTransfer::EscribirOcasional(char cServidor,char sElemento[6], char sOrden[3],char cReferencia,char sNumCaracter[3],char sTexto[32],BYTE byNumOcasional)
//
//  Entrada:
//          char cServidor: Numero del Servidor.
//          char sElemento[6]: Nombre del elemento[ TIPO + IDENTIFICACION ].
//          char sOrden[3]: Si por tarjeta o teclado.
//          char cReferencia: Caracter de Referencia.
//          char sNumCaracter[3]: Numero de Caracteres del Texto.
//          char sTexto[32]: Mensaje a mostrar.
//          BYTE byNumOcasional: Numero de la Ocasional a tratar.
//
//  Devuelve:
//          Codigo de Error
//---------------------------------------------------------------------------

int TTransfer::EscribirOcasional(char *sSentencia,BYTE byNumOcasional)
{
    FILE *pTransfer;
    long lDesplazamiento;
    int nValorDevuelto;

    //Inicializamos variables
    byNumOcasional--;
    nValorDevuelto=TRANSFER_CORRECTO;
    lDesplazamiento=0;

    //Abrimos el fichero en modo escritura
    if( ( pTransfer = fopen("transfer.dat", "r+b") ) == NULL)
            nValorDevuelto=ERROR_ABRIR_FICHERO_TRANSFER;
    else
    {
        //Calculamos el lugar para situar el texto
        lDesplazamiento=sTRAOCADat.lPosicionTRAOCA+(byNumOcasional*TAM_MAXIMO_OCASIONAL);
        //Nos situamos al principio del fichero
        fseek(pTransfer, 0L, SEEK_SET);
        //Nos desplazamos hasta el lugar indicado
        fseek(pTransfer, lDesplazamiento, SEEK_SET);
        //Escribimos el comentario
        fwrite(sSentencia,TAM_MAXIMO_OCASIONAL,1,pTransfer);
    }
    //Cerramos el fichero
    fclose(pTransfer);

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
//  int TTransfer::LeerOcasional(char *Texto,BYTE byNumOcasional)
//
//  Entrada:
//          char *Texto: Respuesta de las ocasionales.
//          BYTE byNumOcasional: Numero de la Ocasional a tratar.
//
//  Salida:
//          Codigo de Error.
//
//---------------------------------------------------------------------------

int TTransfer::LeerOcasional(char *Texto,BYTE byNumOcasional)
{
    FILE *pTransfer;
    BYTE byCero;
    long lDesplazamiento;
    int nValorDevuelto;

    //Inicializamos variables
    byNumOcasional--;
    byCero=0;
    nValorDevuelto=TRANSFER_CORRECTO;
    lDesplazamiento=0;

    //Abrimos el fichero en modo escritura
    if( ( pTransfer = fopen("transfer.dat", "r+b") ) == NULL)
            nValorDevuelto=ERROR_ABRIR_FICHERO_TRANSFER;
    else
    {
        //Calculamos el lugar para situar el texto
        lDesplazamiento=(sTRAOCADat.lPosicionTRAOCA)+(NUM_MAXIMO_OCASIONAL*TAM_MAXIMO_OCASIONAL)+(byNumOcasional*TAM_MAXIMO_OCASIONAL);
        //Nos situamos al principio del fichero
        fseek(pTransfer, 0L, SEEK_SET);
        //Nos desplazamos hasta el lugar indicado
        fseek(pTransfer, lDesplazamiento, SEEK_SET);
        //Leemos la respuesta
        fread(Texto,TAM_MAXIMO_OCASIONAL,1,pTransfer);
        //Nos situamos al principio de la respuesta
        fseek(pTransfer, lDesplazamiento, SEEK_SET);
        //Escribimos un cero para saber que ya la hemos leido
        fwrite(&byCero,1,1,pTransfer);
    }
    //Cerramos el fichero
    fclose(pTransfer);

    return nValorDevuelto;
}

//---------------------------------------------------------------------------
bool TTransfer::LeerFichero(char *NombreFichero,char *NombreEstructura)
{
    bool bCorrecto;
    FILE *fichero;
    LINDat sLINDat;
    ELEDat sELEDat;
    DRVDat sDRVDat;

    bCorrecto=true;
    //Abrimos le fichero en modo lectura
    if( ( fichero = fopen(NombreFichero, "rb") ) == NULL)
        bCorrecto=false;
    else
    {
        if(!strcmp(NombreEstructura,"LINDat"))
        {
            while (!feof(fichero))
            {
                //Leemos la estructura
                fread(&sLINDat, sizeof(sLINDat), 1, fichero);

                //Ponemos el Fin de cadena
                sLINDat.cNumeroLineaLIN[2]=0;
                sLINDat.cVelocidadLineaLIN[5]=0;

            }
        }
        if(!strcmp(NombreEstructura,"ELEDat"))
        {
            while (!feof(fichero))
            {
                //Leemos la estructura
                fread(&sELEDat, sizeof(sELEDat), 1, fichero);

                //Ponemos el Fin de cadena
                sELEDat.cNumeroLineaELE[2]=0;
                sELEDat.cTipoELE[3]=0;
                sELEDat.cIdentificaELE[3]=0;
                sELEDat.cNombreDriverELE[6]=0;
                sELEDat.cTimeOutComunicaELE[3]=0;
                sELEDat.cDireccionELE[3]=0;

            }
        }
        if(!strcmp(NombreEstructura,"DRVDat"))
        {
            while (!feof(fichero))
            {
                //Leemos la estructura
                fread(&sDRVDat, sizeof(sDRVDat)+1, 1, fichero);

                //Ponemos el Fin de cadena
                sDRVDat.cNombreDriverDRV[6]=0;
                sDRVDat.cTamBufferTraDRV[4]=0;
                sDRVDat.cTamBufferRecDRV[4]=0;
                sDRVDat.cTamPeriodicaDRV[4]=0;

            }
        }
    }
    fclose(fichero);

    return bCorrecto;
}
//---------------------------------------------------------------------------