API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 9th, 2019
140
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 27.03 KB | None | 0 0
raw download clone embed print report
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <locale.h>
  3. #include <stdio.h>
  4. #include <windows.h>
  5. #include <math.h>
  6. #include <stdlib.h>
  7. #include <ctype.h>
  8. #include <string.h>
  9. #include <time.h>
  10. # define NUM_COMPUTADORES 4
  11.  
  12. using namespace std;
  13.  
  14.  
  15. /* Estrutura da data */
  16. typedef struct data {
  17.     int ano;
  18.     int mes;
  19.     int dia;
  20.     int hora;
  21.     int min;
  22.     int segundo;
  23. } DATA;
  24.  
  25. /* EStrutura dos utilizadores */
  26. typedef struct utilizadores
  27. {
  28.     int codigoUtilizador;
  29.     char nome[100];
  30.     char morada[150];
  31.     char contacto[10];
  32.     char dataRegisto[20];
  33.     char nomeUtilizador[15];
  34.     char password[15];
  35.     int tipoUser;
  36.     int logado;
  37.     int tempo_total_utilizacao;
  38.     int total_dinheiro_gasto;
  39. } Utilizadores;
  40.  
  41. /* Estrutura dos computadores */
  42. typedef struct computadores
  43. {
  44.     char nome[100];
  45.     int codigoComputador;
  46.     int estado;
  47.     int tempoUtilizacao;
  48.     int total_faturado;
  49. } Computadores;
  50.  
  51. /* Estrutura das sessões */
  52. typedef struct sessoes
  53. {
  54.     int estado;
  55.     int codComputador;
  56.     int codUtilizador;
  57.     char dataInicio;
  58.     int minutosUtilizacao;
  59.     double preco;
  60.     int pagamento;
  61. }Sessoes;
  62.  
  63.  
  64. /* Prototipos das funções */
  65.  
  66. // Menus
  67. char menu_principal(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s); /* Menu principal */
  68. void menu_login(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);                 /* Menu do LOGIN */
  69. void menu_user(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);                  /* Menu principal do user */
  70. void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);       /* Menu principal do user - computador */
  71. void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);     /* Menu principal da ADMIN */
  72. void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n);           /* Menu principal da ADMIN - usuários */
  73. void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s);    /* Menu principal da ADMIN - computadores */
  74.  
  75. // Admin - User
  76. void admin_editar_user(utilizadores *p, int n);                                               /* Admin editar user */
  77. void admin_eliminar_user(utilizadores *p, int n);                       /* Admin eliminar user */
  78. // Admin - Computador
  79. void admin_adicionar_computador(computadores *c, int n);                /* Admin adicionar computador */
  80. void admin_editar_computador();                                         /* Admin editar computador */
  81. void admin_eliminar_computador(computadores *c, int n);                 /* Admin eliminar computador */
  82.  
  83. // User
  84. void user_editar_dados(Utilizadores *p, int n);
  85.  
  86. // Computadores
  87. void computadores_inicializa(Computadores *c, int n);                   /* Inicializa computadores */
  88. void computadores_lista(Computadores *c, int n);                        /* Mostra a lista de computadores */
  89.  
  90. // Utilizadores
  91. void utilizadores_inicializa(Utilizadores *p, int n);                   /* Inicializa os utilizadores*/
  92. void utilizadores_introduzir(Utilizadores *p, data*h, int n);           /* Introduz um novo utilizador */                       // Criar verificações (Repitição de user e outros)
  93. void utilizadores_listar_tabela(Utilizadores *p, data *h, int n);       /* Mostra a lista dos utilizadores com tabela */
  94. void utilizadores_listar_simples(Utilizadores *p, data *h, int n);      /* Mostra a lista dos utilizadores sem tabela */
  95.  
  96. // Tabela
  97. void escreve_espacos_branco(int x);                                     /* Escreve espaços em branco (usado na tabela) */
  98. int conta_numeros(int num);                                             /* Conta a quantidade de numeros de um inteiro */
  99. void tabela_escreve_int(int num, int digitos_tabela);                   /* Escreve um inteiro na tabela */
  100. void tabela_escreve_string(char *string, int digitos_tabela);           /* Escreve uma string na tabela */
  101.  
  102. // Sessoes
  103. void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n);         /* Calcula o preço da sessao */                            // Verificar funcionamento
  104.  
  105. // Outros
  106. void data_registo(DATA *h, int n);                                      /* Diz a data/hora atual */
  107.  
  108.  
  109.  
  110. /*
  111.     Inicializa os computadores
  112.         - Computadores *c -> Apontador para o vetor de computadores
  113.         - n -> Número de computadores
  114. */
  115. void computadores_inicializa(Computadores *c, int n) {
  116.     for (int i = 0; i < NUM_COMPUTADORES; i++) {
  117.         strcpy(c->nome, "Sem Nome");    /* Limpa o nome do computador */
  118.         c->codigoComputador = i + 1;    /* Começa em 1 até n */
  119.         c->estado = -1;                 /* -1 Não existe computador no vetor | 0 livre | 1 ocupado | 2 indisponivel */
  120.         c->tempoUtilizacao = 0;
  121.         c->total_faturado = 0;
  122.         c++;
  123.     }
  124. }
  125.  
  126. /*
  127.     Inicializa os utilizadores
  128.         - Utilizadores *p -> Apontador para o vetor dos utilizadores
  129.         - n -> Numero de utilizadores
  130. */
  131. void utilizadores_inicializa(Utilizadores *p, int n) {
  132.     for (int i = 0; i < n; i++) {
  133.         p->codigoUtilizador = -1;       /* -1 Não tem código | 0 para ADMIN | > 0 para normais */
  134.         p->tempo_total_utilizacao = 0;
  135.         p->total_dinheiro_gasto = 0;
  136.         p->tipoUser = 1;                /* 0 para ADMIN | 1 para normais */
  137.         p->logado = 0;
  138.         p++;
  139.     }
  140. }
  141. /* Guardar Utilizadores em ficheiro Bin */
  142. void guardaUserBin(Utilizadores *p, int n)
  143. {
  144.     int i;
  145.     FILE *f;
  146.     f = fopen("listaUser.dat", "wb");
  147.     for (i = 0; i < n; i++)
  148.     {
  149.         fwrite(p, sizeof(Utilizadores), 1, f); //Guarda o vetor todo no ficheiro
  150.         p++;
  151.     }
  152.     fclose(f);
  153. }
  154.  
  155. /* Ler utilizadores do ficheiro Bin */
  156. void leUsersBin(Utilizadores *p, int n)
  157. {
  158.     int i;
  159.     FILE *f;
  160.     f = fopen("listaUser.dat", "rb");
  161.     if (f == NULL)
  162.     {
  163.         f = fopen("listaUser.dat", "wb");
  164.         return;
  165.     }
  166.     i = 0;
  167.     while (!feof(f))
  168.     {
  169.         i++;
  170.         if (i < n)
  171.         {
  172.             fread(p, sizeof(Utilizadores), 1, f);
  173.             p++;
  174.         }
  175.         else
  176.         {
  177.             fclose(f);
  178.             return;
  179.         }
  180.     }
  181.     fclose(f);
  182. }
  183.  
  184. /* Guardar Computadores em ficheiro Bin */
  185. void guardaComputadorBin(Computadores *c, int n)
  186. {
  187.     int i;
  188.     FILE *f;
  189.     f = fopen("listaComputador.dat", "wb");
  190.     for (i = 0; i < n; i++)
  191.     {
  192.         fwrite(c, sizeof(Computadores), 1, f); //Guarda o vetor todo no ficheiro
  193.         c++;
  194.     }
  195.     fclose(f);
  196. }
  197.  
  198. /* Ler computadores do ficheiro Bin */
  199. void leComputadorBin(Computadores *c, int n)
  200. {
  201.     int i;
  202.     FILE *f;
  203.     f = fopen("listaComputador.dat", "rb");
  204.     if (f == NULL)
  205.     {
  206.         f = fopen("listaComputador.dat", "wb");
  207.         return;
  208.     }
  209.     i = 0;
  210.     while (!feof(f))
  211.     {
  212.         i++;
  213.         if (i < n)
  214.         {
  215.             fread(c, sizeof(Computadores), 1, f);
  216.             c++;
  217.         }
  218.         else
  219.         {
  220.             fclose(f);
  221.             return;
  222.         }
  223.     }
  224.     fclose(f);
  225. }
  226.  
  227. /* Guardar Sessoes em ficheiro Bin */
  228. void guardaSessoesBin(Sessoes *s, int n)
  229. {
  230.     int i;
  231.     FILE *f;
  232.     f = fopen("listaSessoes.dat", "wb");
  233.     for (i = 0; i < n; i++)
  234.     {
  235.         fwrite(s, sizeof(Sessoes), 1, f); //Guarda o vetor todo no ficheiro
  236.         s++;
  237.     }
  238.     fclose(f);
  239. }
  240.  
  241. /* Ler Sessoes do ficheiro Bin */
  242. void leSessoesBin(Sessoes *s, int n)
  243. {
  244.     int i;
  245.     FILE *f;
  246.     f = fopen("listaSessoes.dat", "rb");
  247.     if (f == NULL)
  248.     {
  249.         f = fopen("listaSessoes.dat", "wb");
  250.         return;
  251.     }
  252.     i = 0;
  253.     while (!feof(f))
  254.     {
  255.         i++;
  256.         if (i < n)
  257.         {
  258.             fread(s, sizeof(Sessoes), 1, f);
  259.             s++;
  260.         }
  261.         else
  262.         {
  263.             fclose(f);
  264.             return;
  265.         }
  266.     }
  267.     fclose(f);
  268. }
  269.  
  270. /* Guardar Utilizadores em TXT*/
  271. void guardaUsersTxt(Utilizadores *p, int n)
  272. {
  273.     FILE *f;
  274.     int i;
  275.     f = fopen("listaUsers.txt", "w");
  276.     if (f == NULL)
  277.     {
  278.         f = fopen("listaUsers.txt", "w");
  279.     }
  280.     for (i = 0; i < n; i++)
  281.     {
  282.         if (p->codigoUtilizador != -1)
  283.         {
  284.             fprintf(f, "\Código Utilizador: %d; Nome: %s; Morada: %s; Contacto: %d; Data Registo: %s; Nome Utilizador: %s; Password: %s; Tipo User: %d; Tempo Utilização: %d; Total Dinheiro Gasto: %d\n", i + 1, p->codigoUtilizador, p->nome, p->morada, p->contacto, p->dataRegisto, p->nomeUtilizador, p->password, p->tipoUser, p->tempo_total_utilizacao, p->total_dinheiro_gasto);
  285.         }
  286.         p++;
  287.     }
  288.     fclose(f);
  289. }
  290.  
  291. /* Guardar Computadores em TXT*/
  292. void guardaComputadoresTxt(Computadores *c, int n)
  293. {
  294.     FILE *f;
  295.     int i;
  296.     f = fopen("listaComputadores.txt", "w");
  297.     if (f == NULL)
  298.     {
  299.         fprintf(stderr, "Impossível abrir ficheiro");
  300.         return;
  301.     }
  302.     for (i = 0; i < n; i++)
  303.     {
  304.         if (c->estado != -1)
  305.         {
  306.             fprintf(f, "\nCódigo Computador: %d; Nome: %s; Estado: %d; Tempo Utilização: %d; Total Faturado: %d;\n", i + 1, c->codigoComputador, c->nome, c->estado, c->tempoUtilizacao, c->total_faturado);
  307.         }
  308.         c++;
  309.     }
  310.     fclose(f);
  311. }
  312.  
  313. /* Guardar Sessoes em TXT*/
  314. void guardaSessoesTXT(Sessoes *s, int n)
  315. {
  316.     FILE *f;
  317.     int i;
  318.     f = fopen("listaSessoes.txt", "w");
  319.     if (f == NULL)
  320.     {
  321.         fprintf(stderr, "Impossível abrir ficheiro");
  322.         return;
  323.     }
  324.     for (i = 0; i < n; i++)
  325.     {
  326.         if (s->estado != -1)
  327.         {
  328.             fprintf(f, "\nEstado da Sessão: %d; Código Computador: %d; Código Utilizador: %d; Data Inicio: %s; Minutos Utilização: %d; Preço: %d; Pagamento: %d\n", i + 1, s->estado, s->codComputador, s->codUtilizador, s->dataInicio, s->minutosUtilizacao, s->preco, s->pagamento);
  329.         }
  330.         s++;
  331.     }
  332.     fclose(f);
  333. }
  334.  
  335. /* Escreve x espacos em branco (usado para formatar a tabela) */
  336. void escreve_espacos_branco(int x)
  337. {
  338.     for (int i = 0; i < x; i++) printf(" ");
  339. }
  340.  
  341. /* Conta a quantidade de caracteres de um numero */
  342. int conta_numeros(int num)
  343. {
  344.     if (num < 0) return 0;
  345.     else if (num < 10) return 1;
  346.     else if (num < 100) return 2;
  347.     else if (num < 1000) return 3;
  348.     else if (num < 10000) return 4;
  349.     return 0;
  350. }
  351.  
  352. /* Escreve um inteiro na tabela */
  353. void tabela_escreve_int(int num, int digitos_tabela)
  354. {
  355.     // Conta numeros do inteiro
  356.     int num_dig_codUti = conta_numeros(num);
  357.  
  358.     // Calcula a diferença de digitos necessários da tabela e os digitos do inteiro
  359.     int dif_digitos = digitos_tabela - num_dig_codUti;
  360.  
  361.     // Se a diferença for maior que 0, escreve o inteiro e os espaços em branco necessários (dif_digitos + 1 -> +1 serve para colocar o espaço antes da |)
  362.     if (dif_digitos > 0)
  363.     {
  364.         printf("| %d", num);
  365.         escreve_espacos_branco(dif_digitos + 1);
  366.     }
  367.     else printf("| %d ", num);
  368. }
  369.  
  370. /* Escreve uma string na tabela */
  371. void tabela_escreve_string(char *string, int digitos_tabela)
  372. {
  373.     // Calcula tamanho da string
  374.     int tam_nome = strlen(string);
  375.  
  376.     // Calcula a diferença de digitos necessários da tabela e os digitos da string
  377.     int dif_caracteres = digitos_tabela - tam_nome;
  378.  
  379.     // Se a diferença for maior que 0, escreve a string e os espaços em branco necessários (dif_digitos + 1 -> +1 serve para colocar o espaço antes da |)
  380.     if (dif_caracteres > 0)
  381.     {
  382.         printf("| %s", string);
  383.         escreve_espacos_branco(dif_caracteres + 1);
  384.     }
  385.     else printf("| %s ", string);
  386. }
  387.  
  388. /* Lista dos utilizadores com tabela */
  389. void utilizadores_listar_tabela(Utilizadores *p, data *h, int n)
  390. {
  391.     // HEADER
  392.     printf("================================================================================= \n");
  393.     printf("| COD |      USER      |  CONTACTO  | TIPO | LOGADO | TEMPO TOTAL | TOTAL GASTO | \n");
  394.     printf("================================================================================= \n");
  395.  
  396.     // Loop pelos users
  397.     for (int i = 0; i < n; i++)
  398.     {
  399.         // Escreve as infos
  400.         if (p->codigoUtilizador != -1) {
  401.             tabela_escreve_int(p->codigoUtilizador, 3);
  402.             tabela_escreve_string(p->nomeUtilizador, 14);
  403.             tabela_escreve_string(p->contacto, 10);
  404.             tabela_escreve_int(p->tipoUser, 4);
  405.             tabela_escreve_int(p->logado, 6);
  406.             tabela_escreve_int(p->tempo_total_utilizacao, 11);
  407.             tabela_escreve_int(p->total_dinheiro_gasto, 11);
  408.             printf("|\n");
  409.         }
  410.         // Passa para o proximo user
  411.         p++;
  412.     }
  413.     // FOOTER
  414.     printf("|=====|================|============|======|========|=============|=============| \n");
  415.  
  416.     system("pause");
  417.  
  418. }
  419.  
  420. /* Tabela de preços */
  421. void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n) {
  422.     double preco;
  423.     p->codigoUtilizador = s->codUtilizador;
  424.     if (s->minutosUtilizacao < 30)
  425.         preco = (double)s->minutosUtilizacao * 0.05;
  426.     else if (s->minutosUtilizacao > 30)
  427.         preco = 30 * 0.05 + ((double)s->minutosUtilizacao - 30) * 0.025;
  428.  
  429.     if (preco < 2)
  430.         s->preco = 2;
  431.     else s->preco = preco;
  432.  
  433. }
  434.  
  435. /* Regista a data atual */
  436. void data_registo(DATA *h, int n)
  437. {
  438.     SYSTEMTIME st;
  439.     GetSystemTime(&st);
  440.     for (int i = 0; i < n; i++) {
  441.         h->ano = st.wYear;
  442.         h->mes = st.wMonth;
  443.         h->dia = st.wDay;
  444.         h->hora = st.wHour;
  445.         h->min = st.wMinute;
  446.         h->segundo = st.wSecond;
  447.         h++;
  448.     }
  449. }
  450.  
  451. /* Mostra a lista de computadores */
  452. void computadores_lista(Computadores *c, int n)
  453. {
  454.     printf("\n\n LISTA DE COMPUTADORES \n\n");
  455.     int i;
  456.  
  457.     for (i = 0; i < NUM_COMPUTADORES; i++)
  458.     {
  459.         if (c->estado != -1) {
  460.             printf("Código: %d\n", c->codigoComputador);
  461.             printf("Nome: %s\n", c->nome);
  462.             printf("Estado: %d\n", c->estado);
  463.             printf("Faturado: %d\n", c->total_faturado);
  464.             printf("Tempo Utilização: %d\n\n", c->tempoUtilizacao);
  465.  
  466.             c++;
  467.         }
  468.     }
  469. }
  470.  
  471. /* Adicionar Utilizador */
  472. void utilizadores_introduzir(Utilizadores *p, data*h, int n)
  473. {
  474.     int i = 0;
  475.     while ((p->codigoUtilizador != -1) && (i < n)) {
  476.         i++;
  477.         p++;
  478.         h++;
  479.     }
  480.  
  481.     if (i < n) {
  482.         data_registo(h, n);
  483.         printf("\nInserir novo utilizador no sistema\n\n");
  484.  
  485.         fseek(stdin, 0, 2);
  486.         printf("\nInsira o nome completo: ");
  487.         gets_s(p->nome);
  488.  
  489.         //Percorrer todo o vetor para verificar se há utilizadores com nomes iguais (POR FAZER!!!)
  490.         fseek(stdin, 0, 2);
  491.         printf("\nInsira o nome de utilizador: ");
  492.         gets_s(p->nomeUtilizador);
  493.  
  494.         fseek(stdin, 0, 2);
  495.         printf("\nInsira a morada: ");
  496.         gets_s(p->morada);
  497.  
  498.         printf("\nInsira o contacto de telefone: ");
  499.         gets_s(p->contacto);
  500.  
  501.         fseek(stdin, 0, 2);
  502.         printf("\nInsira password: ");
  503.         gets_s(p->password);
  504.  
  505.         printf("\nUtilizador registado em %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
  506.         p->codigoUtilizador = i;
  507.         if (p->codigoUtilizador == 0) p->tipoUser = 0;
  508.  
  509.         printf("\nUtilizador registado na posicao %d\n", i + 1);
  510.     }
  511.     else printf("\n O programa nao tem espaco para mais utilizadores!! \n");
  512.     system("pause");
  513.  
  514. }
  515.  
  516. /* Mostra utilizadores sem tabela */
  517. void utilizadores_listar_simples(Utilizadores *p, data *h, int n)
  518. {
  519.     int i;
  520.     for (i = 0; i < n; i++)
  521.     {
  522.         if (p->codigoUtilizador != -1) {
  523.             printf("\nO utilizador %s tem os seguintes dados: ", p->nomeUtilizador);
  524.             printf("\nNome: %s", p->nome);
  525.             printf("\nMorada: %s", p->morada);
  526.             printf("\nContacto: %s", p->contacto);
  527.             printf("\nPassword: %s", p->password);
  528.             printf("\nData de Registo: %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
  529.         }
  530.         p++;
  531.         h++;
  532.     }
  533. }
  534.  
  535. /* Admin editar user */
  536. void admin_editar_user(utilizadores *p, int n)
  537. {
  538.     int numero_utilizadores_registados = 0;
  539.     int i = 0;
  540.     int codigo_utilizador;
  541.     int aux_reset = 0;
  542.     char opcao;
  543.     // Ve os utilizadores existentes
  544.     while (i < n)
  545.     {
  546.         if (p->codigoUtilizador != -1)
  547.         {
  548.             numero_utilizadores_registados++;
  549.             aux_reset++;
  550.             p++;
  551.         }
  552.         i++;
  553.     }
  554.  
  555.     if (aux_reset != 0) { //p-> volta ao inicio
  556.  
  557.         aux_reset--;
  558.         p--;
  559.  
  560.     }
  561.  
  562.  
  563.     //Elimina o user
  564.     if (numero_utilizadores_registados < n) {
  565.  
  566.         do {
  567.             printf("\nQual o utilizador que pretende editar? Use o codigo.");
  568.             scanf("%d", &codigo_utilizador);
  569.         } while ((codigo_utilizador < 0) || (codigo_utilizador >= numero_utilizadores_registados));
  570.  
  571.     }
  572.  
  573.     while (p->codigoUtilizador != codigo_utilizador) { //Procura o utilizador selecionado
  574.         p++;
  575.     }
  576.     system("CLS");
  577.     printf("\nEscolheu o utilizador |%d|", p->codigoUtilizador);
  578.  
  579.     do {
  580.  
  581.         do {
  582.             printf("\n#--------------------------#");
  583.             printf("\n     Nome                 (1)      \n");
  584.             printf("\n     Morada               (2)      \n");
  585.             printf("\n     Contacto             (3)      \n");
  586.             printf("\n     Nome de utilizador   (4)      \n");
  587.             printf("\n     Password             (5)      \n");
  588.             printf("\n     Sair                 (0)      \n");
  589.             printf("\n#--------------------------#");
  590.             printf("\nO que deseja editar?");
  591.             scanf(" %c", &opcao);
  592.         } while (opcao < '0' || opcao > '5');
  593.  
  594.         switch (opcao) {
  595.         case '1':
  596.             fseek(stdin, 0, 2);
  597.             printf("\nInsira novo nome: ");
  598.             gets_s(p->nome);
  599.             system("CLS");
  600.             printf("\nNome alterado!\n");
  601.             break;
  602.         case '2':
  603.             fseek(stdin, 0, 2);
  604.             printf("\nInsira nova morada: ");
  605.             gets_s(p->morada);
  606.             system("CLS");
  607.             printf("\nMorada alterada!\n");
  608.             break;
  609.         case '3':
  610.             fseek(stdin, 0, 2);
  611.             printf("\nInsira novo contacto: ");
  612.             gets_s(p->contacto);
  613.             system("CLS");
  614.             printf("\nContacto alterado!\n");
  615.             break;
  616.         case '4':
  617.             fseek(stdin, 0, 2);
  618.             printf("\nInsira novo nome de utilizador: ");
  619.             gets_s(p->nomeUtilizador);
  620.             system("CLS");
  621.             printf("\nNome de utilizador alterado!\n");
  622.             break;
  623.         case '5':
  624.             fseek(stdin, 0, 2);
  625.             printf("\nInsira nova password: ");
  626.             gets_s(p->password);
  627.             system("CLS");
  628.             printf("\nPassword alterada!\n");
  629.         case '0':
  630.             break;
  631.         default:
  632.             printf("\nOpção inválida.");
  633.             break;
  634.         }
  635.     } while (opcao != '0');
  636.  
  637.  
  638. }
  639.  
  640. /* Admin elimiar user */
  641. void admin_eliminar_user(utilizadores *p, int n)
  642. {
  643.     int numero_utilizadores_registados = 0;
  644.     int i = 0;
  645.     int codigo_utilizador;
  646.     int aux_reset = 0;
  647.  
  648.     // Ve os utilizadores existentes
  649.     while (i < n)
  650.     {
  651.         if (p->codigoUtilizador != -1)
  652.         {
  653.             numero_utilizadores_registados++;
  654.             aux_reset++;
  655.             p++;
  656.         }
  657.         i++;
  658.     }
  659.  
  660.     if (aux_reset != 0) { //p-> volta ao inicio
  661.  
  662.         aux_reset--;
  663.         p--;
  664.  
  665.     }
  666.  
  667.  
  668.     //Elimina o user
  669.     if (numero_utilizadores_registados < n) {
  670.  
  671.         do {
  672.             printf("\n");
  673.             printf("=======================================================\n");
  674.             printf("Introduza o codigo do utilizador que pretende remover: ");
  675.             printf("\n=======================================================\n\n");
  676.             scanf("%d", &codigo_utilizador);
  677.         } while ((codigo_utilizador < 0) || (codigo_utilizador >= numero_utilizadores_registados));
  678.  
  679.     }
  680.  
  681.     while (p->codigoUtilizador != codigo_utilizador) { //Procura o utilizador selecionado
  682.         p++;
  683.     }
  684.     p->codigoUtilizador = -1;
  685.     printf("\nO utilizador %d foi removido com sucesso!", codigo_utilizador);
  686.  
  687. }
  688.  
  689. /* Admin eliminar computador */
  690. void admin_eliminar_computador(computadores *c, int n)
  691. {
  692.     int computadores_existentes = 0;
  693.     int i = 0;
  694.     int codigo_computador;
  695.     int aux_reset = 0;
  696.     // Vai ver todos os computadores
  697.     while (i < NUM_COMPUTADORES)
  698.     {
  699.         if (c->estado != -1)
  700.         {
  701.             computadores_existentes++;
  702.             c++;
  703.             aux_reset++;
  704.         }
  705.         i++;
  706.     }
  707.  
  708.     if (aux_reset != 0) { //p-> volta ao inicio
  709.  
  710.         aux_reset--;
  711.         c--;
  712.  
  713.     }
  714.  
  715.  
  716.     //Fecha o pc
  717.     if (computadores_existentes <= NUM_COMPUTADORES) {
  718.  
  719.         do {
  720.             printf("\n");
  721.             printf("======================================================\n");
  722.             printf("Introduza o codigo do computador que pretende fechar: ");
  723.             printf("\n======================================================\n\n");
  724.             scanf("%d", &codigo_computador);
  725.         } while ((codigo_computador < 1) || (codigo_computador > computadores_existentes));
  726.  
  727.     }
  728.  
  729.     while (c->codigoComputador != codigo_computador) { //Procura o computador selecionado
  730.         c++;
  731.     }
  732.  
  733.     if (c->estado == 0) {
  734.         c->estado = 2;
  735.         printf("\nO computador %d esta agora indisponivel!", c->codigoComputador);
  736.     }
  737.     else printf("\nO computador nao existe ou esta a ser utilizado!");
  738.  
  739.  
  740. }
  741.  
  742. /* Admin editar computador */
  743. void admin_editar_computador()
  744. {
  745.     printf("\nFuncao de editar pc!");
  746.     system("pause");
  747.     //POR FAZER
  748. }
  749.  
  750. /* Admin adicionar computador */
  751. void admin_adicionar_computador(Computadores *c)
  752. {
  753.     int computadores_ocupados = 0;
  754.     int i = 0;
  755.  
  756.     // Vai ver todos os computadores
  757.     while (i < NUM_COMPUTADORES)
  758.     {
  759.         if (c->estado != -1)
  760.         {
  761.             computadores_ocupados++;
  762.             c++;
  763.         }
  764.         i++;
  765.     }
  766.  
  767.     // Se os computadores usados forem menos que os computadores existentes
  768.     if (computadores_ocupados < NUM_COMPUTADORES)
  769.     {
  770.         // LOOP que só para quando o computador for adicionado
  771.         while (1)
  772.         {
  773.             // Se o estado do PC for igual a -1
  774.             if ((c->estado == -1))
  775.             {
  776.                 fseek(stdin, 0, 2);
  777.                 printf("\nInsira o nome computador: ");
  778.                 gets_s(c->nome);
  779.                 printf("\nO computador %s foi adicionado.\nCÓDIGO: %d\n\n", c->nome, c->codigoComputador);
  780.                 c->estado = 0;
  781.                 c++;
  782.                 break;
  783.             }
  784.             else c++;
  785.         }
  786.     }
  787.     else printf("\nNão é possivel adicionar mais computadores, lista cheia!");
  788.  
  789.     system("pause");
  790.  
  791. }
  792.  
  793. /* User editar dados */
  794. void user_editar_dados(Utilizadores *p, int n)
  795. {
  796.  
  797.     system("pause");
  798.     //POR FAZER
  799. }
  800.  
  801. /* Menu principal */
  802. char menu_principal(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  803. {
  804.     leSessoesBin(s, n);
  805.     leUsersBin(p, n);
  806.     leComputadorBin(c, n);
  807.  
  808.     char op;
  809.  
  810.     printf("\n#--------------------------#");
  811.     printf("\n     Registar      (1)     \n");
  812.     printf("\n     Logar         (2)     \n");
  813.     printf("\n     Sair          (0)     \n");
  814.     printf("\n#--------------------------#");
  815.  
  816.     do {
  817.         printf("\nQual a opção? ");
  818.         scanf(" %c", &op);
  819.     } while (op < '0' || op > '2');
  820.  
  821.     system("cls");
  822.     return op;
  823. }
  824.  
  825. /* Menu principal do user */
  826. void menu_user(Utilizadores *p, data *h, computadores *c, int n, sessoes *s)
  827. {
  828.     char op;
  829.  
  830.     printf("\n#--------------------------------------------#");
  831.     printf("\n        Ir para PC                    (1)      \n");
  832.     printf("\n        Editar dados                  (2)      \n");
  833.     printf("\n        Sair                          (0)      \n");
  834.     printf("\n#--------------------------------------------#");
  835.  
  836.     do
  837.     {
  838.         printf("\nQual a opção? ");
  839.         scanf(" %c", &op);
  840.     } while (op < '0' || op > '2');
  841.  
  842.     switch (op)
  843.     {
  844.     case '1':
  845.         menu_user_computador(p, h, c, n, s);
  846.         break;
  847.     case '2':
  848.         user_editar_dados(p, n); //POR FAZER
  849.         break;
  850.     case '0':
  851.         menu_principal(p, h, c, n, s);
  852.         break;
  853.     default:
  854.         printf("\nOpção inválida.");
  855.         break;
  856.     }
  857.     system("cls");
  858. }
  859.  
  860. /* Menu principal do user - computador */
  861. void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  862. {
  863.     char op;
  864.  
  865.     printf("\n#--------------------------------------------#");
  866.     printf("\n        Cena 1                  (1)      \n");
  867.     printf("\n        Cena 2                  (2)      \n");
  868.     printf("\n        Sair da sessao          (0)      \n");
  869.     printf("\n#--------------------------------------------#");
  870.  
  871.     do {
  872.         printf("\nQual a opção? ");
  873.         scanf(" %c", &op);
  874.     } while (op < '0' || op > '2');
  875.  
  876.     switch (op)
  877.     {
  878.     case '1':
  879.         //VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
  880.         break;
  881.     case '2':
  882.         //VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
  883.         break;
  884.     case '0':
  885.         menu_user(p, h, c, n, s);
  886.         break;
  887.     default:
  888.         printf("\nOpção inválida.");
  889.         break;
  890.     }
  891.     system("cls");
  892.  
  893. }
  894.  
  895. /* Menu principal da admin */
  896. void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  897. {
  898.     char op;
  899.  
  900.     do
  901.     {
  902.         printf("\n#--------------------------#");
  903.         printf("\n     USERS            (1)      \n");
  904.         printf("\n     PCS              (2)      \n");
  905.         printf("\n     SESSOES          (3)      \n");
  906.         printf("\n     GUARDAR DADOS    (4)      \n");
  907.         printf("\n     Sair             (0)      \n");
  908.         printf("\n#--------------------------#");
  909.  
  910.         do {
  911.             printf("\nQual a opção? ");
  912.             scanf(" %c", &op);
  913.  
  914.         } while (op < '0' || op > '5');
  915.  
  916.         switch (op)
  917.         {
  918.         case '1':
  919.             menu_admin_users(p, h, c, n);
  920.             break;
  921.         case '2':
  922.             menu_admin_computadores(p, h, c, n, s);
  923.             break;
  924.         case '3':
  925.             //menu_admin_sessoes(s, h, c, n);
  926.             break;
  927.         case '4':
  928.             guardaUserBin(p, n);
  929.             guardaComputadorBin(c, n);
  930.             guardaSessoesBin(s, n);
  931.             //guardaComputadoresTxt(c, n);
  932.             guardaUsersTxt(p, n);
  933.             //guardaSessoesTXT(s, n);
  934.             menu_admin(p, h, c, n, s);
  935.             break;
  936.         case '0':
  937.             menu_principal(p, h, c, n, s);
  938.             break;
  939.         default:
  940.             printf("\nOpção inválida 1.");
  941.             break;
  942.         }
  943.     } while (op != '0');
  944.  
  945.     system("cls");
  946.  
  947. }
  948.  
  949. /* Menu principal da admin - Users */
  950. void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n)
  951. {
  952.     char op;
  953.  
  954.     do
  955.     {
  956.         printf("\n#--------------------------#");
  957.         printf("\n     Lista de users   (1)      \n");
  958.         printf("\n     Adicionar user   (2)      \n");
  959.         printf("\n     Editar user      (3)      \n");
  960.         printf("\n     Eliminar user    (4)      \n");
  961.         printf("\n     Sair             (0)      \n");
  962.         printf("\n#--------------------------#");
  963.         do {
  964.             printf("\nQual a opção? ");
  965.             scanf(" %c", &op);
  966.  
  967.         } while (op < '0' || op > '4');
  968.         switch (op) {
  969.         case '1':
  970.             utilizadores_listar_tabela(p, h, n);
  971.  
  972.             break;
  973.         case '2':
  974.             utilizadores_introduzir(p, h, n);
  975.             break;
  976.         case '3':
  977.             admin_editar_user(p, n);
  978.             break;
  979.         case '4':
  980.             utilizadores_listar_tabela(p, h, n);
  981.             admin_eliminar_user(p, n);
  982.             break;
  983.         case '0':
  984.             break;
  985.         default:
  986.             printf("\nOpção inválida. ..");
  987.             break;
  988.         }
  989.     } while (op != '0');
  990.  
  991.  
  992. }
  993.  
  994. /* Menu principal da admin - Computadores */
  995. void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  996. {
  997.     char op;
  998.  
  999.     do {
  1000.         printf("\n#--------------------------#");
  1001.         printf("\n     Lista de PCs   (1)      \n");
  1002.         printf("\n     Adicionar PC   (2)      \n");
  1003.         printf("\n     Editar PC      (3)      \n");
  1004.         printf("\n     Eliminar PC    (4)      \n");
  1005.         printf("\n     Sair           (0)      \n");
  1006.         printf("\n#--------------------------#");
  1007.  
  1008.  
  1009.         printf("\nQual a opção? ");
  1010.         scanf(" %c", &op);
  1011.  
  1012.  
  1013.  
  1014.         switch (op)
  1015.         {
  1016.         case '1':
  1017.             computadores_lista(c, n);
  1018.             menu_admin_computadores(p, h, c, n, s);
  1019.             break;
  1020.         case '2':
  1021.             admin_adicionar_computador(c); //POR FAZER
  1022.             break;
  1023.         case '3':
  1024.             admin_editar_computador();  //POR FAZER
  1025.             break;
  1026.         case '4':
  1027.             admin_eliminar_computador(c, n); //POR FAZER
  1028.             break;
  1029.         case '0':
  1030.             menu_admin(p, h, c, n, s);
  1031.             break;
  1032.         default:
  1033.             printf("\nOpção inválida.");
  1034.             break;
  1035.         }
  1036.     } while (op != '0');
  1037. }
  1038.  
  1039. /* Menu do LOGIN */
  1040. void menu_login(Utilizadores *p, data *h, computadores *c, int n, sessoes *s)
  1041. {
  1042.     int i, cmpStringUser, cmpStringPass;
  1043.     char nome[15], password[15];
  1044.     Utilizadores *user = new Utilizadores;
  1045.     *user = *p;
  1046.     int nUsers = n;
  1047.  
  1048.     fseek(stdin, 0, 2);
  1049.     printf("\nInsira o nome de utilizador: ");
  1050.     gets_s(nome);
  1051.     fseek(stdin, 0, 2);
  1052.     printf("\nInsira a password: ");
  1053.     gets_s(password);
  1054.  
  1055.     for (i = 0; i < n; i++)
  1056.     {
  1057.         cmpStringUser = strcmp(nome, p->nomeUtilizador);
  1058.         cmpStringPass = strcmp(password, p->password);
  1059.  
  1060.         if ((cmpStringUser == 0 && cmpStringPass == 0))
  1061.         {
  1062.             if (p->codigoUtilizador == 0)
  1063.                 menu_admin(p, h, c, n, s);
  1064.             else if (p->codigoUtilizador > 0)
  1065.                 menu_user(p, h, c, n, s);
  1066.         }
  1067.         else p++;
  1068.     }
  1069.     printf("\nErrado.\n");
  1070.     system("pause");
  1071. }
  1072.  
  1073. /* Main */
  1074. void main()
  1075. {
  1076.     setlocale(LC_ALL, ""); //Caracteres acentuados
  1077.  
  1078.  
  1079.     Utilizadores user_logado;
  1080.  
  1081.     Utilizadores user[10];
  1082.     int nUsers = 10;
  1083.  
  1084.  
  1085.     int nComputadores = 20;
  1086.     Computadores pc[NUM_COMPUTADORES];
  1087.     data h[10];
  1088.     sessoes s[10];
  1089.     computadores_inicializa(pc, nComputadores);
  1090.  
  1091.  
  1092.     char ope;
  1093.     utilizadores_inicializa(user, nUsers);
  1094.  
  1095.  
  1096.     do {
  1097.         ope = menu_principal(user, h, pc, nUsers, s);
  1098.  
  1099.         switch (ope) {
  1100.         case '1':
  1101.  
  1102.             utilizadores_introduzir(user, h, nUsers);
  1103.             system("cls");
  1104.             break;
  1105.         case '2':
  1106.             menu_login(user, h, pc, nUsers, s);
  1107.             system("cls");
  1108.             break;
  1109.         case '3':
  1110.             menu_admin(user, h, pc, nUsers, s);
  1111.             system("cls");
  1112.             break;
  1113.         case '0':
  1114.             ope = '0';
  1115.             break;
  1116.         default:
  1117.             printf("\nOpção inválida.");
  1118.             break;
  1119.         }
  1120.     } while (ope != '0');
  1121. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!