UNIP_PIM VI_Jamilly Alcantara Costa_RA 2023765

Prévia do material em texto

2
UNIP EaD
Projeto Integrado Multidisciplinar
Cursos Superiores de Tecnologia
Criação de um Software e de Processos de Gestão de Serviços de TI
Polo Cajamar 
2021
UNIP EaD 
Projeto Integrado Multidisciplinar 
Cursos Superiores de Tecnologia 
Criação de um Software e de Processos de Gestão de Serviços de TI
Nome: Jamilly Alcantara Costa
RA: 2023765
Curso: Gestão de Tecnologia da Informação
Semestre: 3°
Polo Cajamar 
2021
Resumo
Este projeto tem como objetivo apresentar uma proposta para desenvolvimento de um sistema de cadastro de uma rede de locadora de veículos e definir os principais processos que envolvem a gestão de serviços de TI.
Com base nos conhecimentos das disciplinas de Gerenciamento de Serviços de TI, Fundamentos de Engenharia de Software e Algoritmos, será possível oferecer um software para a rede de locadora de veículos e apresentar os principais processos que envolvem a gestão de serviços de TI.
Palavras-chave: software, sistema de cadastro, gestão de serviços de TI.
Abstract
This project aims to present a proposal for the development of a registration system for a car rental network and to define the main processes involving the management of IT services.
Based on the knowledge of the disciplines of IT Service Management, Fundamentals of Software Engineering and Algorithms, it will be possible to offer software for the car rental network and present the main processes involving the management of IT services.
Keywords: software, registration system, IT service management.
Sumário
1.	INTRODUÇÃO	6
2.	SOBRE O NEGÓCIO	7
2.1	Unidades de Negócio	7
3.	OBJETIVOS	9
4.	SISTEMA UTILIZADO	10
5.	TECNOLOGIA UTILIZADA	21
5.1	Principais recursos e características da linguagem C	22
6.	LEVANTAMENTO E ANÁLISE DE REQUISITOS	23
6.1	Requisitos do usuário	24
6.2	Requisitos funcionais	24
6.3	Requisitos não funcionais	25
6.4	Requisitos de sistema	26
7.	PROCESSOS DE GESTÃO DE TI	26
7.1	Definição do Serviço de TI	26
7.2	Principais responsabilidades da área	27
7.3	Catálogo de Serviços de TI e SLAs	27
7.4	Boas Práticas na Gestão de TI	27
8.	CONCLUSÃO	29
9.	REFERÊNCIAS	29
INTRODUÇÃO
A mobilidade urbana no país é um tema que está sempre em transformação e traz novidades e formas melhores sobre como se transitar nas grandes cidades. Ou seja, com o objetivo comum de diminuir o trânsito, reduzir a poluição que os veículos geram, e até mesmo economizar, o compartilhamento de carros foi introduzido. Essa é uma modalidade que ganhou espaço nos últimos anos e que está sendo utilizado cada vez mais por mais pessoas. 
A mobilidade urbana no Brasil é um tema recorrente, já que estamos falando sobre como as pessoas se locomovem diariamente pelas ruas das cidades. 
Portanto, seja de forma coletiva, como no transporte público, ou de maneira individual, como no veículo próprio, a mobilidade no país está em constante transformação.
Com a ajuda da tecnologia, novas opções e maneiras de se locomover surgem a todo momento, e até mesmo com a pandemia, a forma como as pessoas se deslocam diariamente mudou. 
O transporte público por exemplo, foi analisado e visto como uma das piores formas de se locomover diante de uma pandemia. 
Neste ponto, não podemos deixar de notar que novas modalidades começaram a se destacar cada vez mais no mercado. 
Com isso, o aluguel por assinatura e o compartilhamento de carros são opções que estão ganhando espaço de diversas formas e fazendo com que as pessoas reavaliem a forma que transitam.
SOBRE O NEGÓCIO
Diante deste cenário pandêmico do novo Corona Vírus, surgiu a GoCar. Uma empresa locadora de veículos preocupada com questões sanitárias, com foco na mobilidade de forma segura e na comodidade das pessoas.
Unidades de Negócio
Com o objetivo de conferir personalidade à marca, o nosso conceito de lojas sustenta a ideia de um espaço que ofereça conforto, qualidade, variedade, preço justo e atendimento diferenciado, proporcionando a satisfação do cliente.
A empresa vem construindo sua história de sucesso, alcançando, a cada ano, números mais positivos, resultado de uma postura inovadora da instituição, que trabalha constantemente para oferecer produtos e prestar serviços com a máxima qualidade. Atualmente, operamos com uma matriz em São Paulo-Capital, filiais espalhadas em 5 grandes cidades do Estado de SP, além de outras 3 grandes capitais do Brasil.
Os locais escolhidos para as unidades listadas a seguir, foram locais extremamente estratégicos, próximo dos aeroportos das principais cidades brasileiras, pois possuem grande fluxo de pessoas, boa visualização e fácil acesso para os clientes.
 
