DBEstadistica.pc

// DBEstadistica.cpp: implementation of the CDBEstadistica class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "tpc.h"
#include "DBEstadistica.h"
#include "Agv.h"
#include "Orden.h"
#include "macro.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////

// The ORACA=YES option must be specified to enable use of the ORACA
EXEC ORACLE OPTION (ORACA=YES);



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDBEstadistica::CDBEstadistica()
{

}

CDBEstadistica::~CDBEstadistica()
{

}

// Grabar o marcar final de un error de Agv
void CDBEstadistica::LogError(CAgv * ptrAgv, UINT nErr, bool fFin, bool fAbort)
{
	T_sqlca sqlca;	// This is static
	T_oraca oraca;
	oraca.orastxtf = ORASTFERR;
	sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
	EXEC SQL CONTEXT USE :*ptrCtx;
 
	EXEC SQL BEGIN DECLARE SECTION;
	
	 int dbNagv;
	 int dbNummod;
	 int dbNumerr;
	 int dbMp;
	 int dbNmp;
	 int dbWegstr;
	 int dbPosdes;
	 char dbLadodes;
	 int dbPtocomdes;
	 char dbTipfin;
	 int dbCodord;

	EXEC SQL END DECLARE SECTION;

	dbNagv = ptrAgv->m_id;
	dbNummod = ptrAgv->m_pFzdat->errofz[nErr].modul_nr;
	dbNumerr = ptrAgv->m_pFzdat->errofz[nErr].fehler_nr;

	
	EXEC SQL WHENEVER SQLERROR GOTO LogErrorSqlError;
	EXEC SQL WHENEVER NOTFOUND CONTINUE;

	if (ptrAgv->m_pOrden)
		dbCodord = atoi ((char *)ptrAgv->m_pOrden->m_at.id_nr); // Any chance of this failing ?
	else
		dbCodord = 0;

	if (!fFin)
	{
		// Aparece el error
		dbMp = ptrAgv->m_pFzdat->mp;
		dbNmp = ptrAgv->m_pFzdat->nmp;
		dbWegstr = ptrAgv->m_pFzdat->wegstr;
		dbPtocomdes = ptrAgv->m_pFzdat->auftziel.nDest;
		dbPosdes = ptrAgv->m_pFzdat->auftziel.nPos;
		dbLadodes = ptrAgv->m_pFzdat->auftziel.ucSide;

		EXEC SQL INSERT INTO ERRAGV 
			(ERRID,      
			 NAGV,      
			 NUMMOD,    
			 NUMERR,    
			 MP,        
			 NMP,       
			 WEGSTR,    
			 PTOCOMDES, 
			 POSDES,    
			 LADODES,   
			 FECCRE,    
			 FECFIN,    
			 TIPFIN,    
			 CODORD)
			SELECT
			ERRAGV_SEQ.NEXTVAL,
			:dbNagv,
			:dbNummod,
			:dbNumerr,
			:dbMp,
			:dbNmp,
			:dbWegstr,
			:dbPtocomdes,
			:dbPosdes,
			:dbLadodes,
			sysdate,
			null,
			'C',	-- En curso
			:dbCodord
			FROM DUAL;

			if (dbCodord)
			{
				// Marcar la orden en error
				EXEC SQL UPDATE ordtran
				SET ERRORD = 'S'
				WHERE CODORD = :dbCodord;
			}
	}
	else
	{
		dbTipfin = fAbort ? 'R' : 'N';

		EXEC SQL UPDATE ERRAGV
			SET FECFIN = sysdate,
			TIPFIN = :dbTipfin
			WHERE NAGV = :dbNagv
			AND NUMMOD = :dbNummod
			AND NUMERR = :dbNumerr
			AND TIPFIN = 'C';

			if (dbCodord)
			{
				// Quitar el error de la orden
				EXEC SQL UPDATE ordtran
				SET ERRORD = 'N'
				WHERE CODORD = :dbCodord;
			}


	}

	EXEC SQL COMMIT;

	return;

LogErrorSqlError:
	MSGERROR4 ("Imposible %s log de errores para Agv: %d NumMod: %d NumErr: %d",
		fFin ? "actualizar" : "insertar",
		dbNagv,
		dbNummod,
		dbNumerr);

	return;
}

