API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 7th, 2019
102
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.04 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. /* Variáveis globais */
  64. int user_logado = -1;
  65.  
  66. /* Prototipos das funções */
  67.  
  68. // Menus
  69. char menu_principal(); /* Menu principal */
  70. void menu_login(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s); /* Menu do LOGIN */
  71. void menu_user(Utilizadores *p, data *h, computadores *c, int n); /* Menu principal do user */
  72. void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n); /* Menu principal do user - computador */
  73. void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s); /* Menu principal da ADMIN */
  74. void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n); /* Menu principal da ADMIN - usuários */
  75. void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s); /* Menu principal da ADMIN - computadores */
  76. void menu_admin_sessoes(Sessoes *s, data *h, computadores *c, int n); /* Menu principal da ADMIN - sessoes */
  77.  
  78. // Admin - User
  79. void admin_editar_user(); /* Admin editar user */
  80. void admin_eliminar_user(); /* Admin eliminar user */
  81.  
  82. // Admin - Computador
  83. void admin_adicionar_computador(Computadores *c); /* Admin adicionar computador */
  84. void admin_editar_computador(); /* Admin editar computador */
  85. void admin_eliminar_computador(); /* Admin eliminar computador */
  86.  
  87. // Admin - Sessoes
  88. void admin_adicionar_sessoes(Sessoes *s); /* Admin adicionar sessão */
  89.  
  90. // User
  91. void user_editar_dados(Utilizadores *p, int n);
  92.  
  93. // Computadores
  94. void computadores_inicializa(Computadores *c, int n); /* Inicializa computadores */
  95. void computadores_lista(Computadores *c, int n); /* Mostra a lista de computadores */
  96.  
  97. // Utilizadores
  98. void utilizadores_inicializa(Utilizadores *p, int n); /* Inicializa os utilizadores*/
  99. void utilizadores_introduzir(Utilizadores *p, data*h, int n); /* Introduz um novo utilizador */ // Criar verificações (Repitição de user e outros)
  100. void utilizadores_listar_tabela(Utilizadores *p, data *h, int n); /* Mostra a lista dos utilizadores com tabela */
  101. void utilizadores_listar_simples(Utilizadores *p, data *h, int n); /* Mostra a lista dos utilizadores sem tabela */
  102. int utilizadores_codigo_mais_recente(Utilizadores *p, int n); /* Encontra o codigo de utilizador mais recente do usuario */
  103.  
  104. // Tabela
  105. void escreve_espacos_branco(int x); /* Escreve espaços em branco (usado na tabela) */
  106. int conta_numeros(int num); /* Conta a quantidade de numeros de um inteiro */
  107. void tabela_escreve_int(int num, int digitos_tabela); /* Escreve um inteiro na tabela */
  108. void tabela_escreve_string(char *string, int digitos_tabela); /* Escreve uma string na tabela */
  109.  
  110. // Sessoes
  111. void sessoes_inicializa(Sessoes *s, int n); /* Inicializa as sessoe */
  112. void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n); /* Calcula o preço da sessao */ // Verificar funcionamento
  113. void sessoes_listar(Sessoes *s); /* Lista as sessões existentes */
  114.  
  115. // Outros
  116. void data_registo(DATA *h, int n); /* Diz a data/hora atual */
  117.  
  118.  
  119.  
  120. /*
  121. Inicializa os computadores
  122. - Computadores *c -> Apontador para o vetor de computadores
  123. - n -> Número de computadores
  124. */
  125. void computadores_inicializa(Computadores *c, int n) {
  126. for (int i = 0; i < NUM_COMPUTADORES; i++) {
  127. sprintf(c->nome, "-------"); /* Limpa o nome do computador */
  128. c->codigoComputador = i + 1; /* Começa em 1 até n */
  129. c->estado = -1; /* -1 Não existe computador no vetor | 0 livre | 1 ocupado | 2 indisponivel */
  130. c->tempoUtilizacao = 0;
  131. c->total_faturado = 0;
  132. c++;
  133. }
  134. }
  135.  
  136. /*
  137. Inicializa os utilizadores
  138. - Utilizadores *p -> Apontador para o vetor dos utilizadores
  139. - n -> Numero de utilizadores
  140. */
  141. void utilizadores_inicializa(Utilizadores *p, int n) {
  142. for (int i = 0; i < n; i++) {
  143. p->codigoUtilizador = -1; /* -1 Não tem código | 0 para ADMIN | > 0 para normais */
  144. p->tempo_total_utilizacao = 0;
  145. p->total_dinheiro_gasto = 0;
  146. p->tipoUser = 1; /* 0 para ADMIN | 1 para normais */
  147. p->logado = 0;
  148. p++;
  149. }
  150. }
  151.  
  152. /*
  153. Inicializa as sessoes:
  154. - Sessoes *s -> Apontador para o vetor das sessoes
  155. - n -> numero inicial de sessoes
  156. */
  157. void sessoes_inicializa(Sessoes *s, int n)
  158. {
  159. int i = 0;
  160. while (i < n)
  161. {
  162. s->codComputador = -1;
  163. s->codUtilizador = -1;
  164. s->dataInicio = -1;
  165. s->estado = -1;
  166. s->minutosUtilizacao = -1;
  167. s->pagamento = -1;
  168. s->preco = -1;
  169. i++;
  170. s++;
  171. }
  172. }
  173.  
  174. /* Escreve x espacos em branco (usado para formatar a tabela) */
  175. void escreve_espacos_branco(int x)
  176. {
  177. for (int i = 0; i < x; i++) printf(" ");
  178. }
  179.  
  180. /* Conta a quantidade de caracteres de um numero */
  181. int conta_numeros(int num)
  182. {
  183. if (num < 0) return 0;
  184. else if (num < 10) return 1;
  185. else if (num < 100) return 2;
  186. else if (num < 1000) return 3;
  187. else if (num < 10000) return 4;
  188. return 0;
  189. }
  190.  
  191. /* Escreve um inteiro na tabela */
  192. void tabela_escreve_int(int num, int digitos_tabela)
  193. {
  194. // Conta numeros do inteiro
  195. int num_dig_codUti = conta_numeros(num);
  196.  
  197. // Calcula a diferença de digitos necessários da tabela e os digitos do inteiro
  198. int dif_digitos = digitos_tabela - num_dig_codUti;
  199.  
  200. // 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 |)
  201. if (dif_digitos > 0)
  202. {
  203. printf("| %d", num);
  204. escreve_espacos_branco(dif_digitos + 1);
  205. } else printf("| %d ", num);
  206. }
  207.  
  208. /* Escreve uma string na tabela */
  209. void tabela_escreve_string(char *string, int digitos_tabela)
  210. {
  211. // Calcula tamanho da string
  212. int tam_nome = strlen(string);
  213.  
  214. // Calcula a diferença de digitos necessários da tabela e os digitos da string
  215. int dif_caracteres = digitos_tabela - tam_nome;
  216.  
  217. // 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 |)
  218. if (dif_caracteres > 0)
  219. {
  220. printf("| %s", string);
  221. escreve_espacos_branco(dif_caracteres + 1);
  222. } else printf("| %s ", string);
  223. }
  224.  
  225. /* Lista dos utilizadores com tabela */
  226. void utilizadores_listar_tabela(Utilizadores *p, data *h, int n)
  227. {
  228. // HEADER
  229. printf("================================================================================= \n");
  230. printf("| COD | USER | CONTACTO | TIPO | LOGADO | TEMPO TOTAL | TOTAL GASTO | \n");
  231. printf("================================================================================= \n");
  232.  
  233. // Loop pelos users
  234. for (int i = 0; i < n; i++)
  235. {
  236. // Escreve as infos
  237. if (p->codigoUtilizador != -1) {
  238. tabela_escreve_int(p->codigoUtilizador, 3);
  239. tabela_escreve_string(p->nomeUtilizador, 14);
  240. tabela_escreve_string(p->contacto, 10);
  241. tabela_escreve_int(p->tipoUser, 4);
  242. tabela_escreve_int(p->logado, 6);
  243. tabela_escreve_int(p->tempo_total_utilizacao, 11);
  244. tabela_escreve_int(p->total_dinheiro_gasto, 11);
  245. printf("|\n");
  246. }
  247. // Passa para o proximo user
  248. p++;
  249. }
  250. // FOOTER
  251. printf("|=====|================|============|======|========|=============|=============| \n");
  252.  
  253. system("pause");
  254.  
  255. }
  256.  
  257. /* Tabela de preços */
  258. void sessoes_tabela_precos(Sessoes *s, Utilizadores *p, int n) {
  259. double preco;
  260. p->codigoUtilizador = s->codUtilizador;
  261. if (s->minutosUtilizacao < 30)
  262. preco = (double)s->minutosUtilizacao * 0.05;
  263. else if (s->minutosUtilizacao > 30)
  264. preco = 30 * 0.05 + ((double)s->minutosUtilizacao - 30) * 0.025;
  265.  
  266. if (preco < 2)
  267. s->preco = 2;
  268. else s->preco = preco;
  269.  
  270. }
  271.  
  272. /* Regista a data atual */
  273. void data_registo(DATA *h, int n)
  274. {
  275. SYSTEMTIME st;
  276. GetSystemTime(&st);
  277. for (int i = 0; i < n; i++) {
  278. h->ano = st.wYear;
  279. h->mes = st.wMonth;
  280. h->dia = st.wDay;
  281. h->hora = st.wHour;
  282. h->min = st.wMinute;
  283. h->segundo = st.wSecond;
  284. h++;
  285. }
  286. }
  287.  
  288. /* Mostra a lista de computadores */
  289. void computadores_lista(Computadores *c, int n)
  290. {
  291. printf("\n\n LISTA DE COMPUTADORES \n\n");
  292. int i;
  293. for (i = 0; i < NUM_COMPUTADORES; i++)
  294. {
  295. printf("Código: %d\n", c->codigoComputador);
  296. printf("Nome: %s\n", c->nome);
  297. printf("Estado: %d\n", c->estado);
  298. printf("Faturado: %d\n", c->total_faturado);
  299. printf("Tempo Utilização: %d\n\n", c->tempoUtilizacao);
  300.  
  301. c++;
  302. }
  303. }
  304.  
  305. /*
  306. Encontra o codigo de utilizador mais recente do usuario
  307. (Esta função é falha se o usuário eliminado for o mais recente)
  308. */
  309. int utilizadores_codigo_mais_recente(Utilizadores *p, int n)
  310. {
  311. // Variavel que vai guardar o codigo mais recente
  312. int codigoRecente = 0;
  313.  
  314. // Encontra o maior código (que vai ser o mais recente)
  315. for (int i = 0; i < n; i++)
  316. {
  317. if (p->codigoUtilizador > codigoRecente) codigoRecente = p->codigoUtilizador;
  318. p++;
  319. }
  320.  
  321. return codigoRecente;
  322. }
  323.  
  324. /* Adicionar Utilizador */
  325. void utilizadores_introduzir(Utilizadores *p, data*h, int n)
  326. {
  327. int i = 0;
  328. while ((p->codigoUtilizador != -1) && (i < n)) {
  329. i++;
  330. p++;
  331. h++;
  332. }
  333.  
  334. if (i < n) {
  335. data_registo(h, n);
  336. printf("\nInserir novo utilizador no sistema\n\n");
  337.  
  338. fseek(stdin, 0, 2);
  339. printf("\nInsira o nome completo: ");
  340. gets_s(p->nome);
  341.  
  342. //Percorrer todo o vetor para verificar se há utilizadores com nomes iguais (POR FAZER!!!)
  343. fseek(stdin, 0, 2);
  344. printf("\nInsira o nome de utilizador: ");
  345. gets_s(p->nomeUtilizador);
  346.  
  347. fseek(stdin, 0, 2);
  348. printf("\nInsira a morada: ");
  349. gets_s(p->morada);
  350.  
  351. printf("\nInsira o contacto de telefone: ");
  352. gets_s(p->contacto);
  353.  
  354. fseek(stdin, 0, 2);
  355. printf("\nInsira password: ");
  356. gets_s(p->password);
  357.  
  358. printf("\nUtilizador registado em %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
  359.  
  360. p->codigoUtilizador = i; // utilizadores_codigo_mais_recente(p, n);
  361. if (p->codigoUtilizador == 0) p->tipoUser = 0;
  362.  
  363. printf("\nUtilizador registado na posicao %d\n", i + 1);
  364. }
  365. else printf("\n O programa nao tem espaco para mais utilizadores!! \n");
  366. printf("\n Pressiona <enter> para continuar\n");
  367. system("pause");
  368.  
  369. }
  370.  
  371. /* Mostra utilizadores sem tabela */
  372. void utilizadores_listar_simples(Utilizadores *p, data *h, int n)
  373. {
  374. int i;
  375. for (i = 0; i < n; i++)
  376. {
  377. if (p->codigoUtilizador != -1) {
  378. printf("\nO utilizador %s tem os seguintes dados: ", p->nomeUtilizador);
  379. printf("\nNome: %s", p->nome);
  380. printf("\nMorada: %s", p->morada);
  381. printf("\nContacto: %s", p->contacto);
  382. printf("\nPassword: %s", p->password);
  383. printf("\nData de Registo: %d-%d-%d as %d:%d:%d.\n", h->ano, h->mes, h->dia, h->hora, h->min, h->segundo);
  384. }
  385. p++;
  386. h++;
  387. }
  388. }
  389.  
  390. /* Admin editar user */
  391. void admin_editar_user()
  392. {
  393. printf("\nFuncao de editar user!");
  394. system("pause");
  395. //POR FAZER!!
  396. }
  397.  
  398. /* Admin eliminar user */
  399. //void admin_eliminar_user(Utilizadores *p, int n)
  400. //{
  401. // // Vai ser pedido ao utilizador
  402. // int codigo_utilizador = -1;
  403. //
  404. // // Maior código de user atual
  405. // int codigoMaisRecente = utilizadores_codigo_mais_recente(p, n);
  406. //
  407. // if (codigoMaisRecente != 0)
  408. // {
  409. // do {
  410. // printf("\n");
  411. // printf("=======================================================\n");
  412. // printf("Introduza o codigo do utilizador que pretende remover: ");
  413. // printf("\n=======================================================\n\n");
  414. // scanf("%d", &codigo_utilizador);
  415. //
  416. // // Enquanto o código for menor que 0 e o codigo de utilizador for maior que o maior codigo de user atual.
  417. // } while (codigo_utilizador < 0 && codigo_utilizador > codigoMaisRecente);
  418. //
  419. // // Procura o utilizador selecionado
  420. // // ENquanto o código de utilizador for diferente do codigo de algum dos users registados OU
  421. // // enquanto o i for menor ao numero de users máximos do programa
  422. // int i = 0;
  423. // while (p->codigoUtilizador != codigo_utilizador || i < n) p++, i++;
  424. //
  425. // p->codigoUtilizador = -1; /* -1 Não tem código | 0 para ADMIN | > 0 para normais */
  426. // p->tempo_total_utilizacao = 0;
  427. // p->total_dinheiro_gasto = 0;
  428. // p->tipoUser = 1; /* 0 para ADMIN | 1 para normais */
  429. // p->logado = 0;
  430. //
  431. //
  432. // }
  433. // else printf("Não existem utilizadores registados! ");
  434. //
  435. //
  436. //
  437. //
  438. //
  439. //
  440. //
  441. // p->codigoUtilizador = -1;
  442. // printf("\nO utilizador %d foi removido com sucesso!", codigo_utilizador);
  443. // system("pause");
  444. // //POR FAZER!!
  445. //}
  446. void admin_eliminar_user()
  447. {
  448. printf("Não é preciso adicionar esta por enquanto!\n\n");
  449. system("pause");
  450. }
  451.  
  452. /* Admin eliminar computador */
  453. void admin_eliminar_computador()
  454. {
  455. printf("\nFuncao de eliminar pc!");
  456. system("pause");
  457. //POR FAZER
  458. }
  459.  
  460. /* Admin editar computador */
  461. void admin_editar_computador()
  462. {
  463. printf("\nFuncao de editar pc!");
  464. system("pause");
  465. //POR FAZER
  466. }
  467.  
  468. /* Admin adicionar computador */
  469. void admin_adicionar_computador(Computadores *c)
  470. {
  471. int computadores_ocupados = 0;
  472. int i = 0;
  473.  
  474. // Vai ver todos os computadores
  475. while (i < NUM_COMPUTADORES)
  476. {
  477. if (c->estado != -1)
  478. {
  479. computadores_ocupados++;
  480. c++;
  481. }
  482. i++;
  483. }
  484.  
  485. // Se os computadores usados forem menos que os computadores existentes
  486. if (computadores_ocupados < NUM_COMPUTADORES)
  487. {
  488. // LOOP que só para quando o computador for adicionado
  489. while (1)
  490. {
  491. // Se o estado do PC for igual a -1
  492. if ((c->estado == -1))
  493. {
  494. fseek(stdin, 0, 2);
  495. printf("\nInsira o nome computador: ");
  496. gets_s(c->nome);
  497. printf("\nO computador %s foi adicionado.\nCÓDIGO: %d\n\n", c->nome, c->codigoComputador);
  498. c->estado = 0;
  499. c++;
  500. break;
  501. }
  502. else c++;
  503. }
  504. } else printf("\nNão é possivel adicionar mais computadores, lista cheia!");
  505.  
  506. system("pause");
  507. //POR FAZER
  508. }
  509.  
  510. /* User editar dados */
  511. void user_editar_dados(Utilizadores *p, int n)
  512. {
  513.  
  514. system("pause");
  515. //POR FAZER
  516. }
  517.  
  518. /* Admin adicionar sessao */
  519. void admin_adicionar_sessoes(Sessoes *s)
  520. {
  521.  
  522. }
  523.  
  524. /* Admin adicionar sessao */
  525. void sessoes_listar(Sessoes *s)
  526. {
  527. printf("\n\n LISTA DE SESSOES \n\n");
  528. int i = 0;
  529. while (i < 10)
  530. {
  531. printf("\nCódigo: %d", s->codComputador);
  532. printf(" | Estado: %d", s->estado);
  533. printf(" | Preco: %f", s->preco);
  534. printf(" | Pagamento: %0.2d\n\n", s->pagamento);
  535. i++;
  536. s++;
  537. }
  538. system("pause");
  539. }
  540.  
  541. /* Menu principal */
  542. char menu_principal()
  543. {
  544. char op;
  545.  
  546. printf("\n#-----------|%d|------------#", user_logado);
  547. printf("\n Registar (1) \n");
  548. printf("\n Logar (2) \n");
  549. printf("\n Logar Admin(testes)(3)\n");
  550. printf("\n Sair (0) \n");
  551. printf("\n#--------------------------#");
  552.  
  553. do {
  554. printf("\nQual a opção? ");
  555. scanf(" %c", &op);
  556. } while (op < '0' || op > '3');
  557.  
  558. //system("cls");
  559. return op;
  560. }
  561.  
  562. /* Menu principal do user */
  563. void menu_user(Utilizadores *p, data *h, computadores *c, int n)
  564. {
  565. char op;
  566.  
  567. printf("\n#--------------------------------------------#");
  568. printf("\n Ir para PC (1) \n");
  569. printf("\n Editar dados (2) \n");
  570. printf("\n Sair (0) \n");
  571. printf("\n#--------------------------------------------#");
  572.  
  573. do
  574. {
  575. printf("\nQual a opção? ");
  576. scanf(" %c", &op);
  577. } while (op < '0' || op > '2');
  578.  
  579. switch (op)
  580. {
  581. case '1':
  582. menu_user_computador(p, h, c, n);
  583. break;
  584. case '2':
  585. user_editar_dados(p, n); //POR FAZER
  586. break;
  587. case '0':
  588. menu_principal();
  589. break;
  590. default:
  591. printf("\nOpção inválida.");
  592. break;
  593. }
  594. //system("cls");
  595. }
  596.  
  597. /* Menu principal do user - computador */
  598. void menu_user_computador(Utilizadores *p, data *h, computadores *c, int n)
  599. {
  600. char op;
  601.  
  602. printf("\n#--------------------------------------------#");
  603. printf("\n Cena 1 (1) \n");
  604. printf("\n Cena 2 (2) \n");
  605. printf("\n Sair da sessao (0) \n");
  606. printf("\n#--------------------------------------------#");
  607.  
  608. do {
  609. printf("\nQual a opção? ");
  610. scanf(" %c", &op);
  611. } while (op < '0' || op > '2');
  612.  
  613. switch (op)
  614. {
  615. case '1':
  616. //VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
  617. break;
  618. case '2':
  619. //VAMOS TENTAR SIMULAR A UTILIZAÇAO DE UM COMPUTADOR
  620. break;
  621. case '0':
  622. menu_user(p, h, c, n);
  623. break;
  624. default:
  625. printf("\nOpção inválida.");
  626. break;
  627. }
  628. //system("cls");
  629.  
  630. }
  631.  
  632. /* Menu principal da admin */
  633. void menu_admin(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  634. {
  635. char op;
  636.  
  637. do
  638. {
  639. printf("\n#--------------------------#");
  640. printf("\n USERS (1) \n");
  641. printf("\n PCS (2) \n");
  642. printf("\n SESSOES (3) \n");
  643. printf("\n Sair (0) \n");
  644. printf("\n#--------------------------#");
  645.  
  646. do {
  647. printf("\nQual a opção? ");
  648. scanf(" %c", &op);
  649.  
  650. } while (op < '0' || op > '5');
  651.  
  652. switch (op)
  653. {
  654. case '1':
  655. menu_admin_users(p, h, c, n);
  656. break;
  657. case '2':
  658. menu_admin_computadores(p, h, c, n, s);
  659. break;
  660. case '3':
  661. menu_admin_sessoes(s, h, c, n);
  662. break;
  663. case '0':
  664. menu_principal();
  665. break;
  666. default:
  667. printf("\nOpção inválida 1.");
  668. break;
  669. }
  670. } while (op != '0');
  671.  
  672. //system("cls");
  673.  
  674. }
  675.  
  676. /* Menu principal da admin - Users */
  677. void menu_admin_users(Utilizadores *p, data *h, computadores *c, int n)
  678. {
  679. char op;
  680.  
  681. do
  682. {
  683. printf("\n#--------------------------#");
  684. printf("\n Lista de users (1) \n");
  685. printf("\n Adicionar user (2) \n");
  686. printf("\n Editar user (3) \n");
  687. printf("\n Eliminar user (4) \n");
  688. printf("\n Sair (0) \n");
  689. printf("\n#--------------------------#");
  690. do {
  691. printf("\nQual a opção? ");
  692. scanf(" %c", &op);
  693.  
  694. } while (op < '0' || op > '4');
  695. switch (op) {
  696. case '1':
  697. utilizadores_listar_tabela(p, h, n);
  698. break;
  699. case '2':
  700. utilizadores_introduzir(p, h, n);
  701. break;
  702. case '3':
  703. admin_editar_user(); //POR FAZER
  704. break;
  705. case '4':
  706. admin_eliminar_user(); //PORFAZER
  707. break;
  708. case '0':
  709. break;
  710. default:
  711. printf("\nOpção inválida. ..");
  712. break;
  713. }
  714. } while (op != '0');
  715.  
  716.  
  717. }
  718.  
  719. /* Menu principal da admin - Computadores */
  720. void menu_admin_computadores(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  721. {
  722. char op;
  723.  
  724. do {
  725. printf("\n#--------------------------#");
  726. printf("\n Lista de PCs (1) \n");
  727. printf("\n Adicionar PC (2) \n");
  728. printf("\n Editar PC (3) \n");
  729. printf("\n Eliminar PC (4) \n");
  730. printf("\n Sair (0) \n");
  731. printf("\n#--------------------------#");
  732.  
  733.  
  734. printf("\nQual a opção? ");
  735. scanf(" %c", &op);
  736.  
  737.  
  738.  
  739. switch (op)
  740. {
  741. case '1':
  742. computadores_lista(c, n);
  743. menu_admin_computadores(p, h, c, n, s);
  744. break;
  745. case '2':
  746. admin_adicionar_computador(c); //POR FAZER
  747. break;
  748. case '3':
  749. admin_editar_computador(); //POR FAZER
  750. break;
  751. case '4':
  752. admin_eliminar_computador(); //POR FAZER
  753. break;
  754. case '0':
  755. menu_admin(p, h, c, n, s);
  756. break;
  757. default:
  758. printf("\nOpção inválida.");
  759. break;
  760. }
  761. } while (op != '0');
  762. }
  763.  
  764. /* Menu principasl da admin - Sessoes*/
  765. void menu_admin_sessoes(Sessoes *s, data *h, computadores *c, int n)
  766. {
  767. char op;
  768.  
  769. do {
  770. printf("\n#--------------------------#");
  771. printf("\n Lista de Sessoes (1) \n");
  772. printf("\n Adicionar Sessao (2) \n");
  773. printf("\n Editar Sessao (3) \n");
  774. printf("\n Eliminar Sessao (4) \n");
  775. printf("\n Sair (0) \n");
  776. printf("\n#--------------------------#");
  777.  
  778.  
  779. printf("\nQual a opção? ");
  780. scanf(" %c", &op);
  781.  
  782.  
  783.  
  784. switch (op)
  785. {
  786. case '1':
  787. sessoes_listar(s);
  788. //menu_admin_computadores(p, h, c, n);
  789. break;
  790. case '2':
  791. //admin_adicionar_computador(c); //POR FAZER
  792. break;
  793. case '3':
  794. //admin_editar_computador(); //POR FAZER
  795. break;
  796. case '4':
  797. //admin_eliminar_computador(); //POR FAZER
  798. break;
  799. case '0':
  800. //menu_admin(p, h, c, n);
  801. break;
  802. default:
  803. printf("\nOpção inválida.");
  804. break;
  805. }
  806. } while (op != '0');
  807. }
  808.  
  809. /* Menu do LOGIN */
  810. void menu_login(Utilizadores *p, data *h, computadores *c, int n, Sessoes *s)
  811. {
  812. int i, cmpStringUser, cmpStringPass;
  813. char nome[15], password[15];
  814. Utilizadores *user = new Utilizadores;
  815. *user = *p;
  816. int nUsers = n;
  817.  
  818. fseek(stdin, 0, 2);
  819. printf("\nInsira o nome de utilizador: ");
  820. gets_s(nome);
  821. fseek(stdin, 0, 2);
  822. printf("\nInsira a password: ");
  823. gets_s(password);
  824.  
  825. for (i = 0; i < n; i++)
  826. {
  827. cmpStringUser = strcmp(nome, p->nomeUtilizador);
  828. cmpStringPass = strcmp(password, p->password);
  829.  
  830. if ((cmpStringUser == 0 && cmpStringPass == 0))
  831. {
  832. user_logado = p->codigoUtilizador;
  833. if (p->codigoUtilizador == 0)
  834. menu_admin(p, h, c, n, s);
  835. else if (p->codigoUtilizador > 0)
  836. menu_user(p, h, c, n);
  837. }
  838. else p++;
  839. }
  840. printf("\nErrado.\n");
  841. system("pause");
  842. }
  843.  
  844. /* Main */
  845. void main()
  846. {
  847. setlocale(LC_ALL, ""); //Caracteres acentuados
  848.  
  849. // Vai guardar o user que está atualmente logad
  850. /*
  851. -1 -> Não existe ninguém logado
  852. >0 -> Código do user logado
  853. */
  854.  
  855. Utilizadores user[10];
  856. int nUsers = 10;
  857.  
  858. int nComputadores = 20;
  859. Computadores pc[NUM_COMPUTADORES];
  860. data h[10];
  861.  
  862. Sessoes *sessoes = (Sessoes *)malloc(10 * sizeof(Sessoes));
  863.  
  864. computadores_inicializa(pc, nComputadores);
  865. utilizadores_inicializa(user, nUsers);
  866.  
  867. *sessoes = (realloc( (Sessoes)sessoes , 10 * sizeof(Sessoes));
  868.  
  869. sessoes_inicializa(sessoes, 11);
  870.  
  871. char ope;
  872.  
  873.  
  874. do {
  875. ope = menu_principal();
  876.  
  877. switch (ope) {
  878. case '1':
  879.  
  880. utilizadores_introduzir(user, h, nUsers);
  881. //system("cls");
  882. break;
  883. case '2':
  884. menu_login(user, h, pc, nUsers, sessoes);
  885. //menuLogin(user, h, pc, nUsers); //Registar-se no sistema
  886. //system("cls");
  887. break;
  888. case '3':
  889. menu_admin(user, h, pc, nUsers, sessoes);
  890. //menuLogin(user, h, pc, nUsers); //Registar-se no sistema
  891. //system("cls");
  892. break;
  893. case '0':
  894. ope = '0';
  895. break;
  896. default:
  897. printf("\nOpção inválida.");
  898. break;
  899. }
  900. } while (ope != '0');
  901. }
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!