Matriz
Av. Brigadeiro Faria Lima, 1461, 18º andar – Jd.: Paulistano - São Paulo - SP - CEP: 05401-009
Filiais grande São Paulo
Guarulhos: Av. das Hortênsias, 555 – Jd Campestre, Guarulhos, SP – CEP: 06985-569
Campinas: Rua Paulo Brossard, 142 – Centro, Campinas, SP - CEP: 98547-325
Cajamar: Av. das Palmeiras, 620 - Portais, Cajamar, SP - CEP: 07790-890
Osasco: Av. Andromeda, 9870 – Jd da Glória, Osasco, SP - CEP: 08963-555
Santo André: Av. dos Cravos, 6985 - Portal dos Anjos, Santo André - CEP: 8962-000
Filiais grandes capitais do Brasil
Rio de Janeiro: Av. São Paulo, 8697, Centro, Rio de Janeiro - RJ - CEP: 99998-122
Brasília: Setor LBC, Quadra 10, Asa Norte - Brasília, Distrito Federal - CEP 00001-001
Salvador: Rua Alcantara, 2202, Jd Costa, Salvador - BA - CEP: 15632-333
OBJETIVOS
Com a era da informação as empresas têm à disposição um grupo de ferramentas que possibilitam entender melhor o negócio e desenvolver produtos e serviços específicos para atender às necessidades dos clientes. A internet foi a responsável por acabar com as fronteiras do comércio mundial, quebrando barreiras geográficas existentes há séculos. Sendo assim, podemos afirmar que a gestão de TI se tornou uma vantagem competitiva.
Gestão da Tecnologia da Informação é a administração dos recursos de tecnologia utilizados no processo de tratamento da informação de uma organização. Esse processo envolve coleta, armazenamento, processamento, seleção, comparação, distribuição e avaliação de dados, que serão convertidos em informações úteis para a tomada de decisão.
Em busca de governança e com o propósito de organizar e melhorar a infraestrutura de tecnologia, os processos da GoCar serão baseados em ITIL, centralizando e administrando o atendimento de TI em todas as unidades e criando uma infraestrutura que atenda à empresa de forma mais efetiva. Com isso, atenderemos as novas exigências de mercado e, consequentemente, atrairemos novos investimentos.
A exigência de adoção das melhores práticas para alinhamento da tecnologia aos negócios é extremamente importante, pois apenas com esta implantação de governança de TI poderemos suportar o crescimento estimado de 50% da receita ao ano. Sendo assim, é imprescindível manter uma rede segura.
A aposta da GoCar é em inovação, modelos ágeis de gestão e novas tecnologias com um único objetivo: tornar-se a maior plataforma de mobilidade do país.
Foi durante a pandemia da Covid-19 que realizamos um grande diferencial do negócio. Apostamos na possibilidade de aluguel de veículos com a apresentação de um QR Code. Esta necessidade surgiu do nosso principal objetivo: o controle da disseminação do novo Corona Vírus, onde o distanciamento social se tornou primordial. Foi pensando na diminuição de filas e aglomerações que esta solução foi desenvolvida.
Com a novidade, basta o cliente reservar o carro pelo site e retirá-lo nas unidades da GoCar apresentando o QR Code.
SISTEMA UTILIZADO
Foi utilizado um código em linguagem C incrementado com sistema de login, que é capaz de cadastrar usuários, cadastro de veículos, relatórios e cálculo do aluguel do veículo. O sistema leva em consideração cálculos da taxa de quilometragem livre, cálculo da diária (tempo que de aluguel do veículo), descontos para idosos e empresas parceiras de 10% e 5%, respectivamente. Neste sistema é possível tambémcalcular a multa de atraso.
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include <stdlib.h>
char c;
typedef struct veic{ /* Estrutura de Veiculo */
 char placa[8];
 char marca[15];
 char modelo[30];
 int ano;
 struct veic* prox;
} tveic;
typedef tveic* veiculo;
typedef struct data{
 int dia;
 int mes;
 int ano;
} tdata;
typedef struct manut{ /* Estrutura de Manutencao */
 int km;
 tdata data;
 double valor;
 char placa[8];
 struct manut* prox;
} tmanut;
typedef tmanut* manutencao;
void flush_in (){ /* Funcao para limpar o buffer */
 int ch;
 while( (ch = fgetc(stdin)) != EOF && ch != '\n' ){}
}
void inputs (char *prompt, char *s, int count){ /* Funcao para receber strings com o gets e verificar se cabem dentro do vetor */
 char p[255];
 do {
 printf(prompt);
 gets(p);
 if(strlen(p)>count) printf("\nmuito longo\n");
 } while (strlen(p)>count);
 strcpy(s, p);
}
void criarv (veiculo *L){ /* Funcao que cria a lista encadeada vazia veiculo */
 *L = NULL;
}
void criarm (manutencao *L){ /* Funcao que cria a lista encadeada vazia manutencao */
 *L = NULL;
}
int vaziaveiculo (veiculo L){ /* Funcao que verifica se a lista veiculo esta vazia */
 return (L == NULL);
}
int vaziamanut (manutencao L){ /* Funcao que verifica se a lista manutencao esta vazia */
 return (L == NULL);
}
int total_contas = 0, arq_tamanho = 0, op = 0, i;
 struct usuarios_cadastrados {
 char login[10];
 char senha[10];
 };