// Inserta un registro en el histórico de AGVs
void CDBEstadistica::ArchivarHistAgv(CAgv * ptrAgv)
{
	TRY
	{
		int iArchivarHistAgv = AfxGetApp ()->GetProfileInt ("Settings", "ArchivarHistAgv", -1);
		if (iArchivarHistAgv == -1)
		{
			AfxGetApp ()->WriteProfileInt ("Settings", "ArchivarHistAgv", 0);
		}
		
		if (iArchivarHistAgv == 1)
		{	
			T_sqlca sqlca;	// This is static
			T_oraca oraca;
			oraca.orastxtf = ORASTFERR;
			sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
			EXEC SQL CONTEXT USE :*ptrCtx;
		 
			EXEC SQL BEGIN DECLARE SECTION;
			
			int dbNagv;
			int dbEstado;
			char * dbBlockTraffic;
			char * dbBlockBub;
			char * dbEnCircuito;
			int dbMp;
			int dbNmp;
			int dbDestino;
			int dbCodord;
			char * dbMesa1;
			char * dbMesa2;
			char * dbCaminoAlt;
			int dbTiempo;

			EXEC SQL END DECLARE SECTION;

			EXEC SQL WHENEVER SQLERROR GOTO ArchivarHistAgvSqlError;
			EXEC SQL WHENEVER NOTFOUND CONTINUE;

			dbNagv = ptrAgv->m_id;
			dbEstado = ptrAgv->GetEstado();
			dbBlockTraffic = (ptrAgv->IsBlocked() ? "S" : "N");
			dbBlockBub = (ptrAgv->IsDriveForbiddenByBuB() ? "S" : "N");
			dbEnCircuito = (ptrAgv->IsEnCircuito() ? "S": "N");
			dbMp = ptrAgv->m_pFzdat->mp;
			dbNmp = ptrAgv->m_pFzdat->nmp;
			dbDestino = ptrAgv->m_pFzdat->auftziel.nDest;
			if (ptrAgv->m_pOrden)
				dbCodord = atoi ((char *)ptrAgv->m_pOrden->m_at.id_nr); // Any chance of this failing ?
			else
				dbCodord = 0;
			dbMesa1 = (MESA1CARGADA (*ptrAgv->m_pFzdat) ? "S" : "N");
			dbMesa2 = (MESA2CARGADA (*ptrAgv->m_pFzdat) ? "S" : "N");
			dbCaminoAlt = (ptrAgv->CaminoAltActivado() ? "S" : "N");
			if (ptrAgv->tiempo != NULL)
			{
				CTimeSpan elapsedTime = CTime::GetCurrentTime() - ptrAgv->tiempo;
				dbTiempo = (int)((long)elapsedTime.GetTotalSeconds());
			}
			else
				dbTiempo = 0;
			EXEC SQL INSERT INTO HISTAGV 
				(REGID,      
					AGV,      
					ESTADO,    
					BLOCKTRAFFIC,    
					BLOCKBUB,
					ENCIRCUITO,
					MP,        
					NMP,       
					DESTINO,    
					ORDEN, 
					MESA1,    
					MESA2,   
					FECREG,    
					CAMINOALT,    
					TIEMPO)
				SELECT
				HISTAGV_SEQ.NEXTVAL,
				:dbNagv,
				:dbEstado,
				:dbBlockTraffic,
				:dbBlockBub,
				:dbEnCircuito,
				:dbMp,
				:dbNmp,
				:dbDestino,
				:dbCodord,
				:dbMesa1,
				:dbMesa2,
				sysdate,
				:dbCaminoAlt,
				:dbTiempo
				FROM DUAL;

			EXEC SQL COMMIT;
			ptrAgv->tiempo = CTime::GetCurrentTime ();

			return;

		ArchivarHistAgvSqlError:
			MSGERROR1 ("Imposible insertar archivo historico para Agv: %d",
				dbNagv);

			return;
	}
	}
	CATCH(CException, ex)
	{	
		ex->ReportError();
	}
	END_CATCH
}

	// Inserta un registro en el histórico de AGVs
