#include <iostream>

#include <fstream>
#include <cstdlib>
#include "common.h"
#include "util.h"
#define PROCESS "bscalibroD"
#define HEADER_PREFIX ("HDR01")
#define BODY_PREFIX ("BDY01")
#define TRAILER_PREFIX ("TLR01")
#define ENDL_SIZE (1)
#define STA_WIDTH (20 + 1 + 7 + 1 + 10 + 1 + 50 + 1 + 15 + 1 + 15)
//#define MISSING_DATA_FILE_EXIT_CODE (2)
//#define MISSING_CTR_FILE_EXIT_CODE (3)
//#define INVALID_CTR_FILE_EXIT_CODE (4)
//#define INVALID_DATA_FILE_SIZE_EXIT_CODE (5)
//#define INVALID_DATA_FILE_WIDTH_EXIT_CODE (6)
#define DB_ERROR_EXIT_CODE (26)
//#define INVALID_DATA_FILE_EXIT_CODE (8)
#define CANNOT_OPEN_DATA_FILE_EXIT_CODE (10)
//#define FCC_FILE_WRITE_ERROR_EXIT_CODE (11)
#define DATA_FILE_CLOSE_ERROR_EXIT_CODE (12)
//#define FCC_FILE_CLOSE_ERROR_EXIT_CODE (13)
//#define CANNOT_OPEN_ERROR_FILE_EXIT_CODE (14)
//#define ERROR_FILE_WRITE_ERROR_EXIT_CODE (15)
//#define ERROR_FILE_CLOSE_ERROR_EXIT_CODE (16)
#define TRANSLATE_WARNING_EXIT_CODE (17)
#define MISSING_ENVIRONMENT_PARAM_EXIT_CODE (18)
#define PARAM_ERROR_EXIT_CODE (19)
#define DATA_FILE_WRITE_ERROR_EXIT_CODE (20)
#define CTR_FILE_WRITE_ERROR_EXIT_CODE (21)
#define CANNOT_OPEN_CTR_FILE_EXIT_CODE (22)
#define CTR_FILE_CLOSE_ERROR_EXIT_CODE (23)
#define EMPTY_DATA_EXIT_CODE (24)
#define DB_EXECUTION_ERROR_CODE (28)
#define TEMP_FILE_WRITE_OPEN_ERROR_EXIT_CODE (29)
#define TEMP_FILE_READ_ERROR_EXIT_CODE (30)
#define TEMP_FILE_WRITE_ERROR_EXIT_CODE (31)
#define TEMP_FILE_CLOSE_ERROR_EXIT_CODE (32)
#define TEMP_FILE_READ_OPEN_ERROR_EXIT_CODE (33)
#define TEMP_FILE_READ_CLOSE_ERROR_EXIT_CODE (34)
#define BUFFER_RESERVE (1000)
using namespace std;
string transform(otl_stream &_in, Functions &_functions, map<string, string> &_t
otalMap) {
// Variables Generales
Var v_sta_filename_prefix("sta_filename_prefix", "LIBRO");
Var v_view_name("view_name", "LIBRO_DIARIO");
Var v_bank("bank", "BIN");
Var v_allow_empty("allow_empty", "FALSE");
Var v_internal("internal", "true");
Var v_refresh_statement("refresh_statement", "IBSPKS_BSGENERALIBRO.CARGA_DIA
RIO");
Var v_output_dir("output_dir", "$STA_OUT_FOLDER_BIN");
// Variables de entrada cursor Oracle
Var v_I_VOUCHER("I_VOUCHER", 20, Var::variable); // 20
Var v_I_AC_NO("I_AC_NO", 7, Var::fixed); // 27
Var v_I_VALUE_DT("I_VALUE_DT", 10, Var::fixed); // 37
Var v_I_TRN_DESC("I_TRN_DESC", 50, Var::variable); // 87
Var v_I_DEBE("I_DEBE", 15, Var::variable); // 102
Var v_I_HABER("I_HABER", 15, Var::variable); // 117
// lectura de cursor Oracle
char _buffer[117 + BUFFER_RESERVE];
_in>>_buffer;
v_I_VOUCHER.assign2(_buffer);
_in>>_buffer;
v_I_AC_NO.assign2(_buffer);
_in>>_buffer;
v_I_VALUE_DT.assign2(_buffer);
_in>>_buffer;
v_I_TRN_DESC.assign2(_buffer);
_in>>_buffer;
v_I_DEBE.assign2(_buffer);
_in>>_buffer;
v_I_HABER.assign2(_buffer);
v_I_VOUCHER.checkLen();
v_I_AC_NO.checkLen();
v_I_VALUE_DT.checkLen();
v_I_TRN_DESC.checkLen();
v_I_DEBE.checkLen();
v_I_HABER.checkLen();
// Variables de salida interfaz batch
Var v_O_VOUCHER("O_VOUCHER", 20, Var::variable);
Var v_O_FILLER1("O_FILLER1", 1, Var::fixed);
Var v_O_CUENTA("O_CUENTA", 7, Var::fixed);
Var v_O_FILLER2("O_FILLER2", 1, Var::fixed);
Var v_O_FECHA("O_FECHA", 10, Var::fixed);
Var v_O_FILLER3("O_FILLER3", 1, Var::fixed);
Var v_O_DESC("O_DESC", 50, Var::variable);
Var v_O_FILLER4("O_FILLER4", 1, Var::fixed);
Var v_O_DEBE("O_DEBE", 15, Var::variable);
Var v_O_FILLER5("O_FILLER5", 1, Var::fixed);
Var v_O_HABER("O_HABER", 15, Var::variable);
v_O_VOUCHER.assign(v_I_VOUCHER);
v_O_FILLER1.assign(Var("\";\"", ";"));
v_O_CUENTA.assign(v_I_AC_NO);
v_O_FILLER2.assign(Var("\";\"", ";"));
v_O_FECHA.assign(v_I_VALUE_DT);
v_O_FILLER3.assign(Var("\";\"", ";"));
v_O_DESC.assign(v_I_TRN_DESC);
v_O_FILLER4.assign(Var("\";\"", ";"));
v_O_DEBE.assign(v_I_DEBE);
v_O_FILLER5.assign(Var("\";\"", ";"));
v_O_HABER.assign(v_I_HABER);
string _out = v_O_VOUCHER.string()
+ v_O_FILLER1.string()
+ v_O_CUENTA.string()
+ v_O_FILLER2.string()
+ v_O_FECHA.string()
+ v_O_FILLER3.string()
+ v_O_DESC.string()
+ v_O_FILLER4.string()
+ v_O_DEBE.string()
+ v_O_FILLER5.string()
+ v_O_HABER.string()
;
return _out;
}
enum steps
{
db_login, db_concept, db_execute, db_header_trailer, write_header, db_load,
db_close,
write_trailer, open_ctr, open_out, write_ctr, write_out, open_error, close_c
tr, close_out, close_error
};
int main(int argc, char *argv[], char *argd[]) {
Logger logger;
if (argc != 7)
{
logger.error("argumentos invalidos");
return PARAM_ERROR_EXIT_CODE;
}
string filename = argv[1];
string staOrigin = argv[2];
string staDestination = argv[3];
string processDate = argv[4];

string outFolder = argv[5];
string version = argv[6];

string FC_BS_LOG_FOLDER;
string FC_DB_USER;
string FC_DB_PASS;
string FC_DB_SID;
try
{
FC_BS_LOG_FOLDER = Util::mygetenv(argd, "FC_BS_LOG_FOLDER_BIN");
FC_DB_USER = Util::mygetenv(argd, "FC_DB_USER_BIN");
FC_DB_PASS = Util::mygetenv(argd, "FC_DB_PASS_BIN");
FC_DB_SID = Util::mygetenv(argd, "FC_DB_SID_BIN");
}
catch (string var)
{
logger.error("Variable de ambiente '" + var + "' no definida");
return MISSING_ENVIRONMENT_PARAM_EXIT_CODE;
}
string LOG_COUNT = Util::mygetenv(argd, "FC_BS_DOWNLOAD_LOG_COUNT_BIN", "0")
;
int logCount = 0;
try
{
logCount = Util::atoi(LOG_COUNT);
}
catch (string var)
{
logger.error("variable FC_BS_DOWNLOAD_LOG_COUNT_BIN no tiene valor numer
ico:" + LOG_COUNT);
return MISSING_ENVIRONMENT_PARAM_EXIT_CODE;
}

string connectionString = FC_DB_USER + "/" + FC_DB_PASS + "@" + FC_DB_SID;


Connection con;
Functions f;
map<string, string> totalMap;
map<string, string> cursorMap;
steps step;
string outFileName = outFolder + "/" + filename;
string ctrFileName = outFolder + "/" + filename + ".CTR";
bool warning = false;
try
{
step = db_login;
con.initialize();
con.logon(connectionString.c_str());

//Conceptos que se deben rescatar de la tala de para
step = db_concept;
ofstream outFile;
outFile.exceptions ( ifstream::eofbit | ifstream::failbit | ifstream::ba
dbit );
ofstream ctrFile;
ctrFile.exceptions ( ifstream::eofbit | ifstream::failbit | ifstream::ba
dbit );
step = open_out;
outFile.open(outFileName.c_str(), ios::out);
int staCount = 0;
long totalCount = 0;
int headerTrailerCount = 0;
string htStr;
step = db_execute;
otl_stream in(100,
"SELECT "
" ''||VOUCHER "
", ''||AC_NO "
", ''||VALUE_DT "
", ''||TRN_DESC "
", ''||DEBE "
", ''||HABER "
"FROM "
"LIBRO_FINAL ORDER BY VOUCHER, AC_NO "
,
con.getDB());
int i = 0;
step = db_load;
while(!in.eof())
{
i++;
try
{
string tmp = transform(in, f, totalMap);
step = write_out;
outFile << tmp << endl;
staCount++;
totalCount += tmp.length() + ENDL_SIZE;
}
catch (VarException e)
{
warning = true;
logger.error("Traduccion linea detalle " + to_string (i+1) + ":
" + e.what());
}
if ( logCount > 0 && i%logCount == 0 ) {
logger.info("Avance lineas procesadas: " + to_string(i));
}
step = db_load;
}
step = close_out;
outFile.close();
step = db_close;
con.logoff();

step = open_ctr;
ctrFile.open(ctrFileName.c_str(), ios::out);

step = write_ctr;
ctrFile << "MENSAJE_CONTROL" << endl;
ctrFile << Util::rfill(filename, 20, ' ')
<< Util::rfill(staOrigin, 20, ' ')
<< Util::rfill(staDestination, 20, ' ')
<< Util::lfill(to_string(staCount + headerTrailerCount), 10, '0'
)
<< "F"
<< Util::lfill(to_string(STA_WIDTH), 10, '0')
<< "AN" << endl;
ctrFile << "FIN_MENSAJE" << endl;

step = close_ctr;
ctrFile.close();

if ( staCount == 0 ) {
logger.error(string("No hay datos de salida para generar archivo de
salida: ") + outFileName);
return EMPTY_DATA_EXIT_CODE;
}
}
catch ( ios::failure e)
{
if ( step == open_out )
{
logger.error(string("no puede abrir archivo de salida: ") + outFileN
ame);
return CANNOT_OPEN_DATA_FILE_EXIT_CODE;
}
else if ( step == write_out )
{
logger.error(string("error de escritura de archivo de salida: ") + e
.what());
return DATA_FILE_WRITE_ERROR_EXIT_CODE;
}
else if ( step == close_out )
{
logger.error(string("error de cierre de archivo de salida: ") + e.wh
at());
return DATA_FILE_CLOSE_ERROR_EXIT_CODE;
}
else if ( step == open_ctr )
{
logger.error(string("no puede abrir archivo de control: ") + ctrFile
Name);
return CANNOT_OPEN_CTR_FILE_EXIT_CODE;
}
else if ( step == write_ctr )
{
logger.error(string("error de escritura de archivo de control: ") +
e.what());
return CTR_FILE_WRITE_ERROR_EXIT_CODE;
}
else if ( step == close_ctr )
{
logger.error(string("error de cierre de archivo de control: ") + e.w
hat());
return CTR_FILE_CLOSE_ERROR_EXIT_CODE;
}
}
catch(otl_exception& p)
{ // intercept OTL exceptions
string detalle = "(" + to_string(p.code) + " - " + to_string(p.msg) + ")
";
if ( step == db_login )
{
logger.error("login a base de datos" + detalle);
}
else if ( step == db_concept )
{
logger.error("obtencion de conceptos de base de datos" + detalle);
}
else if ( step == db_execute )
{
logger.error("Al ejecutar consulta a base de datos" + detalle);
return DB_EXECUTION_ERROR_CODE;
}
else if ( step == db_header_trailer )
{
logger.error("Al ejecutar consulta de header trailer a base de datos
" + detalle);
return DB_EXECUTION_ERROR_CODE;
}
else if ( step == db_load )
{
logger.error("Al cargar datos de base de datos" + detalle);
}
else if ( step == db_close )
{
logger.error("Al cerrar conexion a base de datos" + detalle);
}
return DB_ERROR_EXIT_CODE;
}
#ifdef WIN32
system("PAUSE");
#endif
if ( warning ) {
return TRANSLATE_WARNING_EXIT_CODE;
}
return EXIT_SUCCESS;
}