PIM II - ADS - 2020

Prévia do material em texto

Universidade Paulista
Projeto Integrado Multidisciplinar
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas
Desenvolvimento de um software de controle para uma pequena rede
clínica médica.
Orientadora: Walkiria
Coordenadora: Walkiria
Campus Goiânia/GO
2020
Universidade Paulista
Projeto Integrado Multidisciplinar
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas
Alunos:
Adriana Valentim e Silva RA: N6662B5
Igor Lourenço de Oliveira RA: N635134
Lorena Lopes Castro RA: F214281
Lucas Rayleno Freitas de Souza RA: N554860
Campus Goiânia/GO
2020
Resumo
O Projeto Integrado Multidisciplinar tem o seu objetivo de desenvolver um
programa que permite a uma pequena rede de clínicas para realizar as demandas
do controle do paciente. Isso os traz as aplicações de sistemas em linguagem em C,
do modo console, para armazenar os dados em arquivo texto para a contabilização.
Essa unidade de rede de clínicas necessita desenvolver um programa para o
gerenciamento e o controle do negócio focado nos atendimentos aos clientes. A
empresa não tem condições para os grandes investimentos em infraestrutura, como
os softwares de valores caros, por isso, optaram um sistema de linguagem C para
ter o controle nas unidades. Isso inclui o desenvolvimento de algoritmos, respectivos
fluxogramas, ferramentas computacionais para o desenvolvimento, diagramas de
fluxo de software, uso da matemática em programas para computadores, debbugar o
código e investigar o funcionamento, formatar o trabalho em equipe e em execução
de projetos. E envolvendo matérias estudadas como: Linguagem e Técnicas De
Programação, Engenharia de Software, Fundamentos Redes de Dados e
Comunicação, Matemática para computação, Ética e Legislação Profissional e por
última Metodologia Científica.
Palavras-chave: Desenvolvimento de um software de controle, Linguagem e
Técnicas de programação, Engenharia de Software.
ABSTRACT
The Integrated Multidisciplinary Project aims to develop a program that allows
a small network of clinics to carry out the demands of patient control. This brings
them the applications of systems in C language, in the console mode, to store the
data in text files for accounting.This unit of network of clinics needs to develop a
program for the management and control of the business focused on customer
satisfaction. The company is unable to make major investments in infrastructure,
like expensive software, so they opted for a C language system to control the units.
This includes developing algorithms,respective flowcharts,computational tools for
development, software flow diagrams, use of mathematics in computer
programs,debug the code and investigate how it works,format team work and project
execution. And involving subjects studied such as: Language and Programming
Techniques, Software Engineering, Fundamentals Data and Communication
Networks, Mathematics for computing, Ethics and Professional Legislation and finally
Scientific Methodology.
Key words: Development of control software, Language and
programming techniques, Software Engineering.
SUMÁRIO
1.0 INTRODUÇÃO 1
2.0 ÉTICA E LEGISLAÇÃO PROFISSIONAL 2
2.1 Art. 6º: Direitos básicos do consumidor 3
3.0 METODOLOGIA CIENTÍFICA 4
3.1 O que é Metodologia Científica? 5
3.2 Pesquisa qualitativa 7
3.3 Pesquisa quantitativa 9
4.0 FECHAMENTO DE CAIXA DIÁRIO 11
5.0 ENGENHARIA DE SOFTWARE 12
5.1 Software Utilizado 13
6.0 DESENVOLVIMENTO DO SISTEMA 15
6.1 Acesso a ferramenta como moderador 15
7.0 FLUXOGRAMA DO SISTEMA 16
7.1 Inclusão de cadastro do usuário 17
7.2 Cadastro de pacientes 18
7.3 Cadastro de agendamentos clínicos 19
7.4 Consulta de cadastros gerais 20
7.5 Consulta de agendamentos 21
7.6 Registro de reclamações, sugestões ou elogios 22
7.7 Consultar uma reclamação, sugestão ou elogio 23
7.8 Registro de chamado para a equipe de TI 24
7.9 Consulta de chamados para o TI 25
7.10 Relatório de desempenho diário das equipes 26
7.11 Alterar senha de usuário 27
7.12 Exclusão de usuário 28
8.0 CÓDIGO DO PROGRAMA 31
9.0 REDE DE DADOS 114
Conclusão 115
Referências 116
1.0 Introdução
O PIM (Projeto Integrado Multidisciplinar) tem a sua função de abranger os
conhecimentos dotados no propósito de interligar as suas determinadas tarefas como
as disciplinas utilizáveis são: Linguagem e Técnicas De Programação, Engenharia de
Software um, Fundamentos Redes Dados e Comunicação, e Matemática para
Computação. Portanto, é para desenvolvê-los os algoritmos, fluxogramas, diagramas,
utilização de ferramentas computacionais e o uso de matemática. E as duas últimas
matérias de Ética e Legislação Profissional e a Metodologia Científica são as
especificações de requisitos de qualidade a serem cumpridos por um material e
serviço para facilitar as necessidades e as expectativas do cliente e do usuário.
Resumo de uma determinada história
Uma pequena rede de clínicas médica contém três unidades entre si. Elas
estão localizadas no centro de uma cidade do Brasil, e a rede clínica opta a
desenvolver um sistema para o seu gerenciamento, e o controle dos seus pacientes
e o negócio para terem êxito nos atendimentos dos seus clientes. Para isso, a
empresa precisa de um sistema em uma linguagem em C do modo console; e
aplicando-se o uso de armazenamentos de dados em arquivos textos. Entretanto,
como a empresa não possui um capital maior para realizar grandes investimentos
em infraestrutura como, por exemplo, uma demanda de softwares caros. Porém, a
Clínica Médica visa desenvolver um determinado programa que se encaixe nas suas
possibilidades e consiga ter melhor desempenho e aprimoramento a evolução
tecnológica.
2.0 ÉTICA E LEGISLAÇÃO PROFISSIONAL
O Código de Defesa do Consumidor (CDC) e os contratos de planos de saúde
A empresa destacou em sua clínica sobre o Código do Consumidor (CDC),
em que se dar o direito para o consumidor, sobre os contratos de seus planos que
podem cobrar um valor altíssimo fora da sua condição. Então é necessário, a
empresa avaliar os contratos para que não cobrem o valor fora da condição
financeira.
Como é fato público e notório, as operadoras de planos de saúde lideram o
ranking de reclamações dos consumidores (Idec) no Brasil, o que, em tese, não
deveria ocorrer, caso as empresas seguissem as normas dispostas no Código de
Defesa do Consumidor (CDC), conforme será abaixo demonstrado. Primeiramente,
cumpre esclarecer que o CDC é um compilado de normas que visa à proteção dos
direitos do consumidor, disciplinando as relações e responsabilidades entre o
fornecedor e o consumidor final.
Neste sentido, importante ressaltar que está pacificado no C. Superior Tribunal
de Justiça, através da Súmula 469, a plena aplicabilidade do Código de Defesa do
Consumidor aos contratos de Plano de Saúde, o qual estabelece normas de
proteção e defesa do consumidor, de ordem pública e interesse social. Dentre as
normas protetivas, insta destacar os direitos básicos do segurado, com amparo legal
no art. 6º do CDC, que, dentre outros, veda a modificação das cláusulas contratuais
que estabeleçam prestações desproporcionais ou que as tornem excessivamente
onerosas aos consumidores, conforme ora se transcreve:
2.1 Art. 6º: Direitos básicos do consumidor
- A proteção da vida, saúde e segurança contra os riscos provocados por
práticas no fornecimento de produtos e serviços considerados perigosos ou
nocivos;
- A educação e divulgação sobre o consumo adequado dos produtos e 
serviços, asseguradas a liberdade de escolha e a igualdade nas contratações;
- A informação adequada e clara sobre os diferentes produtos e serviços, com
especificação correta de quantidade, características, composição, qualidade,
tributos incidentes e preço, bem como sobre os riscos que apresentem;
- A proteção contra a publicidadeenganosa e abusiva, métodos comerciais
coercitivos ou desleais, bem como contra práticas e cláusulas abusivas ou
impostas no fornecimento de produtos e serviços;
- A modificação das cláusulas contratuais que estabeleçam prestações
desproporcionais ou sua revisão em razão de fatos supervenientes que as
tornem excessivamente onerosas;
- A efetiva prevenção e reparação de danos patrimoniais e morais, individuais,
coletivos e difusos;
- O acesso aos órgãos judiciários e administrativos com vistas à prevenção ou
reparação de danos patrimoniais e morais, individuais, coletivos ou difusos 
assegurados a proteção Jurídica, administrativa e técnica aos necessitados;
- A facilitação da defesa de seus direitos, inclusive com a inversão do ônus da
prova, a seu favor, no processo civil, quando, a critério do juiz, for verossímil a
alegação ou quando for ele hipossuficiente, segundo as regras ordinárias de
experiências;
- A adequada e eficaz prestação dos serviços públicos em geral.”
Infelizmente, esta não é a realidade brasileira, sendo cada vez maior o descaso com
que os segurados são tratados pelas operadoras dos planos de saúde, que, muitas
vezes, inserem cláusula abusivas em seus contratos, incorrendo em total violação
aos direitos básicos do consumidor e às normas protetivas instituídas pelo CDC.
É imperioso ressaltar que, além dos direitos supracitados, o art. 51 do CDC
dispõe acerca da nulidade das cláusulas contratuais relativas ao fornecimento de
produtos e serviços, que estabeleça obrigações consideradas abusivas, colocando o
consumidor em desvantagem exagerada, ou seja, incompatíveis com a boa-fé ou a
equidade, por exemplo, a inserção de reajuste traduzido em valor exorbitante ou até
mesmo a recusa injustificada na cobertura de determinada assistência ou
procedimento prescrito pelo médico.
Por fim, tem-se notadamente a situação de vulnerabilidade que se encontra o
consumidor, a qual merecidamente cingiu-se de proteção especial, devendo o
segurado exigir o cumprimento de seus direitos, e, se necessário, procurar um
advogado de sua confiança, a fim de buscar a tutela do Estado, através da 
propositura de ação própria, caso se sinta lesado por atitudes abusivas e
ilegais da seguradora contratada.
3.0 Metodologia Científica
A empresa também aplica a Metodologia Científica que esteja de acordo com
a Associação Brasileira das Normas Técnicas (ABNT), em que vêm incluídos na
Metodologia os seus métodos, teorias e hipóteses de um assunto para especificar o
seu trabalho a ser executado, a primeiramente deve ser analisado para que o projeto
vá adiante de seu argumento, se concretize. Pois, o assunto é sobre “O Código de
Defesa do Consumidor (CDC)”, tendo uma função para que evite os abusos de
contratos de planos de saúde.
3.1 O que é Metodologia Científica?
Metodologia Científica é o estudo dos métodos que devem ser seguidos, em
ordem cronológica, para que um pesquisador realize um trabalho acadêmico bem
estruturado e de qualidade. E, para que você entenda melhor, vamos pensar um
pouco de um exemplo de um processo de construção civil. Quando um engenheiro
civil vai construir uma casa ele precisa seguir uma série de etapas para que a
construção se torne segura. Para isso é preciso que ele siga alguns passos, como:
projeto da casa, fundação, vedação, cobertura, esquadrias e revestimento. Porém,
não é possível que a fundação da casa seja feita se o engenheiro não estiver com o
projeto da construção em mãos, até porque não tem como levantar as paredes se a
casa não possuir estrutura. E assim também funciona a elaboração de textos
acadêmicos. Para que o mesmo seja elaborado, é preciso que você siga uma série
de etapas chamadas de Metodologia Científica. Antes de entender essas etapas que
constituem a Metodologia Científica, vamos ver quais são os tipos de pesquisas que
devem ser feitos conforme o objetivo do seu trabalho.
Tipos de pesquisa: A Metodologia Científica pode ser dividida em 2 tipos de
pesquisa: pesquisa qualitativa e pesquisa quantitativa, e a escolha de cada um
desses métodos vai depender do tema que será abordado no projeto de pesquisa.
3.2 Pesquisa qualitativa
A pesquisa qualitativa é o estudo dos hábitos de uma determinada população.
Este tipo de pesquisa da metodologia científica é mais subjetivo, visto que todas as
análises são feitas por meio de interpretações de aspectos não mensuráveis, como:
comportamentos, sensações, pensamentos e sentimentos.
3.3 Pesquisa quantitativa
Como o próprio nome faz alusão, a pesquisa quantitativa leva em
consideração tudo o que pode ser medido, ou seja, os resultados que podem ser
gerados através de pesquisas estatísticas.
Fundamentação teórica
Quando o cliente escolhe onde e como quer que seja feita a sua casa, a
equipe de construção irá fazer um levantamento de todo o material disponível no
mercado para satisfazer o desejo do cliente. No trabalho de conclusão de curso,
você também vai precisar fazer um levantamento de todo o material que irá
sustentar o seu problema de pesquisa. Dessa forma,é necessário que você faça um
capítulo explicando todos os conceitos que serão abordados para que sua pesquisa
seja estruturada conforme a metodologia científica. Lembre-se de fazer a sua
fundamentação teórica com base em livros ou revistas científicas, pois nem sempre
às fontes citadas na internet são confiáveis. Elabore um método de trabalho.Agora,
chegou o momento de organizar a equipe de construção para entregar o projeto
dentro do prazo. Mas como isso será feito? Os operários da obra farão hora extra?
Qual será o turno de trabalho? Para que o seu trabalho de conclusão de curso tenha
um resultado de qualidade, é preciso que você organize as etapas do seu projeto e
pense em qual é o melhor caminho para resolver o problema que você escolheu,
parte essencial da metodologia científica. O orientador do seu trabalho será o
engenheiro civil deste projeto. Ele irá te auxiliar em como construir um plano de
trabalho eficiente, por isso, não se esqueça de escolher um bom professor para esse
cargo.
Coleta de dados
Nesta parte do projeto, você precisa investigar o seu problema e, de acordo
com o tipo de pesquisa da metodologia científica escolhido, é possível saber qual 
será o método de coleta de dados. As principais formas de coletar esses dados
são através da observação, do uso de questionários ou por meio de
entrevistas.Observação: este tipo de coleta é muito utilizado nas áreas de ciências
sociais e biológicas, visto que é preciso analisar como algo, seja um animal, uma
planta ou um ser humano, se desenvolve com o passar do tempo ou o
comportamento de uma pessoa perante uma determinada situação.
Questionário
O questionário é utilizado para levantar informações a cerca de um
determinado grupo de pessoas. Ele é muito usado quando se deseja saber
informações mais objetivas como crenças religiosas ou preferências políticas. Além
disso, este método de coleta de dados pode ter perguntas abertas ou fechadas.
Entrevista
A entrevista tem um caráter mais pessoal que o questionário. Como não deixa
de ser uma conversa entre duas pessoas, nela é possível observar a reação do
indivíduo frente a determinados questionamentos. Este tipo de coleta é muito
utilizado no meio de ciências sociais. Como: “Análise e interpretação de dados”.
Após a realização da coleta de dados, é preciso analisar e interpretar todos os
resultados obtidos na sua pesquisa. Este estudo deve ser bem detalhado para que o
seu trabalho final tenha uma conclusão satisfatória. E, assim como a casa só pode
receber acabamento depois que a cobertura e as paredes tenham sido construídas,
é necessário que você apresente todos os dados coletados e depois explique os
resultados obtidos. Uma dica fundamental para esta parte do seu projeto é voltar a
mencionar os seus objetivos gerais e específicos,a fim de que fique claro se o
resultado da sua pesquisa teve ou não os objetivos alcançados.
4.0 FECHAMENTO DE CAIXA DIÁRIO
Exemplo 1: Abertura do caixa = N
Recebimentos em espécie = X
Vendas realizadas em cartões crédito = Y 
Vendas realizadas em cartões de débito = D 
Cheques = A
Troco dos recebimentos em espécie = w 
Despesas eventuais = C
Valor total recebido, sem contar com o valor de abertura do caixa = 
Q X + Y +D + A - C - W = R$ Q
Levando em consideração os ganhos a longo prazo no caso de cartões crédito,
cheques sem contar com juros
Exemplo 2:
Abertura do caixa = 250,00 Recebimentos em espécie = 2500,00
Vendas realizadas em cartões crédito = 1500,00 
Vendas realizadas em cartões de débito = 3000,00 
Cheques = 1200,00
Troco dos recebimentos em espécie = 500,00 Despesas
eventuais = 200,00
2500,00 + 1500,00 + 3000,00 + 1200,00 – 500,00 – 200,00 = R$ 7500,00
5.0 ENGENHARIA DE SOFTWARE
Em suma, é uma disciplina de engenharia que se ocupa de todos os aspectos
da produção de software, desde os estágios iniciais de especificação do sistema até a
manutenção desse sistema, após sua entrada em produção a meta principal da
Engenharia de Software é desenvolver sistemas de software com boa relação custo-
benefício. 
De acordo com Pressman:
“A Engenharia de Software ocorre como consequência de um processo
chamado Engenharia de Sistemas. Em vez de se concentrar somente no
software, a engenharia de sistemas focaliza diversos elementos, analisando,
projetando, e os organizando em um sistema que pode ser um produto, um
serviço ou uma tecnologia para transformação da informação ou controle”. 
5.1 Software utilizado
Sigs: Estudo dos sistemas de informação nas empresas e na administração; dando
suporte ao nível gerencial por meio de relatórios, processos correntes e históricos por 
meio de acesso online orientados a eventos internos, apoiando o planejamento, o
controle e a decisão; dependem dos aplicativos TPS para aquisição de dados,
resumindo e apresentando operações e dados básicos. 
6.0 DESENVOLVIMENTO DO SISTEMA
Manual do usuário
-Nesta parte está contidas todas as informações possíveis para que não haja
dificuldade para utilizar o Software.
Acesso a ferramenta como administrador:
LOGIN: ADMIN | admin
SENHA: 1234
6.1 Acesso a ferramenta como moderador:
Para logar como moderador do sistema é necessário criar um usuário estando
logado como administrador. É importante lembrar que somente o ADMIN pode criar ou
excluir um usuário do sistema. O login de usuário se dá pela sigla da equipe a qual o
colaborador pertence, sendo elas | “CE”, “CO” e “CT”| e pelos 4 últimos dígitos do CPF
cadastrado.
EX: CPF CADASTRADO: | 12345678900 |
SIGLA DA EQUIPE: | CO |
O LOGIN SERÁ | CO8900 | 
Senha será o CPF cadastrado | 12345678900 |.
Recomenda-se trocar a senha padrão do moderador no ato de LOGIN da ferramenta
utilizando o comando B0 no menu iniciar para evitar fraudes de matrículas e outros.
Abaixo segue algumas dicas para serem usadas durante o uso:
1. O software consiste em uma ferramenta básica com um menu um tanto interativo,
para utilizar este menu é necessário informar a solicitação de destino e esta solicitação
possui
2 dígitos (Caracteres/Numéricos) que geralmente se encontram a esquerda. Ex: “A1”
corresponderá a uma solicitação para cadastro de usuário.
3. O software foi desenvolvido com o intuito de facilitar seu manuseio, ou seja, o
usuário nunca precisará digitar algo a não ser pedido. 
4. Sempre que houver alternativas com múltiplas escolhas em uma determinada
solicitação, o usuário deverá utilizar números para escolher a alternativa
correspondente ao que precisará executar no sistema . Ex: Ao escolher o sexo será
apresentada a alternativa feminino e masculino onde ‘0’ representa FEMININO e ‘1’
representa MASCULINO. (0 - MASCULINO / 1 - FEMININO)
5. Evite utilizar acentuação/cedilhas e outros caracteres especiais que possam
comprometer as informações que estão sendo coletadas durante o cadastro.
6. Ao entrar com valores numéricos que possuem valores após o ponto flutuante pode-
se usar a vírgula para separar os valores normalmente. Ex: R$ 150,75 | 140123,30.
7.0 Fluxograma do Sistema
O fluxograma inicial é um demonstrativo completo do CGI (Central de gerenciamento
interno) de forma que seja possível entender seu funcionamento.
O CGI foi projetado no intuito de facilitar seu manuseio e apresentar conforto ao
usuário com uma interface amigável. As opções de tratamento variam de “A1” ao “DG”
e são autoexplicativas. Ao lado a projeção da interface do menu inicial.
7.1 Inclusão de cadastro do usuário
A forma de cadastro é simples e ágil podendo ser concluída em poucos
minutos. O usuário somente precisará digitar múltiplas informações em ocasiões 
específicas como endereço, nome e identificações, pois o sistema conta com
validações que auxiliam na criação do cadastro.
7.2 Cadastro de pacientes
A tela de cadastro assim como as demais possuem a área de revisão do
cadastro onde o usuário pode cancelar a solicitação ou finalizar o cadastro com as
informações preenchidas.
Os blocos são validados a cada nova inserção de informações para certificar-se
de que não há espaços vazios ou com informações incorretas.
7.3 Cadastro de agendamentos clínicos
O software conta com atendimento inteligente que identifica se o paciente
possui convênio médico com a clínica para a aplicação de descontos especiais, além
de possui validações que certificam a assertividade das informações cadastradas.
7.4 Consulta de cadastros gerais
Um paciente e/ou funcionário somente poderão ser consultados caso existam na base
de cadastros gerais.
O sistema retornará uma mensagem informativa em caso de erro na busca do
CPF informado.
7.5
Consulta de agendamentos
No ato da abertura de um agendamento é gerado um número de chamado o
qual deve ser anotado para consultar as informações do atendimento em data
posterior.
O médico responsável pelo atendimento pode dar baixa no agendamento assim
como um funcionário que possui credencial de moderador ou administrador. Após a
baixa sistêmica a ordem de serviço poderá ser consulta na aba de agendamentos em
histórico.
7.6 Registro de reclamações, sugestões ou elogios
Somente um administrador ou moderador poderá realizar o registro e é
necessário que o CPF solicitante seja válido. 
Uma ordem de serviço é gerada ao final do procedimento para que seja
possível consultá-la posteriormente.
7.7 Consultar uma reclamação, sugestão ou elogio
Ao consultar uma ordem de serviço o usuário deve informar a modalidade da
consulta seguidamente do número de agendamento
7.8 Registro de chamado para a equipe de TI
Qualquer usuário poderá realizar a abertura de um chamado para a equipe de
TI, pois se trata de uma solicitação prioritária e importante para o bom funcionamento
da clinica.
Um número de chamado é gerado ao final da solicitação e poderá ser utilizado
para acompanhar o andamento da solicitação. 
7.9 Consulta de chamados para o TI
Para consultar um chamado interno é necessário apresentar uma OS de
chamado e somente um moderador ou admin pode realizar uma consulta de chamado.
O mesmo deve estar pendente de tratamento, caso não encontrado poderá ser
pesquisado na aba de agendamentos em histórico.
7.10 Relatório de desempenho diário das equipes
O relatório é gerado na área de trabalho local do usuário que solicitou o
procedimento pelo sistema.
A aba de relatórios está destinada à amostra diária dos resultados obtidos por
todas as filiais e pode ser gerado a qualquer momento por um administrador ou
moderador, mas recomenda-se gerar o relatório somente ao final do dia.
7.11 Alterar senha de usuário
A senha de usuário por padrão é o CPFde origem e deve ser alterada no ato de
login no sistema utilizando o comando B0.
7.12 Exclusão de usuário
Para o cadastro de um moderador é necessário estar logado no sistema com a
conta administradora e somente o admin poderá realizar a exclusão de um usuário do
sistema.
Após a exclusão não há como reverter o processo, o usuário é excluído
permanentemente.
8.0 CÓDIGO DO PROGRAMA
#include <stdio.h> // Biblioteca para usar os comandos de entrada e saida
#include <stdlib.h> // Biblioteca padrão e possui a função de (alocação de memoria),
controle de processos, conversões e outras.
#include <string.h> // Biblioteca para utilizar e manipular strings
#include <time.h> // Biblioteca de datas e horários
#include <stdbool.h> // Biblioteca para utilizar retornos booleanos
#include <locale.h> // Biblioteca para usar a linguagem local incluindo acentos.
#include <windows.h> // Biblioteca para usar funcionalidades especificas do windows
#include <conio.h>
#include <ctype.h>
// Função que fará a concatenação das informaçõs e adicionara no bloco de notas
para a criação de uma OS.
void concatena_string(char tipasta[35], char titratados[45], char OS[15], char
categoria[25], char id[7], char informe[25], char detalhar[255]);
//Funcao para incluir a data e hora nas solicitações / agendamentos
void incluirdatahora(char cm[50]);
//Funcao para limpar o buffer do teclado
void lb(void);
// Função para realizar a leitura de uma senha.
char** lersenha(char senha[9]);
// Funcao cria senha e login padrao
void createloginsenha(char creatediretlogin[50], char creatediretsenha[50],char
loginass[60], char cpf[12]);
// Funcao para apresentar uma linha formatada
void lform();
// funcao para Validar usuario admin
bool validarAdmin(char login[11], char senha[16]);
// funcao para Criar login do usuario
int criarnumusuario(long long num);
// Funcao para confirmação de cadastro
void confirmacadastro(char nomePs[35], char nomeMa[35], char idade[3], char sex[10],
char cpf[12], char endereco[35], char telcont[12], char ctps[12], char dipl[10], char
convenio[12]);
// Funcao para validar um TELEFONE de contato
bool validaTEL(long long valor);
// Funcao para validar um CPF
bool validaCPF(long long cpf_entrada);
// Funcao de pausar a tela
void pause();
// Funcao de limpar tela
void limpatela();
// Funcao de gear numero aleatorio
int gerarOS();
// Funcao que le as informacoes no bloco de texto.
bool leitura(char ler[70]);
// Funcao para cadastro de informacos basicas do usuario/paciente
char cadastrar(char initcadastro[70], char nome[40], char idadeString[5], char sexo[15],
char endereco[40], char cpf[16], char telcont[20]);
int main(void){
 //Cria as pastas do sistema e realiza o processo de ocultação das mesmas.
 system("mode 15,1 && color 15 & title TELA DE LOGIN"); // Muda o tamanho do
terminal para 15 colunas e 1 linha e a cor para fundo azul e letras roxas
 system("msg * AGUARDE! INICIALIZANDO TAREFAS..."); // Mostra uma POP-UP
com uma mensagem para o usuario.
 system("mkdir sugerir-reclamar-elogiar\\ELOGIO\\");
 system("mkdir sugerir-reclamar-elogiar\\RECLAMACAO\\");
 system("mkdir sugerir-reclamar-elogiar\\SUGESTAO\\ & attrib -h sugerir-reclamar-
elogiar");
 system("mkdir funcionarios\\ & attrib -h funcionarios"); // Cria a pasta de funcionarios
 system("mkdir pacientes\\ & attrib -h pacientes"); // Cria a pasta de pacientes
 system("mkdir system-moderadores\\logins\\ & attrib -h system-moderadores"); //
Cria a pasta de logins para moderadores do sistema
 system("mkdir agendamentos\\concluidos\\ & attrib -h agendamentos"); // Cria a
pasta de agendamentos e agendamentos concluidos
 system("mkdir ti-sistemas\\tratados\\ & attrib -h ti-sistemas"); // Cria a pasta de ti e
sistemas
 system("mkdir relatorios\\ & attrib -h relatorios"); // Cria a pasta de relatorios
 moduser: // ponto de salto para modificar o usuario / trocar login
 system("mode 30,6 && color 07"); // Seta o tamanho do terminal para 30 colunas
e 6 linhas e a cor do terminal para o padrão
 struct tm *dataloc; //ponteiro para struct que armazena data e hora
 time_t segundos; //variável do tipo time_t para armazenar o tempo em segundos
 time(&segundos); //obtendo o tempo em segundos
 dataloc = localtime(&segundos); //Para converter de segundos para o tempo local
utilizamos a função localtime
 time(&segundos); //obtendo o tempo em segundos
 dataloc = localtime(&segundos);
 limpatela(); // Limpa a tela para o usuário
 setlocale(LC_ALL,""); // código para setar os acentos no programa
 /*O login será a sigla de 2 digitos da clinica e os 4 ultimos digitos do CPF do
colaborador
 Senha provisória é o CPF do usuario até que seja realizada a devida alteração.*/
 //Variaveis globais de login
 bool admin = false, moderador = false, trocar_senha_padrao = false; // declaracao
de variavel do tipo booleano
 char identificacao_menu[7] = "", caminhologin[65] = "system-moderadores\\
logins\\", caminhosenha[75] = "system-moderadores\\logins\\"; // Declaração de
variavel global
 char verificarsenhapadrao[65] = "system-moderadores\\logins\\";
 int cc; // Declaração de variavel contadora do tipo inteiro
 for(cc = 0; cc < 3; cc++){ // Entrará em um loop infinito até que uma das opções
de login sejam atendidas.
 char login[7] ,log[7] = "", auxlog[60] = "", auxsen[60] = "", senha[9] = ""; //
Declaração de variavel local
 printf("\n LOGIN -> "); // Informa ao usuario para digitar o login
 scanf("%s", &log); // Leitura da string login temporaria
 strcpy(login, log); // copia os dados da variavel de login temporaria para a
variavel de login
 printf(" --------------------------"); // Separador
 printf("\n SENHA -> "); // Informa ao usuario para digitar a senha
 lersenha(senha); // Faz a leitura da senha
 lb(); // Limpa o buffer do teclado.
 // Concatenação de string login
 strcat(auxlog, caminhologin); // Adiciona o caminho da pasta de login para a
variavel auxiliar do login
 strcat(auxlog, login); // Adiciona o login na variavel auxiliar do login
 strcat(auxlog, "\\"); // Adiciona o login na variavel auxiliar do login
 strcat(auxlog, login); // Adiciona o login na variavel auxiliar do login
 strcat(auxlog, ".txt"); // Adiciona a extensão .txt
 // Concatenação de string senha
 strcat(auxsen, caminhosenha); // Adiciona o caminho da pasta de senha para a
variavel auxiliar de senha
 strcat(auxsen, login); // Adiciona a senha na variavel auxiliar da senha para
criar um novo diretório
 strcat(auxsen, "\\"); // Acrescenta a barra correspondente a separação de
diretórios na variavel auxliar da senha
 strcat(auxsen, senha); // Adiciona a senha na variavel auxiliar da senha para
criar um novo arquivo de senha
 strcat(auxsen, "\\"); // Acrescenta a barra correspondente a separação de
diretórios na variavel auxliar da senha
 strcat(auxsen, senha); // Adiciona a senha na variavel auxiliar da senha para
criar um novo arquivo de senha
 strcat(auxsen, ".txt"); // Adiciona a extensão .txt
 // BLOCO CONDICIONAL de Verificação de adminstração do sistema.
 if(strcmp(senha, "1234") == 0 && (strcmp(login, "ADMIN") == 0 || strcmp(login,
"admin") == 0)){ // Compara se o as informações digitadas são válidas, caso seja o
usuario é reconhecido como admin
 admin = true; // Atribuição de valor booleano verdadeiro a variavel admin
 strcat(identificacao_menu, login); // Concatena o login para mostar no menu
inicial
 break; // Encerra o looping
 }else if(validarAdmin(auxlog,auxsen) == true){ // Verifica se o usuario é um
usuario válido para liberar acesso ao uso da ferramenta
 moderador = true; // Atribuição de valor booleano verdadeiro a variavel
usuario
 strcat(identificacao_menu, login); // Concatena o login para mostar no menu
inicial
 // Concatenação de verificação da senha padrao
 strcat(verificarsenhapadrao, login);
 strcat(verificarsenhapadrao, "\\");
 strcat(verificarsenhapadrao, senha);
 strcat(verificarsenhapadrao, "\\");
 strcat(verificarsenhapadrao, "true.txt");
 break; // Encerra o looping
 }else{ // Se nenhum das alternativas anteriores for válida, uma mensagem de
erro será exibida para o usuario.
 system("msg * USUARIO OU SENHA INVALIDOS. TENTE NOVAMENTE!");
// Apresenta uma POP UP com uma mensagem para o usuario
 limpatela();
 }
 // CONDICAO DE CONTROLE DE LOGIN
 if(cc == 2){ // Caso o usuario atinja 3 tentavias de login, o sistema fará
autodeslog.
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SAINDO DO
SISTEMA..."); // Apresenta uma POP UP com uma mensagem para o usuario
 exit(0); // Encerra o programa
 }
 }
 iniciar: // Ponto de salto do GOTO
 limpatela(); // Limpa a tela do usuario
 // DECLARACAO DE VARIAVEIS DE USO GERAL
 FILE *file; // Declaracao de variavel do tipo FILE
 int contador = 0, confirma, idade, aux, os, numos; //Declaracao de variavel de uso
geral do tipo inteiro
 // DECLARAÇÃO DE VARIAVEIS DE USO GERAL DO TIPO CHAR
 char ext[5] = ".txt", sigla[3] = "", sg[3] = "", rlos[15] = "", consultarOS[50] = "",
digitoOS[25] = "", auxiliarOS[53] = "", OS[15] = "";
 char cadastro[55] = "", telefonecontato[15] = "", resultadobusca, numconvenio[11]
= "", categoria[11] = "", resenha[255] = "";
 char sexo[10] = "", endereco[60] = "", ctps[11] = "", idadeString[3] = "", cpf[12] = "",
nome[40] = "", data[11] = "", hora[9] = "";
 char login[60] = "", senha[60] = "", auxsenha[60] = "", auxlogin[60] = "",
cadastroOS[53] = "", consultaficha[50] = "", baixaOS[40] = "";
 char criapastalogin[50] = "mkdir system-moderadores\\logins\\",
criapastasenha[50] = "mkdir system-moderadores\\logins\\",
caminho_recl_sugs_elo[62] = "sugerir-reclamar-elogiar\\";
 char resp[3] = ""; // Declaração de variavel do tipo char para controle de respostas
 char *eptr; //Declaracao de variavel ponteiro tipo char
 long long recebecpf, recebetel; //Declaracao de variavel long long(inteiro)
 system("mode 122,62 & title CENTRAL ADMINSTRATIVA"); // Modulariza o
tamanho da tela para 122 colunas por 62 linhas.
 //Verifica se o usuario já realizou a troca da senha padrao
 file = fopen(verificarsenhapadrao, "r");
 if((admin == false && moderador == true) && file != NULL){
 trocar_senha_padrao = true;
 fclose(file);
 system("msg * A CENTRAL DE SEGURANCA DA INFORMACAO ADVERTE.
PARA A SUA SEGURANCA SERA NECESSARIO REALIZAR A TROCA DA SENHA
PADRAO UTILIZANDO O COMANDO B0!");
 }else{
 fclose(file);
 trocar_senha_padrao = false;
 }
 // MENU INICIAL QUE APARECERA PARA O USUARIO APOS A EXECUCAO
DO SOFWARE
 printf("\n ***********************
HOJE É [%d/%d/%d]\n", dataloc->tm_mday, dataloc->tm_mon+1, dataloc-
>tm_year+1900);
 printf(" _______________________________________________*
*________________________________________________\n");
 printf(" _______________________________________________> ABA
PRINCIPAL <________________________________________________\n");
 printf(" *
* \n");
 printf(" ***********************
\n");
 printf("\n
****************************************************************************** \n");
 printf(" * * LOG
ON \n");
 printf(" * -- BEM VINDO A CENTRAL DE GERENCIAMENTO
INTERNO -- * ____________ \n");
 printf(" *
* \n");
 printf("
****************************************************************************** [ %s ] \n\n",
identificacao_menu);
 printf("
_____________________________________________________________________
_________________________________________________\n\n");
 printf(" PARA PROSSEGUIR DIGITE A SIGLA DE 2 DIGITOS
CORRESPONDENTE A SUA SOLICITACAO \n");
 printf("
_____________________________________________________________________
_________________________________________________\n\n");
 printf("
***************************************************************************************************
*******************\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A1 - CADASTRAR UM NOVO FUNCIONARIO/MEDICO AD
- GERAR RELATORIO DE DESEMPENHO DIARIO NA TELA *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A2 - CADASTRAR UM NOVO PACIENTE AE -
EXPORTAR RELATORIO DE DESEMPENHO PARA O EXCEL *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A3 - CADASTAR UMA ORDEM DE AGENDAMENTO
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A4 - CONSULTAR O CADASTRO DE UM MEDICO/FUNCIONARIO
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A5 - CONSULTAR O CADASTRO DE UM PACIENTE
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A6 - CONSULTAR UM AGENDAMENTO PENDENTE
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A7 - CONSULTAR AGENDAMENTO EM HISTORICO
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A8 - REGISTRAR RECLAMACAO/SUGESTAO/ELOGIO
*\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * A9 - CONSULTAR RECLAMACAO/SUGESTAO/ELOGIO
DG - DANGER ZONE / DELETAR UM USUARIO DO SISTEMA *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * AA - REGISTRAR UM CHAMADO INTERNO - TI B1 -
LOGAR COM UM NOVO USUARIO *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * AB -CONSULTAR UM CHAMADO INTERNO - TI B0 -
TROCAR SENHA DE USUARIO *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf(" * AC - CONSULTAR UM CHAMADO INTERNO EM HISTORICO - TI
A0 - PARA SAIR DO SISTEMA -> -> -> -> -> [SAIDA] *\n");
 printf(" *
------------------------------------------------------------------------------------------------------------------
*\n");
 printf("
***************************************************************************************************
*******************\n\n");
 printf(" RESPOSTA --> ");
 scanf("%s", &resp);
 lb(); // Limpa o buffer do teclado
 //BLOCO CONDICIONAL DO MENU INICIAL
 if(strcmp(resp, "A1") == 0 || strcmp(resp, "a1") == 0){
limpatela(); // Limpa a tela
char diploma[15] = "";
if (admin == false){ // O usuario só poderá criar um novo cadastro
de funcionário se houver permissão de administrador.
 system(" msg * VOCE NAO POSSUI PRIVILEGIOS DE ADMINSTRADOR
PARA EXECUTAR ESTA FUNCAO.");
 goto iniciar; // Direciona o usuario para tela inicial.
}
printf("\n
***************************************************************************************************
*********************");
printf("\n * CADASTRO DE
FUNCIONARIOS E MEDICOS *");
printf("\n
***************************************************************************************************
*********************\n\n");
 // validação de idade para cadastro
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 //Entrada de dados do usuario.
 printf("\n ENTRE COM A IDADE DO
COLABORADOR....................................: ");
 scanf("%s", &idadeString);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 idade = atoi(idadeString); // Converte uma string para um inteiro.
 if (idade < 21 || idade > 65){ // Valida a idade do usuario
 // Entrada de dados do usuario
 printf("\n ESTE COLABORADOR NAO POSSUI IDADE QUE SE
ENCONTRE NO PADRAO DE CADASTRO DE FUNCIONARIOS!\n");
 lform(); // Linha formatada
 printf("\n PARA CANCELAR DIGITE 0 OU 1 PARA CONTINUAR: ");
 scanf("%d", &confirma);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(confirma == 0){ // Verifica se o usuario digitou 0 para cancelar a
solicitação
 goto iniciar; // Direciona o usuario para o menu iniciar
 }else{
 continue;
 }
 }else{
 break; // Encerra o looping
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 // Bloco cadastro com entrada de dados do usuario
 
 printf("\n ENTRE COM O NOME DO COLABORADOR.....................................:
");
 scanf("%[^\n]", &nome); // Faz a leitura da string
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 printf("\n ESCOLHA O SEXO DO COLABORADOR [0 - MASCULINO / 1 -
FEMININO]........: ");
 scanf("%d", &aux);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(aux == 1){ // Validar um sexo padrão.
 strcat(sexo, "FEMININO");
 break; // Encerra o looping
 }else if(aux == 0){ // Validar um sexo padrão.
 strcat(sexo, "MASCULINO");
 break; // Encerra o looping
 }else{ // Validar retorna um erro caso a opção escolhida não seja 1 ou 0.
 printf("\n ALTERNATIVA INVALIDA. TENTE NOVAMENTE!\n");
 lform(); // Linha formatada
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 // Validar a entrada de um CPF
 printf("\n ENTRE COM O CPF DO
COLABORADOR......................................: ");
 scanf("%s", &cpf);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 recebecpf = strtoll(cpf, &eptr, 10); // Converte uma string em um numero
inteiro do tipo long long
 // CONCATENACAO DE STRINGS
 strcat(cadastro, "funcionarios\\"); // Concatena a pasta de funcionarios na
variavel cadastro
 strcat(cadastro, cpf); // Concatena o cpf no cadastro
 strcat(cadastro, ext); // Concatena o cpf com a extensão txt no cadastro;
 file = fopen(cadastro, "r"); // Abre um arquivo de texto em modo leitura
 if(file != NULL){ // Verifica se o colaborador já está cadastrado.
 system("msg * COLABORADOR JA CADASTRADO NO BANCO DE
FUNCIONARIOS. CADASTRO CANCELADO PELO SISTEMA."); // Apresenta uma
POP UP com uma mensagem para o usuario
 fclose(file); // Fecha o arquivo de texto caso tenha sido aberto.
 goto iniciar; // Direciona o usuario para a tela de cadastros.
 }
 fclose(file); // Fecha o arquivo de texto caso tenha sido aberto.
 if(validaCPF(recebecpf) == false){
 printf("\n CPF INVALIDO. TENTE NOVAMENTE!\n");
 lform(); // Linha formatada
 }else{ // Se o CPF for válido será declarada uma variavel temporaria para
receber um determinado valor
 for(contador = 0; contador < 3; contador++){
 printf("\n EQUIPES DISPONIVEIS PARA
SELECAO....................................: [0 - CT] [1 - CE] [2 - CO]\n");
 lform(); // Linha formatada
 printf("\n INFORME A QUAL EQUIPE PERTENCERA O
COLABORADOR......................: ");
 scanf("%d", &aux);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(aux == 0 || aux == 1 || aux == 2){
 break; // Encerra a repetição
 }else{
 system("msg * UTILIZE UMA OPCAO VALIDA. TENTE 1, 2 OU 3!");
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS.
SOLICITACAO CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP
informativa na tela do usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 if(aux == 0){strcat(sigla, "CT");
 }else if(aux == 1){
 strcat(sigla, "CE");
 }else{
 strcat(sigla, "CO");
 }
 char temp[10] = ""; // Declaração de variavel temporaria
 aux = criarnumusuario(recebecpf); // a variavel auxiliar recebera o numero
de usuario de acordo com o CPF digitado
 itoa(aux, temp, 10); // Converte o valor inteiro para string
 strcat(auxlogin, sigla); // Concatena a sigla da empresa a variavel de login
 strcat(auxlogin, temp); // Concatena o valor da variavel temporaria para
criar um login de usuario
 break; // encerra o looping
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }// ENCERRAMENTO DA ESTRUTURA DE REPETICAO
 printf("\n DIGITE O ENDERECO DE LOCALIZACAO DO
COLABORADOR.....................: ");
 scanf("%[^\n]", &endereco);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 // Validar a entrada de um telefone de contato
 printf("\n INFORME O TELEFONE DE CONTATO COM O DDD(SEM
ESPACOS E SEM O ZERO)...: ");
 scanf("%s", &telefonecontato);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 recebetel = strtoll(telefonecontato, &eptr, 10); // Converte uma string em um
numero inteiro do tipo long long
 if(validaTEL(recebetel) == false){
 printf("\n TELEFONE INCORRETO, FAVOR TENTAR NOVAMENTE!\
n");
 lform(); // Linha formatada
 }else{
 break; // Encerra o looping
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 } // ENCERRAMENTO DA ESTRUTURA DE REPETICAO
 printf("\n INFORME O ID - CARTEIRA DE TRABALHO.................................:
");
 scanf("%s", &ctps);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 printf("\n TIPOS DE COLABORADOR DISPONIVELS....................................:
[0 - FUNCIONARIO] - [1 - MEDICO]\n");
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){
 printf("\n INFORME O TIPO DO COLABORADOR.......................................:
");
 scanf("%d", &aux);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(aux == 0 || aux == 1){
 break;
 }else{
 system("msg * OPCAO INVALIDA. TENTE DIGITAR 0 OU 1!");
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 if(aux == 1){
 printf("\n ID DO CERTIFICADO DE MEDICINA.......................................: ");
 scanf("%s", &diploma);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 confirmacadastro(nome, "N/A", idadeString, sexo, cpf, endereco,
telefonecontato, ctps, diploma, "N/A"); // Mostra na tela as informações do cadastro
para que o usuario posssa confirma-las.
 printf("\n DESEJA FINALIZAR O CADASTRO DO COLABORADOR? [0 -
NÃO / 1 - SIM].....: ");
 scanf("%d", &confirma);
 lb(); // Limpa o buffer do teclado
 if(confirma == 0){
 system("msg * CADASTRO CANCELADO PELO USUARIO"); //
Apresenta uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial
 
 }
 cadastrar(cadastro, nome, idadeString, sexo, endereco, cpf,
telefonecontato); //Acrescentando informaçoes basicas de cadastro no arquivo de texto
utilizando a funcao cadastrar.
 //Acrescebtabdi demais informações
 file = fopen(cadastro, "a"); // Abre o arquivo de texto
 fputs("\n CARTEIRA DE TRABALHO.............: ", file);
 fputs(ctps, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n CERTIFICACAO DIPLOMA MEDICO......: ", file);
 fputs(diploma, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n LOGIN CORPORATIVO................: ", file);
 fputs(auxlogin, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n TIPO.............................: MEDICO", file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fclose(file); // Fecha o arquivo
 createloginsenha(criapastalogin, criapastasenha, auxlogin, cpf); // Cria o
login e senha do usuario que foi cadastrado
 system("msg * MEDICO CADASTRADO COM SUCESSO!\n"); // Apresenta
uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela de de inicio.
 
 }else if(aux == 0){
 // Revisão de informações no cadastro.
 confirmacadastro(nome,"N/A",idadeString,sexo,cpf,endereco,telefonecontato
,ctps,"N/A","N/A"); // Chama a função para apresentar as informações na tela para o
usuario
 printf("\n DESEJA FINALIZAR O CADASTRO DO COLABORADOR? [0 -
NÃO / 1 - SIM].....: ");
 scanf("%d", &confirma);
 lform(); // Linha formatada
 if(confirma == 0){
 system("msg * CADASTRO CANCELADO PELO USUARIO."); //
Apresenta uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial.
 }
 //Acrescentando informaçoes basicas de cadastro no arquivo de texto
utilizando a funcao cadastrar.
 cadastrar(cadastro, nome, idadeString, sexo, endereco, cpf,
telefonecontato);
 //Acrescentando demais informacoes no cadastro.
 file = fopen(cadastro, "a");
 fputs("\n CARTEIRA DE TRABALHO.............: ", file);
 fputs(ctps, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n LOGIN CORPORATIVO................: ", file);
 fputs(auxlogin, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",file);
 fputs("\n TIPO.............................: FUNCIONARIO", file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fclose(file); // Fecha o arquivo de texto
 createloginsenha(criapastalogin, criapastasenha, auxlogin, cpf); // Cria o
login e a senha do usuario que foi cadastrado
 file = fopen(verificarsenhapadrao, "w"); // Abre o arquivo de texto e Cria o
verificador da senha padrao
 fclose(file); // Fecha o arquivo de texto
 system("msg * COLABORADOR CADASTRADO COM SUCESSO!"); //
Apresenta uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial.
 }
 }else if(strcmp(resp, "A2") == 0 || strcmp(resp, "a2") == 0){
 limpatela(); // Limpa a tela
 char criapastapaciente[42] = "mkdir pacientes\\", nomemae[40] = "";
 printf("\n
***************************************************************************************************
*********************");
printf("\n * CADASTRO DE
PACIENTES *");
printf("\n
***************************************************************************************************
*********************\n\n");
 if (admin == false && moderador == false){
 system("msg * VOCE NAO POSSUI PRIVILEGIOS DE ADMINSTRADOR
PARA EXECUTAR ESTA FUNCAO."); // Apresenta uma POP UP com uma mensagem
para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial
}
//Entrada de dados do usuario.
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 printf("\n ENTRE COM A IDADE DO PACIENTE....................................: ");
 scanf("%d", &idade);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 itoa(idade, idadeString, 10); // Converter um inteiro para string
 if(idade < 0 && idade >= 150){
 printf("\n IDADE INVALIDA. TENTE NOVAMENTE.\n");
 }else{
 break;
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
}
 // Bloco cadastro com entrada de dados do usuario
 printf("\n ENTRE COM O NOME DO PACIENTE.....................................: ");
 scanf("%[^\n]", &nome);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 printf("\n ENTRE COM O NOME DA MAE DO PACIENTE..............................:
");
 scanf("%[^\n]", &nomemae);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 printf("\n POSSUI PLANO DE SAUDE(CONVENIO MEDICO)? [0 - NÃO / 1
- SIM]......: ");
 scanf("%d", &aux);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(aux == 1){
 printf("\n IDENTIFICACAO - CARTAO CONVENIO..................................:
");
 scanf("%[^\n]", &numconvenio);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 break;
 }else if(aux == 0){
 strcat(numconvenio, "N/A");
 break;
 }else{
 printf("\n ALTERNATVA INVALIDA. TENTE NOVAMENTE!\n");
 lform(); // Linha formatada
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 
 }
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 // Validar um sexo padrão.
 printf("\n INFORME O SEXO DO PACIENTE [0 - MASCULINO / 1 -
FEMININO]........: ");
 scanf("%d", &aux);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 if(aux == 1){
 strcat(sexo, "FEMININO");
 break;
 }else if(aux == 0){
 strcat(sexo, "MASCULINO");
 break;
 }else{
 printf("\n ALTERNATIVA INVALIDA. TENTE NOVAMENTE!\n");
 lform(); // Linha formatada
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 // Validar a entrada de um CPF
 printf("\n ENTRE COM O CPF DO PACIENTE......................................: ");
 scanf("%s", &cpf);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 recebecpf = strtoll(cpf, &eptr, 10);
 if(validaCPF(recebecpf) == false){
 printf("\n CPF INVALIDO TENTE NOVAMENTE!");
 lform(); // Linha formatada
 }else{
 break;
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuario para o menu iniciar;
 }
 }
 printf("\n DIGITE O ENDERECO DE LOCALIZACAO DO
PACIENTE.....................: ");
 scanf("%[^\n]", &endereco);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 // Validar a entrada de um telefone de contato
 printf("\n INFORME O TELEFONE DE CONTATO COM O DDD(SEM
ESPACOS E SEM O ZERO): ");
 scanf("%s", &telefonecontato);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 recebetel = strtoll(telefonecontato, &eptr, 10); // Convete uma string em um
numero inteiro do tipo long long
 if(validaTEL(recebetel) == false){
 printf("\n TELEFONE INCORRETO, FAVOR TENTAR NOVAMENTE.\n");
 lform(); // Linha formatada
 }else{
 break;
 }
 if(contador == 2){
 system("msg * NUMERO DE TENTATIVAS ESGOTADAS. SOLICITACAO
CANCELADA PELO SISTEMA!"); // Apresenta uma POP-UP informativa na tela do
usuario.
 goto iniciar; // Direciona o usuariopara o menu iniciar;
 }
 }
 // Revisão de informações no cadastro.
 confirmacadastro(nome,nomemae,idadeString,sexo,cpf,endereco,telefoneconta
to,ctps,"N/A",numconvenio);
 printf("\n DESEJA FINALIZAR O CADASTRO DO PACIENTE? [0 - NÃO / 1 -
SIM].....: ");
 scanf("%d", &confirma);
 lform(); // Linha formatada
 if(confirma == 0){
 system("msg * CADASTRO CANCELADO PELO USUARIO"); // Apresenta
uma POP UP com uma mensagem para o usuario
 goto iniciar;
 }
 strcat(criapastapaciente, cpf);// CRIANDO CAMINHO DA PASTA COM
INFORMACOES DO PACIENTE
 system(criapastapaciente); // CRIA A PASTA COM AS INFORMACOES DO
PACIENTE;
 if(strcmp(numconvenio, "N/A") == 1){ // Se O cliente possuir um convênio
médico, este será guardado no "banco de dados"
 char temporario[60] = "pacientes\\"; // Concatena a pasta de destino para
acrescentar as informações ao bloco de texto
 strcat(temporario, cpf); // Concaten o CPF do cliente
 strcat(temporario, "\\true"); // Concatena o separador de diretorios
 strcat(temporario, ext); // Concatena a extensão .txt
 file = fopen(temporario, "a"); // abre o arquivo de texto em modo de
escrita(cria o arquivo)
 fclose(file); // Fecha o arquivo de texto.
 }
 //Acrescentando demais informacoes no cadastro.
 strcat(cadastro, "pacientes\\");
 strcat(cadastro, cpf); // Concatena o cpf no cadastro
 strcat(cadastro, "\\"); // Concatena o separador de diretorios
 strcat(cadastro, cpf); // Concatena o cpf no cadastro
 strcat(cadastro, ext); // Concatena o cpf com a extensão txt no cadastro;
 file = fopen(cadastro, "r"); // Abre um arquivo de texto em modo leitura
 if(file != NULL){ // Verifica se o colaborador já está cadastrado.
 system("msg * ESTE PACIENTE JA CONSTA CADASTRADO NO BANCO
DE CADASTROS. CADASTRO CANCELADO PELO SISTEMA!."); // Apresenta uma
POP UP com uma mensagem para o usuario
 fclose(file); // Fecha o arquivo de texto caso tenha sido aberto.
 goto iniciar; // Direciona o usuario para a tela de cadastros.
 }
 fclose(file);// Fecha o arquivo de texto aberto.
 cadastrar(cadastro, nome, idadeString, sexo, endereco, cpf,
telefonecontato); //Acrescentando informaçoes basicas de cadastro no arquivo de texto
com a função cadastrar.
 //Acrescentando demais informacoes no cadastro.
 file = fopen(cadastro, "a");
 fputs("\n NOME DA MAE......................: ", file);
 fputs(nomemae, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n CARTAO DE CONVENIO...............: ", file);
 fputs(numconvenio, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n TIPO.............................: PACIENTE", file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fclose(file); // Fecha o arquivo
 system("msg * PACIENTE CADASTRADO COM SUCESSO!"); // Apresenta
uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para tela de inicio
 }else if(strcmp(resp, "A3") == 0 || strcmp(resp, "a3") == 0){
 char sdia[3] = "", smes[3] = "", sano[5] = "";
 int idia, imes, iano;
 if(admin == false && moderador == false){
 system("msg * VOCE NAO POSSUI PRIVILEGIOS PARA EXECUTAR
ESSA FUNCAO!"); // Apresenta uma popup na tela do usuario
 goto iniciar; // Direciona o usuario para a tela inicial
 }
 limpatela(); // Limpa a tela
 float valorconsulta;
 char verificaconv[35] = "pacientes\\", verificapaciente[45] = "pacientes\\",
svalorconsulta[10] = "";
 printf("\n
***************************************************************************************************
*********************");
printf("\n * CADASTRO DE
AGENDAMENTOS *");
printf("\n
***************************************************************************************************
*********************\n\n");
 // Entrada de dados do usuario
 printf("\n ENTRE COM O CPF DO PACIENTE......................................: ");
 scanf("%s", &cpf);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 // CONCATENACAO DE STRINGS
 strcat(verificapaciente, cpf); // Concatena o CPF
 strcat(verificapaciente, "\\"); // Concatena o separador de diretorios
 strcat(verificapaciente, cpf); // Concatena o cpf no cadastro
 strcat(verificapaciente, ext); // Concatena o cpf com a extensão txt no cadastro;
 strcat(verificaconv, cpf); // Concatena o cpf na variavel de verificar convenio
 strcat(verificaconv, "\\true.txt"); // Concatena o separador de diretorios
 // Valida se o paciente já está cadastrado no sistema.
 if(file = fopen(verificapaciente, "r")){ // abre o arquivo de texto e verifica se o
paciente já está cadastrado
 fclose(file); // Fecha o arquivo de texto
 }else{ // Se a afirmação inicial for falsa significa que o paciente não está
cadastrado.
 system("msg * PACIENTE NAO LOCALIZADO! FAVOR CADASTRA-LO
PRIMEIRAMENTE."); // Apresenta uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial
 }
 // ENTRADA DE DADOS DO USUARIO
 printf("\n INFORME O NOME DO MEDICO QUE FARA O
ATENDIMENTO..................: ");
 scanf("%[^\n]", &nome);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 printf("\n ENTRE COM A DATA DO AGENDAMENTO.\n");
 lform(); // Linha formatada
 printf("\n DIA..............................................................: ");
 scanf("%d", &idia);
 while(idia <= 0 || idia > 31){
 lb(); // Limpa o buffer do teclado
 system("msg * DIA INVALIDO, FAVOR DIGITAR UM DIA VALIDO!");
 printf("\n DIA..............................................................: ");
 scanf("%d", &idia);
 }
 lb(); // Limpa o buffer do teclado
 printf("\n MES..............................................................: ");
 scanf("%d", &imes);
 while(imes <= 0 || imes > 12){
 lb(); // Limpa o buffer do teclado
 system("msg * MES INVALIDO, FAVOR DIGITAR UM DIA VALIDO!");
 printf("\n MES..............................................................: ");
 scanf("%d", &imes);
 }
 lb(); // Limpa o buffer do teclado
 printf("\n ANO..............................................................: ");
 scanf("%d", &iano);
 while(iano < (dataloc->tm_year+1900) || iano > (dataloc->tm_year+1901)){
 lb(); // Limpa o buffer do teclado
 if(iano < (dataloc->tm_year+1900)){
 system("msg * O ANO INFORMADO NAO PODE SER REGISTRADO,
POIS NAO PODE-SE AGENDAR ALGO PARA O PASSADO.");}else if(iano > (dataloc->tm_year+1901)){
 system("msg * O ANO INFORMADO NAO PODE SER REGISTRADO,
POIS ESTA LONGE DE OCORRER. TENTE DIGITAR UM ANO MAIS RECENTE!");
 }
 printf("\n ANO..............................................................: ");
 scanf("%d", &iano);
 }
 lb(); // Limpa o buffer do teclado
 // PROCESSO DE CONVERSAO DOS NUMEROS DE INTEIRO PARA
STRING
 itoa(idia, sdia, 10);
 itoa(imes, smes, 10);
 itoa(iano, sano, 10);
 //PROCESSO DE CONCATENACAO DE STRINGS
 strcat(data, sdia);
 strcat(data, "/");
 strcat(data, smes);
 strcat(data, "/");
 strcat(data, sano);
 lform(); // Linha formatada
 printf("\n HORARIO DE AGENDAMENTO(FORMATO
23:59:59).........................: ");
 scanf("%s", &hora);
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 printf("\n VALOR A SER PAGO(FORMATO R$00.00)................................:
R$");
 scanf("%f", &valorconsulta);
 // VERIFICAÇÃO DO ARQUIVO
 if(file = fopen(verificaconv, "r")){
 fclose(file);
 system("msg * ESTE PACIENTE POSSUI CONVENIO MEDICO, O VALOR
SERA REAJUSTADO AUTOMATICAMENTE.");
 valorconsulta = valorconsulta - (valorconsulta * 60 / 100);
 }
 sprintf(svalorconsulta, "%.2f", valorconsulta); // converte um valor float para
uma string
 lb(); // Limpa o buffer do teclado
 lform(); // Linha formatada
 printf("\n -- CONFIRMACAO DE CADASTRO -- ");
 lform(); // Linha formatada
 printf("\n MEDICO QUE ATENDERA O PACIENTE..............: %s", nome);
 lform(); // Linha formatada
 printf("\n DATA/HORA DO AGENDAMENTO....................: %s AS %s", data,
hora);
 lform(); // Linha formatada
 printf("\n VALOR TOTAL A SER PAGO......................: R$%.2f",
valorconsulta);
 lform(); // Linha formatada
 printf("\n\n\n AS INFORMACOES ESTAO CORRETAS? [0 - CANCELAR / 1 -
CONCLUIR]: ");
 scanf("%d", &confirma);
 lform(); // Linha formatada
 for(contador = 0; contador < 3; contador++){ // inicia um looping com 3
tentativas para acertividade do que for solicitado.
 if(confirma == 0){
 system("msg * PEDIDO CANCELADO PELO USUARIO!"); // Apresenta
uma POP UP com uma mensagem para o usuario
 goto iniciar; // Direciona o usuario para a tela inicial
 }else if(confirma == 1){
 numos = gerarOS(); // Funcao para gerar a ordem de servico
 printf("\n ORDEM DE SERVICO DO AGENDAMENTO.................: %d\n",
numos); // informa o numero da ordem de serviço para o usuario
 lform(); // Linha formatada
 itoa(numos, OS, 10); // Converte inteiro para string
 //PROCESSO DE CONCATENACAO DE STRINGS
 strcat(auxiliarOS, "agendamentos\\concluidos\\"); // Concatena o caminho
da pasta onde sera armazenado a OS na varaivel auxiliaros
 strcat(cadastroOS, "agendamentos\\"); // Concatena a pasta de
armazenameto da OS
 strcat(cadastroOS, "AG"); // Concatena a pasta de armazenamento da
OS.
 strcat(cadastroOS, OS); // Concatena o numero da OS na variavel de
cadastro
 strcat(cadastroOS, ext); // Concatena a extensao .txt na variavel de
cadastrar a os
 strcat(auxiliarOS, "AG"); // Concatena a pasta de armazenamento da OS.
 strcat(auxiliarOS, OS); // Concatena o numero da ordem de servico na
variavel auxiliaros
 strcat(auxiliarOS, ext); // Concatena a extensão .txt na variavel auxiliaros
 file = fopen(cadastroOS, "a"); // Abre o arquivo de texto.
 // Acrescentando informações no bloco de texto
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n AGENDAMENTO ABERTO POR......................: ", file);
 fputs(identificacao_menu, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n MEDICO QUE FARA O ATENDIMENTO...............: ", file);
 fputs(nome, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n CPF DO PACIENTE.............................: ", file);
 fputs(cpf, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n VALOR A SER PAGO............................: R$", file);
 fputs(svalorconsulta, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n PREVISAO DA CONCLUSAO DO AGENDAMENTO........: ",
file);
 fputs(data, file);
 fputs(" - ", file);
 fputs(hora, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n ORDEM DE SERVICO............................: AG", file);
 fputs(OS, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fclose(file); // Fecha o arquivo de texto
 //Abre arquivo de texto auxiliar.
 file = fopen(auxiliarOS, "a");
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n AGENDAMENTO ABERTO POR......................: ", file);
 fputs(identificacao_menu, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n MEDICO QUE FARA O ATENDIMENTO...............: ", file);
 fputs(nome, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n CPF DO PACIENTE.............................: ", file);
 fputs(cpf, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n VALOR A SER PAGO............................: R$", file);
 fputs(svalorconsulta, file);
 fputs("\n
------------------------------------------------------------------------------------------------------------------",
file);
 fputs("\n PREVISAO DA CONCLUSAO DO AGENDAMENTO........: ",
file);
 fputs(data, file);
 fputs(" - ", file);
 fputs(hora, file);