void CDBEstadistica::GetLastPositionAGV(CAgv * ptrAgv)
{
	TRY
	{

			T_sqlca sqlca;	// This is static
			T_oraca oraca;
			oraca.orastxtf = ORASTFERR;
			sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
			EXEC SQL CONTEXT USE :*ptrCtx;
		 
			EXEC SQL BEGIN DECLARE SECTION;
			
			int dbNagv;
			int dbEstado;
			char * dbBlockTraffic;
			char * dbBlockBub;
			char * dbEnCircuito;
			int dbMp;
			int dbNmp;
			int dbDestino;
			int dbCodord;
			char * dbMesa1;
			char * dbMesa2;
			char * dbCaminoAlt;
			int dbTiempo;


			short idbEstado;
			short idbBlockTraffic;
			short idbBlockBub;
			short idbEnCircuito;
			short idbMp;
			short idbNmp;
			short idbDestino;
			short idbCodord;
			short idbMesa1;
			short idbMesa2;
			short idbCaminoAlt;
			short idbTiempo;



			EXEC SQL END DECLARE SECTION;

			dbBlockTraffic = NULL;
			dbBlockBub = NULL;
			dbEnCircuito = NULL;
			dbMesa1 = NULL;
			dbMesa2 = NULL;
			dbCaminoAlt = NULL;




			EXEC SQL WHENEVER SQLERROR GOTO GetLastPositionAGV;
			EXEC SQL WHENEVER NOTFOUND CONTINUE;

			dbNagv = ptrAgv->m_id;

			EXEC SQL DECLARE CURLASTPOSAGV CURSOR FOR
				SELECT ESTADO,
				  BLOCKTRAFFIC,
				  BLOCKBUB,
				  ENCIRCUITO,
				  MP,
				  NMP,
				  DESTINO,
				  ORDEN,
				  MESA1,
				  MESA2
				 FROM HISTAGV
				WHERE REGID = (select max(h1.REGID) from histagv h1 where h1.agv = :dbNagv);
			
			
			EXEC SQL OPEN CURLASTPOSAGV;

			EXEC SQL FETCH CURLASTPOSAGV INTO 
				:dbEstado:idbEstado,
				:dbBlockTraffic:idbBlockTraffic,
				:dbBlockBub:idbBlockBub,
				:dbEnCircuito:idbEnCircuito,
				:dbMp:idbMp,
				:dbNmp:idbNmp,
				:dbDestino:idbDestino,
				:dbCodord:idbCodord,
				:dbMesa1:idbMesa1,
				:dbMesa2:idbMesa2;
				
			EXEC SQL CLOSE CURLASTPOSAGV;

			ptrAgv->SetEstado((TEstadoAGV)dbEstado);
			if (idbBlockTraffic == 0) {
				ptrAgv->SetBlocked (dbBlockTraffic[0] == 'S' ? true : false);
			}
			if (idbBlockBub == 0) {
				ptrAgv->SetBubBlocked (dbBlockBub[0] == 'S' ? 1 : 0);
			}
			if (idbEnCircuito == 0) {
				ptrAgv->SetEnCircuitoInit (dbEnCircuito[0] == 'S' ? true : false);
			}
				ptrAgv->m_pFzdat->mp = dbMp;
			ptrAgv->m_pFzdat->nmp = dbNmp;
			ptrAgv->m_pFzdat->auftziel.nDest = dbDestino;
			
			/*
			if (ptrAgv->m_pOrden)
				dbCodord = atoi ((char *)ptrAgv->m_pOrden->m_at.id_nr); // Any chance of this failing ?
			else
				dbCodord = 0;
				
			How to get the order back !!! TODO */
			
			bool mesa1 = false;
			if (idbMesa1 == 0)
				mesa1 = dbMesa1[0] == 'S' ? true : false;
			bool mesa2 = false;
			if (idbMesa2 == 0)
				mesa2 = dbMesa2[0] == 'S' ? true : false;		
			ptrAgv->SimulateCargada(mesa1, mesa2);

			MSGTRACE3 ("GetLastPosiciónAGV agv:%d mp:%d nmp:%d", dbMp, dbNmp, ptrAgv->m_id);
			SET_FZ_IN_SYSTEM(*(ptrAgv->m_pFzdat));
			return;

		GetLastPositionAGV:
			MSGERROR1 ("Imposible recuperar última posición para Agv: %d",
				dbNagv);

			return;

	}
	CATCH(CException, ex)
	{	
		ex->ReportError();
	}
	END_CATCH
}


// Mover órdenes de transporte al histórico
void CDBEstadistica::ArchivarOrdTran()
{
	sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
	EXEC SQL CONTEXT USE :*ptrCtx;
 
 	T_sqlca sqlca;	// This is static
	T_oraca oraca;
	oraca.orastxtf = ORASTFERR;
	// EXEC SQL WHENEVER SQLERROR GOTO ArchivarOrdTranError;
	EXEC SQL WHENEVER SQLERROR DO plsql_error("CDBEstadistica::ArchivarOrdTran-> ", sqlca, oraca);
	EXEC SQL WHENEVER NOTFOUND CONTINUE;

	EXEC SQL EXECUTE
	begin
		map.ArchivarHistOrdTran;
	end;
	END-EXEC;
	// El commit es realizado por el procedure


	return;
	
//ArchivarOrdTranError:
//	MSGERROR ("Error al archivar Ordenes de Transporte");

	return;
}


