/* * ODBC * Author : WEHRLE Geoffrey * Projet Optim'Eisti */ #include "utilities.h" #include #include #include #include #include #include #include "DatabaseDAO.h" #include "group.h" #include "user.h" #include "problema.h" #include "result.h" #include "XMLParser.h" #include "configuration.h" #include "logger.h" Group* createGroup (Group* g){ // Declare variables SQLHENV env; char name_groupe[MAX_STRING_INPUT] = "nomgroupe"; int id_respo, id_group; // Initialization variables strcpy(name_groupe,g->_name); id_respo = g->_respo; id_group = 0; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { //Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call creeGroupe(?, ?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, name_groupe,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_respo), 0, &id_respo,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Create Group OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } g->setId(g,id_group); return g; } User* createUser (User* u){ // Declare variables SQLHENV env; char* login = "login"; char password[50] = "password"; int id_user,id_group,id_role; // Initialization variables strcpy(login,(char*)u->getLogin(u)); strcpy(password,(char*)u->getPassword(u)); id_user = 0; SQLINTEGER cbValue = SQL_NTS; if ( u->groups.size == 0) fprintf(stderr, "ERROR // no id group for this user in the array group"); else { id_group = u->groups.group[0][ID]; id_role = u->groups.group[0][ROLE_ID]; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt,(SQLCHAR*) "{ call creePersonne(?, ?, ?, ?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, login,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, password,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_role), 0, &id_role,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 5, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_user), 0, &id_user,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Create User OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } } u->setId(u,id_user); return u; } Problema* createProblem (Problema* p,unsigned int id_group){ // Declare variables SQLHENV env; int id_problema; char* name_problema = "nameproblema"; // Initialization variables strcpy(name_problema,p->name); id_problema = 0; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call creeProbleme(XMLTYPE(?), ?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, writeProblemXML(p),0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_problema), 0, &id_problema,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Create Problema OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } p->setId(p,(long)id_problema); return p; } ResultArray* createResultat (ResultArray* r){ // Declare variables SQLHENV env; int id_problem,id_method,id_result; SQLINTEGER cbValue = SQL_NTS; if (r->size == 0) fprintf(stderr, "no results in the array result "); else { // Initialization variables id_problem = r->result[0]->getProblemId(r->result[0]); id_method = r->result[0]->getMethodId(r->result[0]); id_result = 0; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call creeResultat(?,?,XMLTYPE(?),?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_problem), 0, &id_problem,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_method), 0, &id_method,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, writeResultXML(r),0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 4, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_result), 0, &id_result,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Create Result OK !\n"); r->result[0]->setId(r->result[0],id_result); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } } return r; } ResultArray* createBenchmark(ResultArray* r){ // Declare variables SQLHENV env; int id_benchmark,i,id_result; SQLINTEGER cbValue = SQL_NTS; if (r->size == 0) fprintf(stderr, "no results in the array result "); else { id_result = r->result[0]->getId(r->result[0]); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call creeBenchmark(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_benchmark), 0, &id_benchmark,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Create Benchmark OK !\n"); r->benchId = id_benchmark; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } for (i = 0; isize ; i++){ // Create handle to get statement result SQLHSTMT stmt1; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt1)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt1, (SQLCHAR*)"{ call lienBenchmarkResult(?,?) }", SQL_NTS); SQLBindParameter(stmt1, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_result), 0, &id_result,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt1, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_benchmark), 0, &id_benchmark,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Add Result to Benchmark OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt1); } } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } } return r; } User* readUser(unsigned int id){ return NULL; } Group* readGroup(unsigned int id){ return NULL; } Problema* readProblema (unsigned int id){ // Declare variables SQLHENV env; Problema* p; char xml_problema[MAX_STRING_INPUT]; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to BDD SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call lireProbleme(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, MAX_STRING_INPUT, 0,xml_problema,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Read Problema OK !\n"); p = parseProblemFromString(xml_problema); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return p; } ResultArray* readResult(unsigned int id){ // Declare variables SQLHENV env; ResultArray* r; char xml_result[MAX_STRING_INPUT]; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to BDD SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call lireResultat(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, MAX_STRING_INPUT, 0,xml_result,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Read Result OK !\n"); r = parseResultFromString(xml_result); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return r; } User* updateUser (User* u){ // Declare variables SQLHENV env; char login[50] = "login"; char password[50] = "password"; int id_user; // Initialization variables strcpy(login,u->getLogin(u)); strcpy(password,u->getPassword(u)); id_user = u->getId(u); SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to BDD SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call modifierMembre(?,?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_user), 0, &id_user,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, login,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, password,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Update User OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return u; } Group* updateGroup (Group* g){ // Declare Variables SQLHENV env; char* name_group = "namegroup"; int id_group,id_respo; // Initialization variables strcpy(name_group,g->_name); id_group = g->getId(g); id_respo = g->_respo; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call modifierGroupe(?,?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, name_group,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_respo), 0, &id_respo,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Update Group OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return g; } Problema* updateProblema (Problema* p){ // Declare variables SQLHENV env; int id_problem; // Initialization variable id_problem = p->getId(p); SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call modifierProbleme(?,XMLTYPE(?)) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_problem), 0, &id_problem,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, writeProblemXML(p),0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Update Problema OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return p; } Result* updateResult(Result* r){ // Declare variables SQLHENV env; int id_problem,id_result,id_method; ResultArray result; // Initialization variable id_problem = r->getProblemId(r); id_method = r->getMethodId(r); id_result = r->getId(r); SQLINTEGER cbValue = SQL_NTS; memset(result.result,0,MAX_ITEM*sizeof(Result*)); result.result[0] = r; result.size = 1; result.benchId = 0; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { char* xml_data = writeResultXML(&result); // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call modifierResultat(?,?,?,XMLTYPE(?)) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_result), 0, &id_result,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_problem), 0, &id_problem,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_method), 0, &id_method,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(xml_data), 0,xml_data,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Update Result OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return r; } Group** getGroups(){ // Declare variables SQLHENV env; int number,i; Group** groups; number = 0; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) { logMessage(SEVERE," function SQLAllocHandle ENV","Failed"); return NULL; } else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) { logMessage(SEVERE," function SQLSetEnvAttr","Failed"); return NULL; } else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) { logMessage(SEVERE," function SQLAllocHandle DBC","Failed"); return NULL; } else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) { logMessage(SEVERE," function SQLConnect","Failed"); return NULL; } else { // Create handle to get statement result SQLHSTMT stmt; ; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) { logMessage(SEVERE," function SQLAllocHandle STMT","Failed"); return NULL; } else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call tailleGroupe(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(number), 0, &number,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) { logMessage(SEVERE," function SQLExecute","Failed"); return NULL; } else { sprintf(buffer,"%d",number); logMessage(DEBUG1,"group size",buffer); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } // Create handle to get statement result SQLHSTMT hstmt; SQLCHAR columns[3][30]; SQLRETURN rc; groups = malloc((number+1)*sizeof(Group*)); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(SEVERE," function SQLExecDirect","avant de failed"); //sleep(4); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt, (SQLCHAR*) "SELECT * FROM groupe", SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(INFO," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; int j = 0; while ((rc =SQL_SUCCEEDED(SQLFetch(hstmt)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,0,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } groups[j] = createGroupSkeleton(); rc = SQLGetData(hstmt, 1, SQL_C_CHAR, columns[0], sizeof(columns[0]), NULL); logMessage(INFO,"Id groupe",(char *)columns[0]); logMessage(INFO,"Check GetData 1 success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 2, SQL_C_CHAR, columns[1], sizeof(columns[1]), NULL); logMessage(INFO,"Nom groupe",(char *)columns[1]); logMessage(INFO,"Check 2 GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check 2 GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check 2 GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check 2 GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check 2 GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check 2 GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,2,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 3, SQL_C_CHAR, columns[3], sizeof(columns[3]), NULL); logMessage(INFO,"Id respo groupe",(char *)columns[3]); logMessage(INFO,"Check GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,3,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id groupe"," on rentre l'id dans groups"); groups[j] ->setId(groups[j],atoi((char *)columns[0])); logMessage(DEBUG1,"nom groupe"," on rentre le nom groupe dans groups"); strcpy(groups[j]->_name,(char*)columns[1]); logMessage(DEBUG1,"id groupe"," on rentre l'id du respo dans groups"); groups[j] ->_respo = atoi((char *)columns[2]); j++; } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); groups[j] = NULL; } SQLFreeHandle(SQL_HANDLE_STMT, hstmt); } for (i=0;igetId(groups[i])); logMessage(DEBUG1," requete sql", sqlstmt); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt1)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(DEBUG1,"avant function SQLExecDirect","avant de failed"); //sleep(4); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt1, (SQLCHAR*) sqlstmt, SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(INFO," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; while ((rc1 =SQL_SUCCEEDED(SQLFetch(hstmt1)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc1 = SQLGetData(hstmt1, 1, SQL_C_CHAR, columns, sizeof(columns), NULL); logMessage(INFO,"Id_personne ",(char *)columns); logMessage(INFO,"Check GetData 1 success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id personne"," on rentre l'id personne dans groups"); groups[i]->addUser(groups[i],atoi((char *)columns)); } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt1); } } for (i=0;igetId(groups[i])); logMessage(DEBUG1," requete sql", sqlstmt); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt2)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(DEBUG1,"avant function SQLExecDirect","avant de failed"); //sleep(4); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt2, (SQLCHAR*) sqlstmt, SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(INFO," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; while ((rc2 =SQL_SUCCEEDED(SQLFetch(hstmt2)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc2 == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc2 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc2 == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc2 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc2 == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc2 == SQL_INVALID_HANDLE)); if( rc2 == SQL_SUCCESS_WITH_INFO || rc2 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt2,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc2 = SQLGetData(hstmt2, 1, SQL_C_CHAR, columns, sizeof(columns), NULL); logMessage(INFO,"Id_probleme ",(char *)columns); logMessage(INFO,"Check GetData 1 success",printBoolean(rc2 == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc2 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc2 == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc2 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc2 == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc2 == SQL_INVALID_HANDLE)); if( rc2 == SQL_SUCCESS_WITH_INFO || rc2 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt2,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id probleme"," on rentre l'id problem dans groups"); groups[i]->addProblem(groups[i],atoi((char *)columns)); } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt2); } } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return groups; } User** getUsers(){ // Declare variables SQLHENV env; int number,i; User** users; number = 0; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) { logMessage(SEVERE," function SQLAllocHandle ENV","Failed"); return NULL; } else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) { logMessage(SEVERE," function SQLSetEnvAttr","Failed"); return NULL; } else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) { logMessage(SEVERE," function SQLAllocHandle DBC","Failed"); return NULL; } else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) { logMessage(SEVERE," function SQLConnect","Failed"); return NULL; } else { // Create handle to get statement result SQLHSTMT stmt; ; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) { logMessage(SEVERE," function SQLAllocHandle STMT","Failed"); return NULL; } else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call taillePersonne(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(number), 0, &number,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) { logMessage(SEVERE," function SQLExecute","Failed"); return NULL; } else { sprintf(buffer,"%d",number); logMessage(DEBUG1,"user size",buffer); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } // Create handle to get statement result SQLHSTMT hstmt; SQLCHAR columns[4][30]; SQLRETURN rc; users = malloc((number+1)*sizeof(User*)); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(SEVERE," function SQLExecDirect","avant de failed"); //sleep(4); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt, (SQLCHAR*) "SELECT * FROM personne", SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(SEVERE," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; int j = 0; while ((rc =SQL_SUCCEEDED(SQLFetch(hstmt)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,0,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } users[j] = createUserSkeleton(); rc = SQLGetData(hstmt, 1, SQL_C_CHAR, columns[0], sizeof(columns[0]), NULL); logMessage(INFO,"Id user",(char *)columns[0]); logMessage(INFO,"Check GetData 1 success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 2, SQL_C_CHAR, columns[1], sizeof(columns[1]), NULL); logMessage(INFO,"Login user",(char *)columns[1]); logMessage(INFO,"Check 2 GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check 2 GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check 2 GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check 2 GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check 2 GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check 2 GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,2,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 3, SQL_C_CHAR, columns[2], sizeof(columns[2]), NULL); logMessage(INFO,"user password",(char *)columns[2]); logMessage(INFO,"Check GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,3,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 4, SQL_C_CHAR, columns[3], sizeof(columns[3]), NULL); logMessage(INFO,"id_role",(char *)columns[2]); logMessage(INFO,"Check GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,3,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id user"," on rentre l'id dans user"); users[j] ->setId(users[j],atoi((char *)columns[0])); logMessage(DEBUG1,"login user"," on rentre le login dans users"); users[j] ->setLogin(users[j],(char*)columns[1]); logMessage(DEBUG1,"password user"," on rentre le password dans users"); users[j] ->setPassword(users[j],(char*)columns[2]); logMessage(DEBUG1,"id role"," on rentre l'id role dans user"); users[j] ->groups.group[0][ROLE_ID] = atoi((char *)columns[3]); j++; } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); users[j] = NULL; } SQLFreeHandle(SQL_HANDLE_STMT, hstmt); } for (i=0;igetId(users[i])); logMessage(DEBUG1," requete sql", sqlstmt); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt1)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(DEBUG1,"avant function SQLExecDirect","avant de failed"); //sleep(4); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt1, (SQLCHAR*) sqlstmt, SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(SEVERE," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; while ((rc1 =SQL_SUCCEEDED(SQLFetch(hstmt1)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc1 = SQLGetData(hstmt1, 1, SQL_C_CHAR, columns, sizeof(columns), NULL); logMessage(INFO,"Id group ",(char *)columns); logMessage(INFO,"Check GetData 1 success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id group"," on rentre l'id group dans users"); users[i]->addGroup(users[i],atoi((char *)columns),users[i]->groups.group[0][ROLE_ID]); } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt1); } } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return users; } Problema** getProblema(){ // Declare variables SQLHENV env; int number,id_group; Problema** problems; number = 0; SQLINTEGER cbValue = SQL_NTS; id_group = getSessionId(); sprintf(buffer,"%d",id_group); logMessage(INFO,"number vid group",buffer); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) { logMessage(SEVERE," function SQLAllocHandle ENV","Failed"); return NULL; } else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) { logMessage(SEVERE," function SQLSetEnvAttr","Failed"); return NULL; } else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) { logMessage(SEVERE," function SQLAllocHandle DBC","Failed"); return NULL; } else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) { logMessage(SEVERE," function SQLConnect","Failed"); return NULL; } else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) { logMessage(SEVERE," function SQLAllocHandle STMT","Failed"); return NULL; } else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call tailleProbleme(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(number), 0, &number,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) { logMessage(SEVERE," function SQLExecute","Failed"); return NULL; } else { sprintf(buffer,"%d",number); logMessage(DEBUG1,"problema size",buffer); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } // Create handle to get statement result SQLHSTMT hstmt; SQLCHAR columns[2][30]; SQLCHAR getxml[MAX_STRING_INPUT]; SQLRETURN rc; char sqlstmt[200]; problems = malloc((number+1)*sizeof(Problema*)); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(DEBUG1," function SQLExecDirect","avant de failed"); sprintf(sqlstmt,"SELECT p.id, p.nom_probleme, p.structure_probleme FROM probleme p,lien_probleme_groupe lpg WHERE (p.id = lpg.id_probleme AND lpg.id_groupe = %d)",id_group); logMessage(INFO, "", sqlstmt); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt, (SQLCHAR*) sqlstmt, SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(DEBUG1," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; int j = 0; logMessage(DEBUG1,"j'arrive au while ou je rentre pas",""); while ((rc = SQL_SUCCEEDED(SQLFetch(hstmt)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } problems[j] = createProblemaSkeleton(); rc = SQLGetData(hstmt, 1, SQL_C_CHAR, columns[0], sizeof(columns[0]), NULL); logMessage(INFO,"Id problem",(char *)columns[0]); logMessage(INFO,"Check GetData 1 success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 2, SQL_C_CHAR, columns[1], sizeof(columns[1]), NULL); logMessage(INFO,"name_problema",(char *)columns[1]); logMessage(INFO,"Check 2 GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check 2 GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check 2 GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check 2 GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check 2 GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check 2 GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,2,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc = SQLGetData(hstmt, 3, SQL_C_CHAR, getxml, sizeof(getxml), NULL); logMessage(INFO,"probleme xml",(char *)getxml); logMessage(INFO,"Check GetData success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO,"Check GetData success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData no data",printBoolean(rc == SQL_NO_DATA)); logMessage(INFO,"Check GetData still executing",printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData error",printBoolean(rc == SQL_ERROR)); logMessage(INFO,"Check GetData invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); if( rc == SQL_SUCCESS_WITH_INFO || rc == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt,3,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"parse problem"," on rentre l'xml"); problems[j] = parseProblemFromString((char *)getxml); logMessage(DEBUG1,"id problem"," on rentre l'id dans problem"); problems[j] ->setId(problems[j],atoi((char *)columns[1])); j++; } logMessage(DEBUG2,"Fetch","fin while"); logMessage(INFO,"Check Fetch success",printBoolean(rc == SQL_SUCCESS)); logMessage(INFO, "Check Fetch success with info",printBoolean(rc == SQL_SUCCESS_WITH_INFO)); logMessage(INFO, "Check Fetch no data", printBoolean(rc == SQL_NO_DATA)); logMessage(INFO, "Check Fetch still executing", printBoolean(rc == SQL_STILL_EXECUTING)); logMessage(INFO, "Check Fetch error", printBoolean( rc == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc == SQL_INVALID_HANDLE)); logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); problems[j] = NULL; } SQLFreeHandle(SQL_HANDLE_STMT, hstmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return problems; } User* authentify (char* login, char* password){ // Declare Variables SQLHENV env; User* u = NULL; int id_user, id_role, id_group; // Initialization variable SQLINTEGER cbValue = SQL_NTS; id_user = 0; id_role = 0; id_group = 0; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { logMessage(INFO,"Action","On va attendre"); // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call authentifier(?,?,?,?,?) }", SQL_NTS); int number = 0; logMessage(INFO,"Action","On va binder"); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, login,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 50, 0, password,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 3, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_user), 0, &id_user,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 4, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_role), 0, &id_role,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 5, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(number), 0, &number,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) { logMessage(SEVERE,"Error SQL","function SQLExecute failed"); return NULL; } else { sprintf(buffer,"%d",number); logMessage(INFO,"number value",buffer); if (number == 1){ u = createUserSkeleton(); u->setId(u,id_user); u->setLogin(u,login); u->setPassword(u,password); logMessage(INFO,"User created",u->display(u)); logMessage(INFO,"DATABASEDAO","Authentification OK !"); }else{ logMessage(INFO,"DATABASEDAO","CA A FAILED"); } } logMessage(INFO,"DATABASEDAO","je fais le free HANDLE"); SQLFreeHandle(SQL_HANDLE_STMT, stmt); } // Create handle to get statement result SQLHSTMT hstmt1; SQLCHAR columns[30]; SQLRETURN rc1; char sqlstmt[100]; logMessage(DEBUG1," sprintf"," concat"); sprintf(sqlstmt,"SELECT id_groupe FROM lien_personne_groupe WHERE id_personne = %d",u->getId(u)); logMessage(DEBUG1," requete sql", sqlstmt); if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &hstmt1)) ) { logMessage(SEVERE," function SQLAllocHandle","Failed"); return NULL; } else { logMessage(DEBUG1,"avant function SQLExecDirect","avant de failed"); if (!SQL_SUCCEEDED(SQLExecDirect(hstmt1, (SQLCHAR*) sqlstmt, SQL_NTS))) { logMessage(SEVERE," function SQLExecDirect","Failed"); return NULL; } else{ logMessage(SEVERE," function SQLSucceeded",""); SQLCHAR sqlstate[100]; SQLCHAR msgstate[100]; SQLINTEGER nativeErrorPtr; while ((rc1 =SQL_SUCCEEDED(SQLFetch(hstmt1)))) { logMessage(DEBUG2,"Fetch","traitement ligne"); logMessage(INFO,"Check Fetch success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check Fetch success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check Fetch no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check Fetch still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check Fetch error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check Fetch invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } rc1 = SQLGetData(hstmt1, 1, SQL_C_CHAR, columns, sizeof(columns), NULL); logMessage(INFO,"Id_groupe ",(char *)columns); logMessage(INFO,"Check GetData 1 success",printBoolean(rc1 == SQL_SUCCESS)); logMessage(INFO,"Check GetData 1 success with info",printBoolean(rc1 == SQL_SUCCESS_WITH_INFO)); logMessage(INFO,"Check GetData 1 no data",printBoolean(rc1 == SQL_NO_DATA)); logMessage(INFO,"Check GetData 1 still executing",printBoolean(rc1 == SQL_STILL_EXECUTING)); logMessage(INFO,"Check GetData 1 error",printBoolean(rc1 == SQL_ERROR)); logMessage(INFO,"Check GetData 1 invalid handle",printBoolean(rc1 == SQL_INVALID_HANDLE)); if( rc1 == SQL_SUCCESS_WITH_INFO || rc1 == SQL_ERROR) { SQLGetDiagRec(SQL_HANDLE_STMT,hstmt1,1,sqlstate,&nativeErrorPtr,msgstate,sizeof(msgstate),NULL); logMessage(INFO,"sql state",(char *)sqlstate); logMessage(INFO,"Message state",(char *)msgstate); } logMessage(DEBUG1,"id group"," on rentre l'id group dans personne"); u->addGroup(u,atoi((char *)columns),id_role); } logMessage(DEBUG1," le fetch finit","Fin de la boucle while"); } SQLFreeHandle(SQL_HANDLE_STMT, hstmt1); } SQLDisconnect(con); logMessage(INFO,"DATABASEDAO","je fais le free DISCONNECT"); } SQLFreeHandle(SQL_HANDLE_DBC, con); logMessage(INFO,"DATABASEDAO","je fais le free HANDLE 2"); } } SQLFreeHandle(SQL_HANDLE_ENV, env); logMessage(INFO,"DATABASEDAO","je fais le free HANDLE 3"); } logMessage(INFO,"DATABASEDAO","je return u"); return u; } boolean addUserGroup (unsigned int id_user, unsigned int id_group){ // Declare Variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call ajoutMembre(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_user), 0, &id_user,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Add Member OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean dropUserGroup (unsigned int id_user, unsigned int id_group){ // Declare variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to BDD SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call retirerMembre(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_user), 0, &id_user,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Drop Member OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean switchGroupManager (unsigned int id_new_respo, unsigned int id_group){ // Declare variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call changerRespoGroupe(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_new_respo), 0, &id_new_respo,0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id_group), 0, &id_group,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Switch Group Manager OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean deleteUser (unsigned int id){ // Declare variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call supprimerMembre(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Delete User OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean deleteGroup (Group * g){ // Declare variables SQLHENV env; boolean response; int number,test,i,id; // Initialization variables response = FALSE; number = 0; test = 0; id = g->getId(g); SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result // Check users if they all get other group for (i = 0 ; i_users.size ; i++){ SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call verifMembre(?,?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(g->_users.ids[i]), 0, &g->_users.ids[i],0,(SQLLEN *) &cbValue); SQLBindParameter(stmt, 2, SQL_PARAM_OUTPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(number), 0, &number,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Check Member OK !\n"); if (number == 1) test = 1; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } } // Delete group if all users get at least one other group if (test == 0){ SQLHSTMT stmt1; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt1)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt1, (SQLCHAR*)"{ call supprimerGroupe(?) }", SQL_NTS); SQLBindParameter(stmt1, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt1))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Delete Group OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt1); } } // Delete problems of the deleted group for (i = 0 ; i_problems.size ; i++){ SQLHSTMT stmt2; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt2)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt2, (SQLCHAR*)"{ call supprimerProbleme(?) }", SQL_NTS); SQLBindParameter(stmt2, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(g->_problems.ids[i]), 0, &g->_problems.ids[i],0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt2))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Delete Problem of Group OK !\n"); } SQLFreeHandle(SQL_HANDLE_STMT, stmt2); } } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean deleteProblema (unsigned int id){ // Declare variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call supprimerProbleme(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Delete Problema OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; } boolean deleteResult (unsigned int id){ // Declare variables SQLHENV env; boolean response; // Initialization variable response = FALSE; SQLINTEGER cbValue = SQL_NTS; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, NULL, &env)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_ENV).\n"); else { // Configure environment if ( !SQL_SUCCEEDED(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)) ) fprintf(stderr, "function SQLSetEnvAttr failed.\n"); else { // Create connection SQLHDBC con; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, env, &con)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_DBC).\n"); else { // Connection to DataBase SQLCHAR dsn[] = "ORACLE_PROJECT"; SQLCHAR uid[] = "PROJECT"; SQLCHAR pwd[] = "OPTIM"; if ( !SQL_SUCCEEDED(SQLConnect(con, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS)) ) fprintf(stderr, "function SQLConnect failed.\n"); else { // Create handle to get statement result SQLHSTMT stmt; if ( !SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, con, &stmt)) ) fprintf(stderr, "function SQLAllocHandle failed (SQL_HANDLE_STMT).\n"); else { // Statement SQLPrepare(stmt, (SQLCHAR*)"{ call supprimerResultat(?) }", SQL_NTS); SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_INTEGER, sizeof(id), 0, &id,0,(SQLLEN *) &cbValue); if ( !SQL_SUCCEEDED(SQLExecute(stmt))) fprintf(stderr, "function SQLExecute failed.\n"); else { printf("Delete Result OK !\n"); response = TRUE; } SQLFreeHandle(SQL_HANDLE_STMT, stmt); } SQLDisconnect(con); } SQLFreeHandle(SQL_HANDLE_DBC, con); } } SQLFreeHandle(SQL_HANDLE_ENV, env); } return response; }