#include <iostream>

#include <pqxx/pqxx>

using namespace std;

using namespace pqxx;

//Déclaration des fonctions

void create();
void save();
void read_all();
void search(string);
void update(string);
void delete_student(string);
void read_allstudent();
void studentbynameasc();
void studentbynamedesc();
void studentbymoydesc();
void studentbymoyasc();
void avgdep();
void maxdep();
void mindep();

void runApp();
void pause();

int choix;
string matricule, nom, prenom, departement, mention, sql;
float som, moyenne, note[6];

int main()
{
runApp();
return 0;
}

void pause(){
string systempause;
cout << "Appuyez sur une touche pour continuer...";
cin >> systempause;
}

void create(){
try{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "Connexion établie\n";
else
cout << "Connexion non établie\n";

sql = "CREATE TABLE student("\

"MATRICULE VARCHAR(7) PRIMARY KEY NOT NULL,"\
"NOM VARCHAR(50) NOT NULL,"\
"PRENOM VARCHAR(100) NOT NULL,"\
"DEPARTEMENT VARCHAR(40) NOT NULL,"\
"MOYENNE DECIMAL(2,1) NOT NULL,"\
"MENTION VARCHAR(20) NOT NULL);";
 work W(C);
// Execute sql query
W.exec(sql);
W.commit();
cout << "§§§ Table créée avec succès §§§\n";
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

void save(){
cout << "Veuillez saisir les informations de l'étudiant" << endl;
cout << "Matricule >>> "; cin >> matricule;
cout << "Nom >>> "; cin >> nom;
cout << "Prenom >>> "; cin >> prenom;
cout << "Département >>> "; cin >> departement;
cout << "6 Notes " << endl;
som = 0;
for(int i = 0; i < 6; i++){
cout << "Note " << i+1 << " >>> ";
cin >> note[i];
som += note[i];
} moyenne = som / 6;
cout << "Mention >>> "; cin >> mention;

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */
C.prepare("insert", "INSERT INTO student VALUES ($1, $2, $3, $4, $5,
$6)");

/* Création d'un objet de type transactionnel*/

work W(C);
// Execute sql query
W.exec_prepared("insert", matricule, nom, prenom, departement, moyenne,
mention);
W.commit();
cout << "§§§ Ligne Insérer avec succès §§§\n";
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

void read_allstudent(){
try
{
 connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */
sql = "SELECT * FROM student";
/* Creation d'un objet non transactionnel */
nontransaction N(C);
// Execute sql query
result R( N.exec(sql));
// list down all the records
cout << "------------------Liste de tous les étudiants ----------------\n"
<< endl;
cout <<
"+-------------------------------------------------------------------------+" <<
endl;
cout << "+ Matricule | Nom | Prénom | Département | Moyenne |
Mention |" << endl;
cout <<
"+-------------------------------------------------------------------------+" <<
endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "| " << setw(14) << c[0].as<string>() << " | " << setw(9) <<
c[1].as<string>() << " | " << setw(14) << c[2].as<string>() << " | " << setw(14) <<
c[3].as<string>() << " | " << setw(9) << c[4].as<float>() << " | " << setw(9) <<
c[5].as<string>() << " | " << endl;
cout <<
"+-------------------------------------------------------------------------+" <<
endl;
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}
// Liste des étudiants par ordre croissant du nom
void studentbynameasc(){
try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT * FROM student order by nom asc";

/* Create a nontransactional object */

nontransaction N(C);
// Execute sql query
result R( N.exec(sql));
 // list down all the records
cout << "----------- Ordre croissant ------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Matricule : "<< c[0].as<string>() << endl;
cout << "Nom : "<< c[1].as<string>() << endl;
cout << "Prénom : "<< c[2].as<string>() << endl;
cout << "Département : "<< c[3].as<string>() << endl;
cout << "Moyenne : "<< c[4].as<float>() << endl;
cout << "Mention : "<< c[5].as<string>() << endl;
cout << "--------------------------------------\n";
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

// Liste des étudiants par ordre décroissant du nom

void studentbynamedesc(){
try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT * FROM student order by nom desc";

/* Create a nontransactional object */

nontransaction N(C);
// Execute sql query
result R(N.exec(sql));

// list down all the records

cout << "----------- Ordre décroissant ------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Matricule : "<< c[0].as<string>() << endl;
cout << "Nom : "<< c[1].as<string>() << endl;
cout << "Prénom : "<< c[2].as<string>() << endl;
cout << "Département : "<< c[3].as<string>() << endl;
cout << "Moyenne : "<< c[4].as<float>() << endl;
cout << "Mention : "<< c[5].as<string>() << endl;
cout << "--------------------------------------\n";
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
 }
}

// Etudiants par ordre décroissant de la moyenne (ordre de mérite)

void studentbymoydesc(){
try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT * FROM student order by moyenne desc";

/* Create a nontransactional object */

nontransaction N(C);
// Execute sql query
result R( N.exec(sql));

// list down all the records

cout << "---------------Moyenne décroissant -------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Matricule : "<< c[0].as<string>() << endl;
cout << "Nom : "<< c[1].as<string>() << endl;
cout << "Prénom : "<< c[2].as<string>() << endl;
cout << "Département : "<< c[3].as<string>() << endl;
cout << "Moyenne : "<< c[4].as<float>() << endl;
cout << "Mention : "<< c[5].as<string>() << endl;
cout << "--------------------------------------\n";
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

//Etudiants par ordre croissant de la moyenne

void studentbymoyasc(){

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";

/* Create sql statement */

 sql = "SELECT * FROM student order by moyenne asc";

/* Create a nontransactional object */

nontransaction N(C);
// Execute sql query
result R( N.exec(sql));

// list down all the records

cout << "---------------Moyenne croissant -------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Matricule : "<< c[0].as<string>() << endl;
cout << "Nom : "<< c[1].as<string>() << endl;
cout << "Prénom : "<< c[2].as<string>() << endl;
cout << "Département : "<< c[3].as<string>() << endl;
cout << "Moyenne : "<< c[4].as<float>() << endl;
cout << "Mention : "<< c[5].as<string>() << endl;
cout << "--------------------------------------\n";
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

// Moyenne par département

void avgdep(){

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT departement, avg(moyenne) from student group by departement";

/* Create a nontransactional object */

nontransaction N(C);
// Execute sql query
result R( N.exec(sql));

// list down all the records

cout << "---------------Moyenne par département -------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Départemnt : "<< c[0].as<string>() << endl;
cout << "Moyenne : "<< c[1].as<float>() << endl;
cout << "-------------------------------" << endl;
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
 }
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

void maxdep(){

try{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT departement, max(moyenne) from student group by departement";

/* Create a nontransactional object */
nontransaction N(C);
// Execute sql query
result R( N.exec(sql));

// list down all the records

cout << "---------------Max par département -------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Départemnt : "<< c[0].as<string>() << endl;
cout << "Moyenne : "<< c[1].as<float>() << endl;
cout << "-------------------------------" << endl;
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

void mindep(){

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
/* Create sql statement */

sql = "SELECT departement, min(moyenne) from student group by departement";

/* Create a nontransactional object */
nontransaction N(C);
// Execute sql query
result R( N.exec(sql));
 // list down all the records
cout << "---------------Min par département -------------\n" << endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Départemnt : "<< c[0].as<string>() << endl;
cout << "Moyenne : "<< c[1].as<float>() << endl;
cout << "-------------------------------" << endl;
}
cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}
//Menu d'affichage

void read_all(){
int choix;
do{
system("clear");
cout <<
"+------------------------------------------------------------------+" << endl;
cout << "| 1. LISTE DE TOUS LES ÉTUDIANTS
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 2. ÉTUDIANTS PAR ORDRE CROISSANT DU NOM (de A à Z)
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 3. ÉTUDIANTS PAR ORDRE DÉCROISSANT DU NOM (de Z à A)
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 4. ÉTUDIANTS PAR ORDRE DÉCROISSANT DE LA MOYENNE
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 5. ÉTUDIANTS PAR ORDRE CROISSANT DE LA MOYENNE
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 6. MOYENNE PAR DEPARTEMENT
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 7. LA PLUS HAUTE MOYENNE PAR DEPARTEMENT
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 8. LA PLUS FAIBLE MOYENNE PAR DEPARTEMENT
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "| 9. QUITTER
|" << endl;
cout <<
"+------------------------------------------------------------------|" << endl;
cout << "Votre choix >> ";
cin >> choix;
switch(choix){
case 1 :
read_allstudent();
pause();
break;
case 2 :
studentbynameasc();
pause();
break;
case 3 :
studentbynamedesc();
pause();
break;
case 4 :
studentbymoydesc();
pause();
break;
case 5 :
studentbymoyasc();
pause();
break;
case 6 :
avgdep();
pause();
break;
case 7 :
maxdep();
pause();
break;
case 8 :
mindep();
pause();
break;
case 9 :
cout << "§§§ Vous avez quittez le menu d'affichage §§§" <<
endl;
pause();
break;
default :
cout << "§§§ Choix Incorrect! §§§" << endl;
pause();

}
}while (choix != 9);

void search(string matricule){

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
 cout << "§§§ Connexion non établie §§§\n";

/* Create sql statement */

C.prepare("search", "SELECT * FROM student where matricule = $1");

/* Create a nontransactional object */

/*Un objet de type transactionnel, c'est lorsqu'on veut appoter des modifs
à la db*/
nontransaction N(C);
// Execute sql query
result R( N.exec_prepared("search", matricule));

// list down all the records

cout << "------------------Resultat de la recherche ----------------\n" <<
endl;
for (result::const_iterator c=R.begin(); c!=R.end(); ++c)
{
cout << "Matricule : "<< c[0].as<string>() << endl;
cout << "Nom : "<< c[1].as<string>() << endl;
cout << "Prénom : "<< c[2].as<string>() << endl;
cout << "Département : "<< c[3].as<string>() << endl;
cout << "Moyenne : "<< c[4].as<float>() << endl;
cout << "Mention : "<< c[5].as<string>() << endl;
cout << "--------------------------------------\n";
}

cout << "§§§ Opération effectuée aves succès... §§§" << endl;
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}

void update(string matricule){

cout << "Donner les nouvelles informations de l'étudiant \n";

cout << "Nom >> "; cin >> nom;
cout << "Prenom >> "; cin >> prenom;
cout << "Département >>> "; cin >> departement;
cout << "6 Notes " << endl;
som = 0;
for(int i = 0; i < 6; i++){
cout << "Note " << i+1 << " >>> ";
cin >> note[i];
som += note[i];
} moyenne = som / 6;
cout << "Mention >>> "; cin >> mention;
try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";
 C.prepare("update", "UPDATE student \
set nom = $2,\
prenom = $3,\
departement = $4,\
moyenne = $5,\
mention = $6\
where matricule = $1");
work W(C);
/* create delete statement */
W.exec_prepared ("update", matricule, nom, prenom, departement, moyenne,
mention);
W.commit();
cout << "§§§ Modification effectuée avec succès §§§\n";
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}

void delete_student(string matricule){

try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";

C.prepare("delete", "DELETE FROM student where matricule = $1");

work W(C);
/* create delete statement
sql = "DELETE from student where id = 1"; */
W.exec_prepared("delete", matricule);
W.commit();
cout << "§§§ Suppression éffectuée avec succès §§§\n";
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}
void runApp(){
int choix;
do{
system("clear");
cout << "+------------------------------+" << endl;
cout << "| 1. CREATION DE LA TABLE |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 2. AJOUTER UN ÉTUDIANTS |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 3. AFFICHER |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 4. RECHERCHER UN ÉTUDIANT |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 5. MODIFICATION D'ÉTUDIANTS |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 6. SUPPRESSION D'ÉTUDIANTS |" << endl;
cout << "+------------------------------|" << endl;
cout << "| 7. QUITTER |" << endl;
cout << "+------------------------------+" << endl;
cout << "Votre choix >> ";
cin >> choix;
switch(choix){
case 1:
cout << "CREATION DE LA TABLE" << endl;
create();
pause();
break;
case 2:
cout << "ENREGISTREMENT D'ÉTUDIANTS" << endl;
save();
pause();
break;
case 3:
read_all();
break;
case 4:
cout << "RECHERCHE D'ÉTUDIANTS" << endl;
cout << "Veuillez saisir son matricule >> ";
cin >> matricule;
search(matricule);
pause();
break;
case 5:
cout << "MODIFICATION D'ÉTUDIANTS" << endl;
cout << "Veuillez saisir son matricule >> ";
cin >> matricule;
update(matricule);
pause();
break;
case 6:
int choix1;
cout << "SUPPRESSION D'ÉTUDIANTS " << endl;
cout << "-- 1. SUPPRIMER UN SEUL " << endl;
cout << "-- 2.TOUT LE MONDE " << endl;
cout << "-- Votre choix => ";
cin >> choix1;
if (choix1 == 1){
cout << "Veuillez saisir son matricule >> ";
cin >> matricule;
delete_student(matricule);
} else{
try
{
connection C("dbname=etudiant user=postgres password=root\
hostaddr=127.0.0.1 port=5432");
if (C.is_open())
cout << "§§§ Connexion établie §§§\n";
else
cout << "§§§ Connexion non établie §§§\n";

C.prepare("delete_all", "DELETE FROM student ");

 work W(C);
/* create delete statement
sql = "DELETE from student where id = 1"; */
W.exec_prepared("delete_all");
W.commit();
cout << "§§§ Suppression éffectuée avec succès §§§\n";
C.disconnect();
}
catch(const std::exception &e)
{
std::cerr << e.what() << '\n';
}
}
pause();
break;
case 7:
cout << "§§§ VOUS AVEZ QUITTER L'APPLICATION §§§" << endl;
pause();
break;
default :
cout << "§§§ Choix incorrect §§§" << endl;
break;
}

}while (choix != 7);