API tools faq
paste
Advertisement
Guest User

Untitled

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