struct usuarios_cadastrados usuario_cadastrado, *lista_de_contas;
FILE* logs;
/* Menu do aplicativo */
void menu(){ 
volta:
while (op != 3){
 printf("\n 1 - Cadastrar nova conta\n");
 printf(" 2 - Fazer login\n");
 printf(" 3 - Sair\n");
 
 printf("\nOpcao: ");
 scanf("%d%*c", &op);
 switch(op){
 case 1:
 logs = fopen ("contas.db","ab");
 if(logs == NULL)
 {
 printf("\nErro ao tentar abrir o arquivo.\n\n");
 goto volta;
 }
 else
 {
 memset(&usuario_cadastrado,0,sizeof(struct usuarios_cadastrados));
 printf("Cadastrar usuario: ");
 scanf("%s", usuario_cadastrado.login);
 printf("Cadastrar senha: ");
 scanf("%s", usuario_cadastrado.senha);
 fwrite(&usuario_cadastrado, sizeof usuario_cadastrado, 1, logs);
 fclose(logs);
 goto volta;
 }
 break;
 
 case 2:
 memset(&usuario_cadastrado, 0, sizeof(struct usuarios_cadastrados));
 printf("USUARIO: ");
 scanf("%s", usuario_cadastrado.login);
 printf("SENHA: ");
 scanf("%s", usuario_cadastrado.senha);
 
 logs = fopen ("contas.db","rb");
 if(logs == NULL)
 {
 printf("\nErro ao tentar abrir o arquivo.\n\n");
 goto volta;
 }
 else
 {
 fseek(logs,0,SEEK_END);
 arq_tamanho = ftell(logs);
 total_contas = arq_tamanho / sizeof (struct usuarios_cadastrados);
 rewind(logs);
 lista_de_contas = malloc(arq_tamanho);
 if(fread(lista_de_contas, sizeof usuario_cadastrado, total_contas, logs) != total_contas)
 {
 printf("Falha ao tentar ler contas\n");
 fclose(logs);
 free(lista_de_contas);
 }
 fclose(logs);
 for (i=0; i<total_contas; i++){
 if(memcmp(&usuario_cadastrado, &lista_de_contas[i], sizeof(struct usuarios_cadastrados)) == 0)
 {
 printf("\n LOGADO COM SUCESSO\n");
 goto start;
 break;
 }
 }
 if(i == total_contas)
 {
 printf("\n NEGADO\n");
 goto volta;
 }
 free(lista_de_contas);
 }
 break;
 
 case 3:
 exit(0);
 
 default:
 printf("\n Opcao invalida!\n");
 } 
}
	system("CLS");
 start: 
 system("cls"); 
 printf("|-------------------------------------------------------------------------|\n");
 printf("| MENU PRINCIPAL |\n");
 printf("|-------------------------------------------------------------------------|\n");
 printf("| Entre com a opcao desejada: |\n");
 printf("| |\n"); 
 printf("| (1) : Cadastrar veiculo |\n");
 printf("| (2) : Cadastrar manutencao |\n");
 printf("| (3) : Listar veiculo cadastrado |\n");
 printf("| (4) : Localizar dados do veiculo ( pela placa) |\n");
 printf("| (5) : Listar as manutencoes de um veiculo |\n");
 printf("| (6) : Calcular valor dos gasto com manutencoes de um veiculo |\n");
 printf("| (7) : Remover dado de uma manutencao de um veiculo |\n");
 printf("| (8) : Remover cadastro de um veiculo. |\n");
 printf("| (9) : Alterar cadastro de um veiculo |\n");
 printf("| (10): Alterar cadastro de uma manutencao de um veiculo |\n");
 printf("| (11): Exibir um relatorio |\n");
 printf("| (12): Sair |\n");
 printf("|-------------------------------------------------------------------------|\n");
 printf(" opcao: ");
}
int cadveiculo(veiculo *L){ /* Funcao que insere dados de veiculos*/
 veiculo novo;
 novo = (veiculo) malloc(sizeof(tveic));
 if (*L == NULL) { /* 1a. insersao */
 if (novo == NULL) return 0; /* erro: memoria insuficiente */
 inputs("Digite a placa: ", novo->placa, 7);
 inputs("Digite a marca: ", novo->marca, 14);
 inputs("Digite a modelo: ",novo->modelo, 29);
 printf("Digite o ano: ");
 scanf("%d",&novo->ano);
 novo->prox = NULL;
 *L = novo;
 return 1;
 }
 else { /* insersao na primeira posisao em uma lista nao vazia */
 if (novo == NULL) return 0; /* erro: memoria insuficiente */
 inputs("Digite a placa: ", novo->placa, 7);
 inputs("Digite a marca: ", novo->marca, 15);
 inputs("Digite a modelo: ",novo->modelo, 30);
 printf("Digite o ano: ");
 scanf("%d",&novo->ano);
 novo->prox = *L;
 *L = novo;
 return 1;
 } 
}
int cadmanutencao(manutencao *Lm, veiculo *Lv){ /*Funcao que insere dados de manutensoes*/
 manutencao novo;
 veiculo lista;
 int c1=1;
 int e;
 novo = (manutencao) malloc(sizeof(tmanut));
 if(vaziaveiculo(*Lv)){
 printf("\nA lista de veiculos? vazia!\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&c);
 return 0;
 }
 for(lista=*Lv;lista!=NULL;lista=lista->prox){
 printf("%d - %s\n",c1,lista->placa);
 c1++;
 }
 printf("\n\nInforme um numero para cadastrar a manutencao: ");
 scanf("%d",&e);
 lista=*Lv;
 for(c1=1;c1<e;c1++) lista=lista->prox;strcpy(novo->placa,lista->placa);
 printf("%s\n",novo->placa);
 if (*Lm == NULL) { /* 1a. insersao */
 if (novo == NULL) return 0; /* erro: memoria insuficiente */
 printf("Digite a quilometragem: ");
 scanf("%d",&novo->km);
 printf("Digite o dia: "); 
 scanf("%d",&novo->data.dia);
 printf("Digite o mes: ");
 scanf("%d",&novo->data.mes);
 printf("Digite o ano: ");
 scanf("%d",&novo->data.ano);
 printf("Digite o valor: ");
 scanf("%lf",&novo->valor);
 novo->prox = NULL;
 *Lm = novo;
 return 1;
 }
 else { /* insersao na primeira posicao em uma lista nao vazia */
 if (novo == NULL) return 0; /* erro: memoria insuficiente */
 printf("Digite a quilometragem: ");
 scanf("%d",&novo->km);
 printf("Digite o dia: ");
 scanf("%d",&novo->data.dia);
 printf("Digite o mes: ");
 scanf("%d",&novo->data.mes);
 printf("Digite o ano: ");
 scanf("%d",&novo->data.ano);
 printf("Digite o valor: ");
 scanf("%lf",&novo->valor);
 novo->prox = *Lm;
 *Lm = novo;
 return 1;
 } 
}
void imprimirveiculos(veiculo L){
 int n;
 veiculo temp=L;
 char ch;
 if(vaziaveiculo(temp)){
 printf("\nA lista esta? vazia!\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&ch);
 }
 else {
 system("cls"); 
 printf("\n\n\n");
 printf("|-------------------------------------------------------|\n");
 printf("| Listar Veiculo Cadastrado |\n");
 printf("|-------------------------------------------------------|\n");
 printf("| Placa | Marca | Modelo | Ano |\n");
 printf("|-------------------------------------------------------|\n");
 while(temp!=NULL){
 printf("| %7s | %6s |%10s | %3d |\n",temp->placa, temp->marca, temp->modelo, temp->ano);
 temp=temp->prox;
 }
 printf("|-------------------------------------------------------|\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&ch);
 }
}
int removerveiculo (veiculo *Lv, manutencao *Lm){
 veiculo atualv, anteriorv;
 manutencao atualm, anteriorm;
 char excluir[8];
 
 atualv=anteriorv->prox;
 if(vaziaveiculo(*Lv)) return 0; //Lista esta? vazia
 inputs("Informe a placa do veiculo a ser excluido: ", excluir, 7);
 if(*Lm!=NULL){
 anteriorm=*Lm;
 atualm=anteriorm->prox;
 while(atualm!=NULL) {
 if(!strcmp(excluir,anteriorm->placa)) {
 *Lm=anteriorm->prox;
 free(anteriorm);
 }
 else {
 if(!strcmp(excluir,atualm->placa)){
 anteriorm->prox=atualm->prox;
 }
 else {
 anteriorm=anteriorm->prox;
 atualm=atualm->prox;
 }
 }
 }
 }
 while(atualv!=NULL) {
 if(!strcmp(excluir,anteriorv->placa)) {
 *Lv=anteriorv->prox;
 free(anteriorv);
 return (1);
 }
 else {
 if(!strcmp(excluir,atualv->placa)){
 anteriorv->prox=atualv->prox;
 return (1);
 }
 else {
 anteriorv=anteriorv->prox;
 atualv=atualv->prox;
 }
 }
 }
 return (0);
}
int localizavei(veiculo *L){ //Localizar veiculos cadastrados 
 veiculo temp;
 char local[8];
 system("cls");
 if(vaziaveiculo(*L)) {
 printf("Lista Vazia!\n");
 return (1);
 }
 inputs("Informe a placa do veiculo a ser localizado: ", local, 8);
 system("cls");
 for(temp=*L;temp!=NULL;temp=temp->prox){
 if(!strcmp(local,temp->placa)) {
 printf("\n\n\n");
 printf("|-----------------------------------------------|\n");
 printf("| Listar Veiculo Cadastrado(Placa) |\n");
 printf("|-----------------------------------------------|\n");
 printf("| Placa | Marca | Modelo | Ano |\n");
 printf("|-----------------------------------------------|\n");
 printf("|%7s | %6s |%10s | %3d |\n",temp->placa, temp->marca, temp->modelo, temp->ano);
 printf("|-----------------------------------------------|\n");
 printf("\n\n\nTecle <Enter> para retornar ao menu");
 scanf("%c",&c);
 return (0);
 }
 }
 return (1);
}
/* 
int calculagasto(manutencao L, char pplaca[8]){
 int total;
 total=0;
 manutencao p;
 p = L;
 if (L == NULL){
 printf("\nA lista esta vazia!\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&c);
 return total;
 }
 while (p != NULL) {
 if (!strcmp(p->placa, pplaca)) {
 total+=p->valor;
 } 
 p = p->prox;
 }
 return total;
}
*/
void relatorioveiculos (veiculo Lv, manutencao Lm){
 veiculo listav;
 manutencao listam;
 int count;
 system("cls"); 
 for(listav=Lv;listav!=NULL;listav=listav->prox){
 printf("\n\n\n");
 printf("|-----------------------------------------------------|\n");
 printf("| Relatorio |\n"); 
 printf("|-----------------------------------------------------|\n");
 printf("| Placa | Marca | Modelo | Ano3 |\n");
 printf("|-----------------------------------------------------|\n");
 printf("| %s | %s | %s | %d |\n",listav->placa, listav->marca, listav->modelo, listav->ano);
 count=1;
 for(listam=Lm;listam!=NULL;listam=listam->prox){
 printf("|-----------------------------------------------------|\n");
 printf("| Manut. | Kilometragem | Data | Valor |\n");
 printf("|-----------------------------------------------------|\n"); 
 if(!strcmp(listam->placa,listav->placa)){
 printf("| %d | %d | %d/%d/%d | %5.2f |\n",count, listam->km, listam->data.dia, listam->data.mes, listam->data.ano, listam->valor);
 count++;
 }
 }
 }
 printf("|-----------------------------------------------------|\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&c);
}
void relatoriomanutencao (veiculo Lv, manutencao Lm){
 veiculo listav;
 manutencao listam;
 int count;
 system("cls"); 
 count=1; 
 for(listav=Lv;listav!=NULL;listav=listav->prox){
 printf("\n\n\n");
 printf("|------------------------------------------------------|\n");
 printf("| Lista de Manutencoes |\n"); 
 printf("|------------------------------------------------------|\n");
 printf("| Manut. | Kilometragem | Data | Valor |\n");
 printf("|------------------------------------------------------|\n"); 
 for(listam=Lm;listam!=NULL;listam=listam->prox){
 if(!strcmp(listam->placa,listav->placa)){
 printf("| %d | %d | %d/%d/%d | %5.2f |\n",count, listam->km, listam->data.dia, listam->data.mes, listam->data.ano, listam->valor);
 count++;
 }
 }
 } 
 printf("|------------------------------------------------------|\n");
 printf("\n\n\nTecle Enter para retornar ao menu");
 scanf("%c",&c);
}
/*int removemnt(tlistamnt *L, char pplaca[8]){
 tlistamnt a, p;
 int n;
 if (*L == NULL) return 0; /* erro: lista vazia 
 p = *L;
 n = 1;
 while ((!strcmp(p->placa,pplaca)) && (p!=NULL)) {
 a = p;
 p = p->prox;
 n++;
 }
 if (p == NULL) return 0; /* erro: placa não encontrada 
 if (n == 1)
 *L = p->prox;
 else 
 a->prox = p->prox;
 free(p);
 return(1);
}
*/
int main() {
 veiculo cadveic; /* variavel cadastro de veiculos */
 manutencao cadman; /* declaracao da variavel cadastro de manutencoes */
 int opcao; /* opcao digitada pelo usuário */
 int fim = 0; /* encerra o laço do-while e por consequência o programa */
 char placavei[8];
 criarv(&cadveic);
 criarm(&cadman);
 
 while(!fim){
 menu();
 opcao = 0; 
 scanf("%d", &opcao); 
 flush_in(); 
 switch(opcao){
 case 1: if(cadveiculo(&cadveic)){
 printf("Veiculo cadastrado com sucesso!\n");
 scanf("%c",&c); 
 }
 break;
 case 2: if(cadmanutencao(&cadman,&cadveic)){
 printf("Manutencao cadastrada com sucesso!\n");
 scanf("%c",&c); 
 }
 break;
 case 3: imprimirveiculos(cadveic);
 break;
 case 4: if(localizavei(&cadveic)){
 printf("Veiculo nao localizado!\n");
 scanf("%c",&c); 
 }
 break;
 
 case 5: relatoriomanutencao(cadveic, cadman);
 // case 6: calculagasto(cadman, pplaca[8]);
 // break;
 case 7:// printf("Informe um numero da placa para remover a manutencao: ");
 // gets(placavei);
 // removemnt(&cadman, placavei);
 //printf("Manutencao removida com sucesso!\n");
 break;
 case 8: if(removerveiculo(&cadveic, &cadman))//{
 printf("Veiculo removido com sucesso!\n");
 break;
 case 9: printf("\n Em desenvolvimento\n");
 break;
 case 10: printf("\n Em desenvolvimento\n");
 break;
 case 11: relatorioveiculos(cadveic, cadman);
 break;
 case 12: fim = 1;
 break; 
 scanf("%c",&c); 
 default: printf("\n\nERRO: A opcao Invalida. Tente novamente...\n");
 }
 }
 return(0);
}
TECNOLOGIA UTILIZADA
A linguagem C já foi utilizada em praticamente todos os tipos de hardware e software. Visto que ela foi criada na década de 70 com o intuito de trabalhar com o acesso e controle dos espaços da memória das máquinas, acabou se tornando uma ferramenta muito importante para o desenvolvimento de grandes produtos.
A linguagem C pode ser facilmente encontrada em grandes jogos do mercado atual, editores de imagem e vídeo, robôs, sistemas de automação, e muitos sistemas operacionais são programados totalmente ou parcialmente em C, como por exemplo o Windows, o Linux e o Mac OS (Optamos pela escolha do Linux, por sua relativa segurança, fácil manutenção, personalizável e gratuito).
Ela foi pensada para ser uma linguagem que lida diretamente com o hardware, o que significa que pode ser encontrada com facilidade em processadores, microcontroladores e drivers.
A linguagem em C tem recursos que fazem com que acesso aos espaços de memória e dados dessas máquinas seja facilitado, mas isso não anula o fato de que ela também pode ser facilmente implementada em softwares ou aplicações diferentes.
Principais recursos e características da linguagem C
É importante destacar que a linguagem C é uma linguagem de alto nível. 
Uma linguagem é considerada de alto nível quando sua sintaxe se assemelha bastante com a linguagem falada por nós, ou seja, que você pode de certa forma “ditar” seu código, um bom exemplo é a linguagem Python, que foi a utilizada neste sistema.
Um dos principais diferenciais dessa linguagem para as outras existentes é sua sintaxe, que além de ser mais clara e moderna, permite que os programadores escrevam códigos legíveis, organizados e tenham até maior produtividade de trabalho.
As principais características desta tecnologia utilizada são:
· Portabilidade: ela pode ser compilada em diversas arquiteturas, sistemas operacionais e compiladores diferentes. Tanto para hardware como para software com códigos limpos e grande velocidade;
· Simplicidade: ela é uma linguagem com sintaxe muito simples para se aprender, e quando bem programada, dificilmente trará problemas para o usuário;
· Compilação: seus programas são rapidamente compilados gerando um arquivo executável;
· Recursos de baixo nível: como já foi citado anteriormente, a linguagem possui recursos de baixo nível muito úteis, como o acesso a memória da máquina.
LEVANTAMENTO E ANÁLISE DE REQUISITOS 
O levantamento de requisitos é uma etapa significativa para a concepção dentro da engenharia de requisitos, onde o analista deve utilizar todas as informações disponíveis que irão gerar os requisitos e com isso identificar as funções que o sistema irá disponibilizar (WAZLAWICK, 2011).
Com a atividade de análise dos requisitos foram realizadas pesquisas e posteriormente a classificação e agrupamento das ideias, com o objetivo de entender como funciona o negócio e já estabelecer algumas funcionalidades para o sistema. 
Nesta análise, a equipe técnica trabalha em conjunto os usuários finais para que estes descubram informações no que diz respeito ao domínio da aplicação, quais serviços o sistema deve fornecer, o desempenho exigido do sistema, bem como as restrições de software e hardware (SOMMERVILLE, 2003).
Figura 1 - Processo de levantamento e análise de requisitos
Requisitos do usuário
Para o bom desenvolvimento de um software, uma boa modelagem deve ser efetuada. Com o UML encontramos uma praticidade e eficiência, tornando-o um software mais acessível e de fácil entendimento. Com os diversos diagramas disponíveis, o objetivo é demonstrar de forma clara e precisa as mais diversas funções presentes no projeto.
Os requisitos do usuário são descritos de forma entendível para que o stakeholder tenha um bom entendimento do que se quer do sistema a ser construído. A modelagem do negócio é um modelo de fácil interpretação, como podemos observar na figura a seguir.
Figura 2 – Diagrama de casos de uso
Requisitos funcionais
Aqui será descrito o que o sistema deve e o que não deve fazer, as funções detalhadas do sistema, suas entradas e saídas, exceções etc.
RF01 Manter cadastro de veículos
RF02 Manter cadastro de funcionários
RF03 Manter cadastro de clientes
RF04 Manter cadastro de categorias de veículos
RF05 Registrar reserva de veículos
RF06 Registrar devolução de veículos
RF07 Registrar a retirada de veículos
RF08 Manter o cadastro das formas de pagamento
RF09 Registrar venda de veículos
RF10 Registrar aluguel de veículos
RF11 Gerar relatório de carros alugados no momento
RF12 Gerar relatório de reservas
RF13 Gerar comprovante de retirada de veículo
RF14 Gerar comprovante de devolução de veículo
RF15 Gerar relatório de carros alugados pelo cliente
RF16 Gerar relatório de faturamento por período por aluguéis, vendas e financiamentos
RF17 Gerar relatório diariamente de clientes em débito
RF18 Gerar faturas diariamente para pagamento de aluguéis
RF19 Permitir a simulação de financiamento
RF20 Gerar o contrato de locação
RF21 Permitir a inserção de interesses dos clientes
RF22 Permitir o envio de e-mail para clientes
RF23 Gerar relatório de interesses de clientes em veículos
RF24 Manter cadastro de serviços adicionais no aluguel
RF25 Permitir a autenticação por meio de login
Requisitos não funcionais
Nesta etapa, será definido as propriedades e restrições do sistema como segurança, desempenho, padrões do cliente, legislação, espaço etc.
RNF01 O sistema deve ser desenvolvido utilizando arquitetura web.
RNF02 O sistema deve ser desenvolvido utilizando a linguagem JAVA.
RNF03 O sistema deve suportar até 100 clientes simultaneamente.
RNF04 O tempo de resposta para qualquer função do sistema não deve superar 10 segundos.
RNF05 O SGDB utilizado deve ser MySql.
Requisitos de sistema
A seguir, as descrições mais detalhadas dos requisitos do usuário com o foco no sistema, com uma especificação completa e consistente dos componentes do sistema utilizados.
	Requisito do sistema (RS)
	Especificação
	RS01
	Dell Optiplex 390, modelo PC com médio desempenho
	RS02
	Sistema operacional Linux. Ver RS01
	RS03
	Mozilla Firefox. A aplicação irá funcionar em uma rede intranet
Quadro 1 – Especificação de requisitos do sistema
PROCESSOS DE GESTÃO DE TI
Em um mundo com novas ferramentas e recursos que auxiliam no desempenho das atividades, o gerenciamento de tecnologia da informação se tornou um diferencial de mercado. Garantir o uso adequado destas ferramentas proporcionamais eficiência e inteligência em sua operação.
Definição do Serviço de TI
Pensando em prover e implementar soluções tecnológicas e de segurança inovadoras, visando continuidade e crescimento da empresa, a área de Gestão de TI da GoCar, é subdivida em 3 áreas que se integram:
Quadro 2 – Composição da área de Gestão de TI
Principais responsabilidades da área
· Gestão dos níveis de serviço;
· Gestão da capacidade da infraestrutura instalada;
· Gestão da segurança e disponibilidade das informações;
· Gestão do atendimento de serviços;
· Manter servidores;
· Manter a conectividade;
· Plantão de suporte;
· Backup diário;
· Manter acessos a banco de dados;
· Atendimento de chamados;
· Administração de usuários;
· Controle do inventário de hardware e software;
· Auditorias de segurança da informação.
Catálogo de Serviços de TI e SLAs
Para otimizar, aumentar a eficácia e potencializar a qualidade organizamos quais são os serviços de TI do negócio em um catálogo de serviços, que é uma lista dos serviços oferecidos e suas principais informações, como a descrição das atividades, SLA de atendimento, prioridade, categorização do serviço etc.
A ideia é obter uma visão geral dos serviços de tecnologia da informação oferecidos.
Dessa maneira, é possível mensurar a qualidade das entregas e resguardar tanto os interesses dos clientes quanto dos profissionais de TI.
Boas Práticas na Gestão de TI
Como todo setor de administração de empresas, o GSTI da GoCar conta com metodologias científicas que guiam a atuação dos profissionais envolvidos. As boas práticas na gestão de TI são padronizações que visam garantir a segurança, acessibilidade e integridade dos dados e processos no setor.
Cada área possui, pelo menos, um profissional certificado em ITIL, que é uma das principais metodologias de mercado.
O principal objetivo do ITIL é a melhoria da qualidade dos serviços de tecnologia da informação de uma organização, por meio de uma gestão com foco no cliente. 
Assim, é possível proporcionar maior otimização dos serviços prestados, visando a redução de custos e eficácia dos setores envolvidos.
Quadro 3 – Catálogo de Serviços e SLA
CONCLUSÃO
O presente estudo teve o objetivo de apresentar uma proposta de criação de um software e de um processo de Gestão de Serviços de TI com o propósito de implementar estratégias consideráveis no desempenho organizacional da rede de locadora de carros GoCar.
Através da execução dos objetivos específicos, foi possível desenvolver um sistema de cadastro utilizando a linguagem C, especificar os requisitos do usuário, os requisitos funcionais, os requisitos não funcionais e os requisitos do sistema. 
Analisando o ambiente em que está inserido, foi possível concluir que investir em uma gestão de TI adequada é uma das mais importantes decisões para garantir o sucesso de uma empresa. Por tanto foi apresentado os principais processos que envolvem a gestão de serviços de TI neste negócio.
Este trabalho representa um grande crescimento e consolidação dos conhecimentos adquiridos nas disciplinas de Gerenciamento de Serviços de TI, Fundamentos de Engenharia de Software e Algoritmo.
REFERÊNCIAS
SOMMERVILLE, Ian. Engenharia de Software : 8 ed. Rio de Janeiro: Prentice-Hall, 2008.
PRESSMAN, Roger S. Engenharia de Software : 6 ed. São Paulo: McGraw Hill/Nacional, 2006.
PAULA FILHO, Wilson de Pádua. Engenharia de Software: fundamentos, métodos e padrões. São Paulo: LTC Editora, 2000.
SILVA, T. A. S. Modelos UML estáticos vs. dinâmicos. TASSinfo, 19 abr. 2016. Disponível em: https://bit.ly/3l8KzVi. Acesso em: 30/05/2021.
Santos, Marcelo Henrique dos. Algoritmos / Marcelo Henrique dos Santos. – São Paulo: Editora Sol, 2021.
Alves, Davis. Gerenciamento de Serviços de TI / Davis Alves. – São Paulo: Editora Sol, 2021.
Moreno, Edson Quedas. Fundamentos de Engenharia de Software / Edson Quedas Moreno. – São Paulo: Editora Sol, 2021.