3284 lines
126 KiB
C++
3284 lines
126 KiB
C++
//---------------------------------------------------------------------------
|
||
#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<6D>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;
|
||
}
|
||
//---------------------------------------------------------------------------
|