// Grabar o quitar un defecto
void CDBEstadistica::LogDefecto(UINT nZona, UINT nIndMesa, UINT nBit, bool fFin, bool fAbort)
{
	sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
	EXEC SQL CONTEXT USE :*ptrCtx;
 	T_sqlca sqlca;	// This is static
	T_oraca oraca;
	oraca.orastxtf = ORASTFERR;
	EXEC SQL BEGIN DECLARE SECTION;
	
	int dbZona;
	int dbInd;
	int dbBit;
	char dbTipFin;

	EXEC SQL END DECLARE SECTION;

	dbZona = nZona;
	dbInd = nIndMesa;
	dbBit = nBit;

    EXEC SQL WHENEVER SQLERROR DO plsql_error("LogDefecto: ", sqlca, oraca);
	EXEC SQL WHENEVER NOTFOUND CONTINUE;

	if (fFin)
	{
		if (fAbort)
			dbTipFin = 'R';
		else
			dbTipFin = 'N';

		EXEC SQL UPDATE DEFECTO
			SET fecfin = sysdate,
				tipfin = :dbTipFin
			WHERE ZONA = :dbZona
			AND IND = :dbInd
			AND BIT = :dbBit
			AND TIPFIN = 'C';
		
	}
	else
		{
		dbTipFin = 'C';	// En curso
		EXEC SQL INSERT INTO DEFECTO 
			(ZONA,
			IND, 	
			BIT,
			FECCRE,
			FECFIN, 	
			TIPFIN)
		SELECT
			:dbZona,
			:dbInd,
			:dbBit,
			sysdate,
			null,
			:dbTipFin
			FROM dual;
		}
	
	EXEC SQL COMMIT;

}


bool CDBEstadistica::GetStringsDefecto(UINT nZona, UINT nIndMesa, UINT nBit, LPTSTR strCodMes, LPTSTR strCodClInd, LPTSTR strDefecto)
{
	sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
	EXEC SQL CONTEXT USE :*ptrCtx;
 	T_sqlca sqlca;	// This is static
	T_oraca oraca;
	oraca.orastxtf = ORASTFERR;
    EXEC SQL WHENEVER SQLERROR DO plsql_error("GetStringsDefecto: ", sqlca, oraca);
	EXEC SQL WHENEVER NOTFOUND GOTO GetStringsDefectoNotFound;

	bool fRetVal = false;

	EXEC SQL BEGIN DECLARE SECTION;

	
	char * dbCodClInd;
	int dbZona;
	int dbInd;
	char * dbCodMes;
	char * dbTexto;
	int dbBit;

	short idbCodClInd = -1;
	short idbCodMes = -1;
	short idbTexto = -1;


	EXEC SQL END DECLARE SECTION;



	dbZona = nZona;
	dbInd = nIndMesa;
	dbBit = nBit;
	dbCodClInd = strCodClInd;

	dbCodMes = strCodMes;
	dbTexto = strDefecto;

	EXEC SQL DECLARE CURDEF CURSOR FOR
		SELECT CODCLIND,
				CODMES,
				TEXTO
		FROM DEFMESA, DEFTEXT
		WHERE DEFMESA.ZONA = :dbZona
		AND DEFMESA.IND = :dbInd
		AND DEFTEXT.BIT = :dbBit;

	EXEC SQL OPEN CURDEF;

	EXEC SQL FETCH CURDEF INTO 
		:dbCodClInd:idbCodClInd,
		:dbCodMes:idbCodMes,
		:dbTexto:idbTexto;

	fRetVal = true;

GetStringsDefectoNotFound:

	EXEC SQL CLOSE CURDEF;
	
	return (fRetVal);
}



void CDBEstadistica::BorrarHistoricos()
{
	sql_context * ptrCtx = (sql_context *)g_Container.m_dbutil.GetOraContext ();
	EXEC SQL CONTEXT USE :*ptrCtx;
 	T_sqlca sqlca;	// This is static
	T_oraca oraca;
	oraca.orastxtf = ORASTFERR;
	EXEC SQL WHENEVER SQLERROR DO plsql_error("CDBEstadistica::BorrarHistoricos-> ", sqlca, oraca);
	EXEC SQL WHENEVER NOTFOUND CONTINUE;
	
	MSGTRACE ("BorrarHistoricos");
	
	EXEC SQL EXECUTE
	begin
		map.BorrarHistoricos;		
	end;
	END-EXEC;


}