Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Elenco Telefonico Remoto - manutenzione.c

manutenzione.c

Caricato da:
Scarica il programma completo

  1. /* manutenzione.c */
  2.  
  3. #include "macro.h"
  4. #include "funzioniServer.h"
  5. #include "manutenzione.h"
  6.  
  7. void stampaMenuManutenzione(){
  8.  
  9.         /* Stampo il sottomenù "Manutenzione" */
  10.        
  11.         printf("\n\033[01;33m---------------------------------\n");fflush(stdout);
  12.         printf("--------MENU MANUTENZIONE--------\n");fflush(stdout);
  13.         printf("---------------------------------\n\n");fflush(stdout);
  14.         printf("   1. Aggiungi Record\n");fflush(stdout);
  15.         printf("   2. Cancella Record\n");fflush(stdout);
  16.         printf("   3. Cerca Record\n");fflush(stdout);
  17.         printf("   4. Stampa elenco telefonico\n");fflush(stdout);
  18.         printf("\n");fflush(stdout);
  19.         printf("   5. Aggiungi Utente\n");fflush(stdout);
  20.         printf("   6. Cancella Utente\n");fflush(stdout);
  21.         printf("   7. Cerca Utente\n");fflush(stdout);
  22.         printf("   8. Stampa elenco utenti\n");fflush(stdout);
  23.         printf("\n");fflush(stdout);
  24.         printf("   9. INDIETRO\n");fflush(stdout);
  25.         printf("\n---------------------------------\n");fflush(stdout);
  26.         printf("---------------------------------\033[00m\n");fflush(stdout);
  27.  
  28. }
  29.  
  30. int manutenzione(){
  31.  
  32.         int modalita;
  33.         int testscanf;
  34.  
  35.         /* Stampo il sottomenù "Manutenzione" */
  36.         stampaMenuManutenzione();
  37.  
  38.         printf("Selezionare l'opzione...\n");fflush(stdout);
  39.  
  40.         /* Seleziono l'opzione desiderata scartando quelle "illegali" */
  41.         do{    
  42.                 testscanf = scanf("%d", &modalita);
  43.                 while(-1 == testscanf){
  44.                         if(errno != EINTR){
  45.                                 printf("\nErrore scanf\n");
  46.                                 chiusuraServer();
  47.                         }
  48.                         else{
  49.                                 testscanf = scanf("%d", &modalita);
  50.                         }
  51.                 }
  52.                 if(testscanf == 0 || modalita>9 || modalita<1){ // Ho scelto un'opzione "illegale"
  53.                         scanf("%*[^\n]"); // Svuoto l'input buffer
  54.                         printf("Opzione non valida...\n");fflush(stdout);
  55.                         printf("Selezionare l'opzione...\n\n");fflush(stdout);
  56.                         stampaMenuManutenzione();
  57.                 }
  58.         } while(testscanf == 0 || modalita>9 || modalita<1);
  59.        
  60.         /* Ritorno il valore dell'opzione selezionata*/
  61.         return modalita;
  62. }
  63.  
  64. void manutenzioneMain(){
  65.  
  66.         int opzione;
  67.  
  68.         while(1){
  69.  
  70.                 /* Seleziono l'opzione del sottomenù "Manutenzione" */
  71.                 opzione = manutenzione();
  72.  
  73.                 /* Chiamo la funzione specifica per l'opzione selezionata */
  74.                 if(opzione==1) {
  75.                                         Record record;
  76.                                        
  77.                                         /* Resetto i valori della struct record */
  78.                                         memset(record.nome, 0, sizeof(record.nome));
  79.                                         memset(record.cognome, 0, sizeof(record.cognome));
  80.                                         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  81.                                        
  82.                                         /* Memorizzo nella struct record i valori digitati */
  83.                                         printf("\nInserisci nome e premi INVIO   ");fflush(stdout);
  84.                                         while(scanf("%s", record.nome) == -1){
  85.                                                 if(errno != EINTR){
  86.                                                         printf("\nErrore scanf\n");
  87.                                                         chiusuraServer();
  88.                                                 }
  89.                                         }
  90.                                         printf("\nInserisci cognome e premi INVIO   ");fflush(stdout);
  91.                                         while(scanf("%s", record.cognome) == -1){
  92.                                                 if(errno != EINTR){
  93.                                                         printf("\nErrore scanf\n");
  94.                                                         chiusuraServer();
  95.                                                 }
  96.                                         }
  97.                                        
  98.                                         /* Cerco nell'archivio il record "record" e lo memorizzo in recordTemp */
  99.                                         Record recordTemp = cercaRecord(record);
  100.                                         if((strcmp(record.nome, recordTemp.nome) != 0 ) && (strcmp(record.cognome, recordTemp.cognome) != 0 )){
  101.                                                 printf("\nInserisci N.telefono e premi INVIO   ");fflush(stdout);
  102.                                                 while(scanf("%s", record.numeroTelefono) == -1){
  103.                                                         if(errno != EINTR){
  104.                                                                 printf("\nErrore scanf\n");
  105.                                                                 chiusuraServer();
  106.                                                         }
  107.                                                 }
  108.                                        
  109.                                                 /* Aggiungo il record all'archivio */
  110.                                                 if(-1 == aggiungiRecord(record)){
  111.                                                         printf("\nOperazione fallita, riprovare...\n");fflush(stdout);
  112.                                                         premiInvio();
  113.                                                 }
  114.                                                 else{
  115.                                                         printf("\nOperazione conclusa con successo!\n");fflush(stdout);
  116.                                                         premiInvio();
  117.                                                 }
  118.                                         }
  119.                                         else{
  120.                                                 printf("\n%s %s è già presente nell'elenco!\n", record.nome, record.cognome);fflush(stdout);
  121.                                                 premiInvio();
  122.                                         }
  123.                                 }
  124.                 if(opzione==2) {
  125.                                         Record record;
  126.  
  127.                                         /* Resetto i valori della struct record */
  128.                                         memset(record.nome, 0, sizeof(record.nome));
  129.                                         memset(record.cognome, 0, sizeof(record.cognome));
  130.                                         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  131.                                        
  132.                                         /* Memorizzo nella struct record i valori digitati */
  133.                                         printf("\nInserisci nome e premi INVIO   ");fflush(stdout);
  134.                                         while(scanf("%s", record.nome) == -1){
  135.                                                 if(errno != EINTR){
  136.                                                         printf("\nErrore scanf\n");
  137.                                                         chiusuraServer();
  138.                                                 }
  139.                                         }
  140.                                         printf("\nInserisci cognome e premi INVIO   ");fflush(stdout);
  141.                                         while(scanf("%s", record.cognome) == -1){
  142.                                                 if(errno != EINTR){
  143.                                                         printf("\nErrore scanf\n");
  144.                                                         chiusuraServer();
  145.                                                 }
  146.                                         }
  147.  
  148.                                         /* Cerco nell'archivio il record "record" e lo memorizzo in recordTemp */
  149.                                         Record recordTemp = cercaRecord(record);
  150.                                         if(strcmp(recordTemp.nome, "NULL") != 0){
  151.  
  152.                                                 /* Cancello il record dall'archivio */
  153.                                                 if(-1 == cancellaRecord(record)){
  154.                                                         printf("\nOperazione fallita, riprovare...\n");fflush(stdout);
  155.                                                         premiInvio();
  156.                                                 }
  157.                                                 else{
  158.                                                         printf("\nOperazione conclusa con successo!\n");fflush(stdout);
  159.                                                         premiInvio();
  160.                                                 }
  161.                                         }
  162.                                         else{
  163.                                                 printf("\nOperazione impossibile, %s %s non è presente nell'elenco!\n", record.nome, record.cognome);fflush(stdout);
  164.                                                 premiInvio();
  165.                                         }
  166.                                 }
  167.                 if(opzione==3) {
  168.                                         Record record, recordTemp;
  169.  
  170.                                         /* Resetto i valori della struct record */
  171.                                         memset(record.nome, 0, sizeof(record.nome));
  172.                                         memset(record.cognome, 0, sizeof(record.cognome));
  173.                                         memset(record.numeroTelefono, 0, sizeof(record.numeroTelefono));
  174.  
  175.                                         /* Resetto i valori della struct recordTemp */
  176.                                         memset(recordTemp.nome, 0, sizeof(recordTemp.nome));
  177.                                         memset(recordTemp.cognome, 0, sizeof(recordTemp.cognome));
  178.                                         memset(recordTemp.numeroTelefono, 0, sizeof(recordTemp.numeroTelefono));
  179.                                        
  180.                                         /* Memorizzo nella struct record i valori digitati */
  181.                                         printf("\nInserire il cognome e premere INVIO   ");fflush(stdout);
  182.                                         while(scanf("%s", record.cognome) == -1){
  183.                                                 if(errno != EINTR){
  184.                                                         printf("\nErrore scanf\n");
  185.                                                         chiusuraServer();
  186.                                                 }
  187.                                         }                                      
  188.                                         printf("\nInserire il nome e premere INVIO   ");fflush(stdout);
  189.                                         while(scanf("%s", record.nome) == -1){
  190.                                                 if(errno != EINTR){
  191.                                                         printf("\nErrore scanf\n");
  192.                                                         chiusuraServer();
  193.                                                 }
  194.                                         }
  195.                                        
  196.                                         /* Cerco nell'archivio il record "record" e lo memorizzo in recordTemp */
  197.                                         recordTemp = cercaRecord(record);
  198.                                         if(strcmp(recordTemp.nome, "NULL") == 0){
  199.                                                 printf("\nRecord inesistente!\n");fflush(stdout);
  200.                                                 premiInvio();
  201.                                         }
  202.                                         else{
  203.                                                 /* Stampo il record trovato */
  204.                                                 printf("\n%-13s %-13s %s\n", "NOME", "COGNOME", "N. TEL");fflush(stdout);
  205.                                                 printf("\n%-13s %-13s %s\n\n", recordTemp.nome, recordTemp.cognome, recordTemp.numeroTelefono);fflush(stdout);
  206.                                                 premiInvio();                                  
  207.                                         }      
  208.                                 }
  209.  
  210.                                 /* Stampo l'intero elenco telefonico */
  211.                 if(opzione==4) stampaElencoTelefonico();
  212.                 if(opzione==5) {
  213.                                         Utente utente, utenteTemp;
  214.                        
  215.                                         /* Resetto i valori della struct utente */
  216.                                         memset(utente.nickname, 0, sizeof(utente.nickname));
  217.                                         memset(utente.password, 0, sizeof(utente.password));
  218.  
  219.                                         /* Resetto i valori della struct utenteTemp */
  220.                                         memset(utenteTemp.nickname, 0, sizeof(utenteTemp.nickname));
  221.                                         memset(utenteTemp.password, 0, sizeof(utenteTemp.password));
  222.  
  223.                                         /* Memorizzo nella struct utente i valori digitati */
  224.                                         printf("\nInserisci nickname e premi INVIO   ");fflush(stdout);
  225.                                         while(scanf("%s", utente.nickname) == -1){
  226.                                                 if(errno != EINTR){
  227.                                                         printf("\nErrore scanf\n");
  228.                                                         chiusuraServer();
  229.                                                 }
  230.                                         }
  231.                                        
  232.                                         /* Cerco nell'archivio l'utente "utente" e lo memorizzo in utenteTemp */
  233.                                         utenteTemp = cercaUtente(utente);
  234.                                         if( strcmp(utente.nickname, utenteTemp.nickname) != 0 ){
  235.                                                
  236.                                                 /* Memorizzo nella struct utente i valori digitati */
  237.                                                 printf("\nInserisci password e premi INVIO   ");fflush(stdout);
  238.                                                 while(scanf("%s", utente.password) == -1){
  239.                                                         if(errno != EINTR){
  240.                                                                 printf("\nErrore scanf\n");
  241.                                                                 chiusuraServer();
  242.                                                         }
  243.                                                 }
  244.                                                 printf("\nInserisci tipo permesso (1.Read only, 2.R/W) e premi INVIO   ");fflush(stdout);
  245.                                                 while(scanf("%d", &utente.permessi) == -1){
  246.                                                         if(errno != EINTR){
  247.                                                                 printf("\nErrore scanf\n");
  248.                                                                 chiusuraServer();
  249.                                                         }
  250.                                                 }
  251.  
  252.                                                 /* Aggiungo l'utente "utente" all'archivio */
  253.                                                 if(-1 == aggiungiUtente(utente)){
  254.                                                         printf("\nOperazione fallita, riprovare...\n");fflush(stdout);
  255.                                                         premiInvio();
  256.                                                 }
  257.                                                 else{
  258.                                                         printf("\nOperazione conclusa con successo!\n");fflush(stdout);
  259.                                                         premiInvio();
  260.                                                 }
  261.                                         }
  262.                                         else{
  263.                                                 printf("\n%s è già presente nell'elenco!\n", utente.nickname);fflush(stdout);
  264.                                                 premiInvio();
  265.                                         }
  266.                                 }
  267.                 if(opzione==6) {
  268.                                         Utente utente, utenteTemp;
  269.  
  270.                                         /* Resetto i valori della struct utente */
  271.                                         memset(utente.nickname, 0, sizeof(utente.nickname));
  272.                                         memset(utente.password, 0, sizeof(utente.password));
  273.  
  274.                                         /* Resetto i valori della struct utenteTemp */
  275.                                         memset(utenteTemp.nickname, 0, sizeof(utenteTemp.nickname));
  276.                                         memset(utenteTemp.password, 0, sizeof(utenteTemp.password));
  277.  
  278.                                         /* Memorizzo nella struct utente i valori digitati */
  279.                                         printf("\nInserisci nickname e premi INVIO   ");fflush(stdout);
  280.                                         while(scanf("%s", utente.nickname) == -1){
  281.                                                 if(errno != EINTR){
  282.                                                         printf("\nErrore scanf\n");
  283.                                                         chiusuraServer();
  284.                                                 }
  285.                                         }
  286.  
  287.                                         /* Cerco nell'archivio l'utente "utente" e lo memorizzo in utenteTemp */
  288.                                         utenteTemp = cercaUtente(utente);
  289.                                         if( strcmp(utente.nickname, utenteTemp.nickname) == 0 ){
  290.  
  291.                                                 /* Cancello l'utente "utente" dall'archivio */
  292.                                                 if(-1 == cancellaUtente(utente)){
  293.                                                         printf("\nOperazione fallita, riprovare...\n");fflush(stdout);
  294.                                                         premiInvio();
  295.                                                 }
  296.                                                 else{
  297.                                                         printf("\nOperazione conclusa con successo!\n");fflush(stdout);
  298.                                                         premiInvio();
  299.                                                 }
  300.                                         }
  301.                                         else{
  302.                                                 printf("\nOperazione impossibile, %s non è presente nell'elenco!\n", utente.nickname);fflush(stdout);
  303.                                                 premiInvio();
  304.                                         }
  305.                                 }
  306.                 if(opzione==7) {
  307.                                         Utente utente, utenteTemp;
  308.  
  309.                                         /* Resetto i valori della struct utente */
  310.                                         memset(utente.nickname, 0, sizeof(utente.nickname));
  311.                                         memset(utente.password, 0, sizeof(utente.password));
  312.  
  313.                                         /* Resetto i valori della struct utenteTemp */
  314.                                         memset(utenteTemp.nickname, 0, sizeof(utenteTemp.nickname));
  315.                                         memset(utenteTemp.password, 0, sizeof(utenteTemp.password));
  316.  
  317.                                         /* Memorizzo nella struct utente i valori digitati */
  318.                                         printf("\nInserire nickname e premere INVIO   ");fflush(stdout);
  319.                                         while(scanf("%s", utente.nickname) == -1){
  320.                                                 if(errno != EINTR){
  321.                                                         printf("\nErrore scanf\n");
  322.                                                         chiusuraServer();
  323.                                                 }
  324.                                         }
  325.  
  326.                                         /* Cerco nell'archivio l'utente "utente" e lo memorizzo in utenteTemp */
  327.                                         utenteTemp = cercaUtente(utente);
  328.                                         if( strcmp(utenteTemp.nickname, "NULL") == 0 ){
  329.                                                 printf("\nUtente inesistente!\n");fflush(stdout);
  330.                                                 premiInvio();
  331.                                         }
  332.                                         else{
  333.                                                 /* Stampo l'utente trovato */
  334.                                                 printf("\n%-13s %-13s %s\n", "NICKNAME", "PASSWORD", "TIPO PERMESSI");fflush(stdout);
  335.                                                 printf("\n%-13s %-13s %d\n\n", utenteTemp.nickname, utenteTemp.password, utenteTemp.permessi);
  336.                                                 premiInvio();
  337.                                         }
  338.                                 }
  339.  
  340.                                 /* Stampo l'intero elenco utenti */
  341.                 if(opzione==8) stampaElencoUtenti();
  342.  
  343.                                 /* Esco dal sottomenù "Manutenzione" */
  344.                 if(opzione==9) break;
  345.  
  346.         }      
  347.  
  348. }