package visao;

import java.util.Date;
import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

import Dominio.Agenda_Servico;
import Dominio.Agendamento;
import Dominio.Cliente;
import Dominio.Funcionario;
import Dominio.Serviço;
import persistencia.Agenda_ServicoDAO;
import persistencia.AgendamentoDAO;
import persistencia.ClienteDAO;
import persistencia.FuncionarioDAO;
import persistencia.servicoDAO;

public class Principal {

public static void main(String[] args) {

// TODO Auto-generated method stub

SimpleDateFormat formatadorData = new SimpleDateFormat("dd/MM/yyyy"); // FORMATAR

A DATA
SimpleDateFormat formatadorHora = new SimpleDateFormat("HH:mm"); //
FORMATAR A HORA

Scanner teclado = new Scanner(System.in);// LER OS INPUTS DO TECLADO

// CLIENTE
ClienteDAO cliDAO = new ClienteDAO();
Cliente cliSelect = new Cliente();
ArrayList<Cliente> RelatorioDeClientes = new ArrayList<Cliente>();

// FUNCIONARIO
FuncionarioDAO funcionarioDAO = new FuncionarioDAO();
Funcionario funcionarioAux= new Funcionario();
ArrayList<Funcionario> RelatorioDeFuncionarios = new ArrayList<>();

// SERVICO
Serviço servicoAux = new Serviço();
servicoDAO servicoDAO = new servicoDAO();
ArrayList<Serviço> RelatorioDeServicos = new ArrayList<Serviço>();

// AGENDAMENTO
AgendamentoDAO agendamentoDAO = new AgendamentoDAO();
ArrayList<Agendamento> RelatorioDeAgendamentos = new ArrayList<>();

// AGENDA_SERVICO
Agenda_Servico agendaServicoAux = new Agenda_Servico();
Agenda_ServicoDAO agendaServicoDAO = new Agenda_ServicoDAO();
ArrayList <Agenda_Servico> RelatorioDeAgenda_Servico = new ArrayList<>();

// VARIAVEIS DE APOIO
int op, senha, i, chance;
boolean acertou;
String CPFaux;

// UTILIZAMOS PARA GERAR UM NUMERO RANDOMICO QUE SERVIRÁ PARA O CODIGO DO

AGENDAMENTO
Long codigoRandom;
Random codigoRandomAux = new Random();
Random codigo = new Random();
 do {// MENU INICIAL

System.out.println("\t Menu Principal");

System.out.println("------------------------------");
System.out.println("1-Informações de Funcionario");
System.out.println("2-Informações de cliente");
System.out.println("3-Agendamentos");
System.out.println("4-Serviços");
System.out.println("5-Sair do Programa");
System.out.print("--> ");
op = teclado.nextInt();
System.out.println("------------------------------");

switch (op) {
case 1:
i = 0;
do {
System.out.println("Digite a senha");
senha = teclado.nextInt();
if (senha == 1234) {
System.out.println("Acesso aceito\n");
do {
System.out.println("\nMenu de Gestão");

System.out.println("--------------------------------");
System.out.println("1-Adicionar Funcionario");
System.out.println("2-Demitir Funcionario");
System.out.println("3-Alterar Funcionario");
System.out.println("4-Relatorio de
Funcionario");
System.out.println("5-Ver Funcionario por
carteira");
System.out.println("6-Gasto Total com
Funcionarios");
System.out.println("7-Voltar ao Menu
Principal");

System.out.print("--> ");
op = teclado.nextInt();

System.out.println("------------------------------");

switch (op) {

case 1:
chance = 0;
String identificadorAUX;
teclado.nextLine();// comer o enter
do {

Funcionario f1 = new
Funcionario();

System.out.println("Carteira de
Trabalho do Funcionario");

f1.setCarteiraTrab(teclado.nextLine());
identificadorAUX =
f1.getCarteiraTrab();

if
(funcionarioDAO.buscarFun(identificadorAUX) == null) {// teste de se ja existe

System.out.println("Salario do Funcionario");

f1.setSalario(teclado.nextFloat());
teclado.nextLine();
 System.out.println("E-
mail do Funcionario");

f1.setEmail(teclado.nextLine());

System.out.println("Numero do Funcionario");

f1.setNumero(teclado.nextInt());

System.out.println(f1.getNumero());
teclado.nextLine();

funcionarioDAO.AdicionarFuncionario(f1);

System.out.println("FUNCIONARIO CADASTRADO!!");

chance = 3;
} else {
chance++;
i = 3 - chance;

System.out.println("FUNCIONARIO JA CADASTRADO!!");
System.out.println("\
nVOCE TEM : " + i + " tentativas!!");

}
} while (chance != 3);

break;
case 2:
System.out.println("Nº CARTEIRA TRAB
PARA DEMIITIR FUNCIONARIO");
teclado.nextLine();

funcionarioDAO.excluirFuncionario(teclado.nextLine());
System.out.println("FUNCIONARIO
DEMITIDO!!");
break;

case 3:
teclado.nextLine();
i = 0;
String cartAux ,cartAux2;
Funcionario f2 = new Funcionario();
System.out.println("DIGITE A CARTEIRA DE
TRABALHO PARA ALTERAR");
cartAux = teclado.nextLine();
System.out.println(cartAux);
f2.setCarteiraTrab(cartAux);
do {
if
(funcionarioDAO.buscarFun(cartAux) != null) {

System.out.println("Digite a carteira de Trabalho");

f2.setCarteiraTrab(teclado.nextLine());
cartAux2 =
f2.getCarteiraTrab();//testar a nova key

if(funcionarioDAO.buscarFun(cartAux2) != null && !cartAux2.equals(cartAux) ) {

System.out.println("CARTEIRA DE TRABALHO JA CADASTRADA!!!");

}else {

System.out.println("Digite o Salario");
 f2.setSalario(teclado.nextFloat());

teclado.nextLine();

System.out.println("Digite o Email");

f2.setEmail(teclado.nextLine());

System.out.println("Digite Numero do Funcionario");

f2.setNumero(teclado.nextInt());
i = 3;

funcionarioDAO.alterarFuncionario(f2, cartAux);

System.out.println(" FUNCIONARIO ALTERADO!!");

}
}
} while (i != 3);

break;
case 4:
RelatorioDeFuncionarios =
funcionarioDAO.RelatorioFuncionarios();

System.out.println("=========================================================");
for (i = 0; i <
RelatorioDeFuncionarios.size(); i++) {
System.out.println("Nº CARTEIRA
DE TRABALHO -> "
+
RelatorioDeFuncionarios.get(i).getCarteiraTrab()
+ "\n SALARIO DO
FUNCIONARIO -> "
+
RelatorioDeFuncionarios.get(i).getSalario() + "\n EMAIL DO FUNCIONARIO ->"
+
RelatorioDeFuncionarios.get(i).getEmail() + "\n NUMERO DO FUNCIONARIO -> "
+
RelatorioDeFuncionarios.get(i).getNumero());

System.out.println("=========================================================");
}
break;
case 5:
Funcionario f1 = new Funcionario();
System.out.println("N° CARTEIRA TRAB
PARA ENCONTRAR FUNCIONARIO");
teclado.nextLine();
f1 =
funcionarioDAO.buscarFun(teclado.nextLine());

System.out.println("=========================================================");
System.out.println("\nEMAIL: " +
f1.getEmail());
System.out.println("NUMERO: " +
f1.getNumero());
System.out.println("CARTEIRA TRAB: " +
f1.getCarteiraTrab());
System.out.println("SALARIO: " +
f1.getSalario());

System.out.println("=========================================================");
break;

case 6:
float soma = 0;
 RelatorioDeFuncionarios =
funcionarioDAO.RelatorioFuncionarios();

System.out.println("=========================================================");
for (i = 0; i <
RelatorioDeFuncionarios.size(); i++) {
soma =
RelatorioDeFuncionarios.get(i).getSalario() + soma;

}
System.out.println("SALARIO TOTAL DOS
FUNCIONARIOS -> " + soma);

break;
case 7:
i = 3;
break;
default:
System.out.println("opção invalida!!");

} while (op != 7);

} else {
System.out.println("Acesso negado");
i++;
}
} while (i != 3);
break;
case 2:

i = 0;
do {
System.out.println("Digite a senha");
senha = teclado.nextInt();
if (senha == 1234) {
System.out.println("Acesso aceito");
do {
System.out.println("Menu Secundario 2");

System.out.println("--------------------------------");
System.out.println("1-Adicionar Cliente");
System.out.println("2-Remover Cliente");
System.out.println("3-Alterar Cliente");
System.out.println("4-Ver todos os Clientes");
System.out.println("5-Ver Cliente por CPF");
System.out.println("6-Voltar ao Menu
Principal");
op = teclado.nextInt();
switch (op) {
case 1:
chance = 0;
String identificadorAUX;
teclado.nextLine();// comer o enter

do {
Cliente c1 = new Cliente();

System.out.println("\nDigite seu
CPF");
identificadorAUX =
teclado.nextLine();

c1.setCpf(identificadorAUX);

if
(cliDAO.buscar(identificadorAUX) == null) {// teste para ver se ja existe
 System.out.println("Digite seu Email");

c1.setEmail(teclado.nextLine());

System.out.println("Digite seu Numero");

c1.setNumero(teclado.nextLine());

cliDAO.inserirCliente(c1);
chance = 3;

} else {
chance++;
i = 3 - chance;

System.out.println("CLIENTE JA CADASTRADO!!");
System.out.println("\
nVOCE TEM : " + i + " tentativas!!");

}
} while (chance != 3);

break;
case 2:
int op2;
System.out.println("CPF DO CLINETE QUE
DESEJA REMOVER");
teclado.nextLine();
CPFaux = teclado.nextLine();// antes de
exluir deve-se ver se ele não tem nem um
// agendamento, ou seja buscamos o
cliente verificamos se n
// há agendamento e depois exluimos.
System.out.println(
"VOCÊ TEM CERTEZA QUE
DESEJA EXCLUIR O CLIENTE?\nTODOS OS SEUS AGENDAMENTOS EM ABERTOS SERAM EXLUIDOS
CONSEQUENTEMENTE!!\n 1-SIM, EU CONFIRMO|2-CANCELAR");
op2 = teclado.nextInt();

if (op2 == 1) {
cliDAO.excluirCliente(CPFaux);
} else {

System.out.println("CANCELANDO...");
}

break;

case 3:
String CPFaux2,CPFaux1;
Cliente c1 = new Cliente();
i = 0;

do {
teclado.nextLine();
System.out.println("CPF DO
CLIENTE QUE DESEJA ALTERAR");
CPFaux1 = teclado.nextLine();
c1.setCpf(CPFaux1);

if (cliDAO.buscar(CPFaux1) !=
null) {

System.out.println("Digite o CPF1");
 c1.setCpf(teclado.nextLine());
CPFaux2 =
c1.getCpf();//testar a nova key

if(cliDAO.buscar(CPFaux1)
!= null && !CPFaux2.equals(CPFaux1)) {

System.out.println("CPF JA CADASTRADO");

}else {

System.out.println("Digite o numero");

c1.setNumero(teclado.nextLine());

System.out.println("Digite o email");

c1.setEmail(teclado.nextLine());

cliDAO.alterarCliente(c1, CPFaux1);
i = 3;
}
} else {
System.out.println("CPF
nao encontrado");
i++;
}
} while (i != 3);

break;
case 4:

System.out.println("Todos os clientes:
");

RelatorioDeClientes =
cliDAO.clientesTotal();

System.out.println("=========================================================");
for (i = 0; i <
RelatorioDeClientes.size(); i++) {
System.out.println("Email do
cliente " + i + " -> "
+
RelatorioDeClientes.get(i).getEmail() + "\nNumero do cliente:" + i + "-> "
+
RelatorioDeClientes.get(i).getNumero() + "\ncpf do cliente" + i + "-> "
+
RelatorioDeClientes.get(i).getCpf());

System.out.println("=========================================================");
}

break;
case 5:
System.out.println("CPF DO CLIENTE QUE
DESEJA BUSCAR");
teclado.nextLine();
cliSelect =
cliDAO.buscar(teclado.nextLine());

System.out.println("\nEMAIL: " +
cliSelect.getEmail());
System.out.println("NUMERO: " +
cliSelect.getNumero());
 System.out.println("CPF: " +
cliSelect.getCpf());

break;
case 6:
i = 3;
break;
default:
System.out.println("Opção invalida");
}
} while (op != 6);
} else {
System.out.println("Acesso negado");
i++;
}
} while (i != 3);
break;
case 3:
int opAux;
do {
System.out.println("Menu de Agendamento");
System.out.println("---------------------");
System.out.println("1-Marcar Agendamento");
System.out.println("2-Excluir Agendamento");
System.out.println("3-Alterar Agendamento");
System.out.println("4-Buscar Agendamento");
System.out.println("5-Relatorio Agendamentos");
System.out.println("6-voltar ao menu principal");
opAux = teclado.nextInt();

switch (opAux) {
case 1:

String cpfAux, dataNaoFormatada, horarioNaoFormatado;

chance = 0;
String identificadorAUX;
java.sql.Date dataSQL;
java.util.Date dataJava = new Date();
Date timeUtil = null;
Time timeSql;
int IDAUX;

//================================AGENDAR===========================================

Agendamento a1 = new Agendamento();

teclado.nextLine();// comer o enter

codigoRandom = codigoRandomAux.nextLong() * 100;

if (codigoRandom < 0) {
codigoRandom = codigoRandom * -1;
}

System.out.println("-------------------------------------------------------");
System.out.println("CODIGO AGENDAMENTO: " +
codigoRandom);
a1.setCodigo(codigoRandom);

System.out.println("-------------------------------------------------------");
System.out.println("DIGITE SEU CPF");
cpfAux = teclado.nextLine();

Cliente clienteAux = new Cliente();

clienteAux = cliDAO.buscar(cpfAux);

//================================VER SE O CLIENTE
EXISTE PARA AGENDAR===========================================
 if (clienteAux == null) {

System.out.println("CLIENTE NÃO CONSTA NO BANCO

DADOS!!");

Cliente c1 = new Cliente();

System.out.println("DIGITE SEU CPF");
cpfAux =(teclado.nextLine());
c1.setCpf(cpfAux);
System.out.println("Digite seu Email");
c1.setEmail(teclado.nextLine());
System.out.println("Digite seu Numero");
c1.setNumero(teclado.nextLine());
cliDAO.inserirCliente(c1);
}

// =========================TRATAR DATA E HORA DO

AGENDAMENTO=====================================================
System.out.println("Digite a Data - FORMATO:
dd/MM/yyyy");
dataNaoFormatada = teclado.nextLine();// PEGAMOS A
STRING
try {
dataJava =
formatadorData.parse(dataNaoFormatada);
} catch (ParseException e) {
System.out.println(e + "ERRO EM ALTERAR O
AGENDAMENTO NA VISAO");
}
dataSQL = new java.sql.Date(dataJava.getTime());//
PASSAMOS A STRING PARA UM DATE JAVA UTIL
a1.setData(dataSQL);// PREENCHEMOS DATA

System.out.println("Digite o HORARIO - FORMATO:

HH:mm");
horarioNaoFormatado = teclado.nextLine();
try {
timeUtil =
formatadorHora.parse(horarioNaoFormatado);
} catch (ParseException e) {
System.out.println(e + "ERRO EM ALTERAR O
AGENDAMENTO NA VISAO");
}
timeSql = new Time(timeUtil.getTime());
a1.setHora(timeSql);

//============================= SETAR SERVIÇO EM

AGENDAMENTO ======================================================

System.out.println("================================SERVIÇOS=================================");
RelatorioDeServicos = servicoDAO.servicoTotal();

System.out.println("=========================================================");
for (i = 0; i < RelatorioDeServicos.size(); i++) {
System.out.println("ID do SERVIÇO" + i + " ->
"+ RelatorioDeServicos.get(i).getId() +
"\nTIPO do SERVIÇO:" + i + "->
"+ RelatorioDeServicos.get(i).getTipo());

System.out.println("=========================================================");
}
int adicionar;
boolean primeiraVez = true;
do {
adicionar = 0;
 int servico1;
Serviço s2 = new Serviço();
System.out.println("Digite o SERVIÇO QUE
DESEJA");
//USO A DAO DE SERVICO PARA BUSCAR UM SRVIÇO
COM ID QUE FOI ESCOLHIDO A DAO RETORNA UM OBJETO QUE JOGO PARA O DOMINIO DE AGENDAMENTO LA EU
ADICIONO DENTRO DA LISTA DE SERVICOS
servico1 = teclado.nextInt();
servicoAux =
servicoDAO.buscarServico(servico1);

if(servicoDAO.buscarServico(servico1) != null){
a1.setServicos(servicoAux);//preenchendo
o array list do Agendamento
if(primeiraVez) {
agendamentoDAO.Agendar(a1,cpfAux);//
AGENDAMENTO TOTALEMNTE PREENCHIDO
}

agendaServicoAux.setFk_servico(servicoAux);// setou o FK_serviço NO OBJETO DA TERCEIRA

TABELA

agendaServicoAux.setFk_agendamento(a1);// setou o FK_agendamento NO OBJETO DA TERCEIRA

TABELA

agendaServicoDAO.inserirAgendaServico(agendaServicoAux);
}else {
System.out.println("Servico ja existe");
}
System.out.println("DESEJA ADICIONAR MAIS UM
SERVIÇO AO AGENDAMENTO? 1 - SIM | 2 - NÃO ");
adicionar= teclado.nextInt();
primeiraVez = false;
}while(adicionar != 2);

break;

case 2:
System.out.println("CODIGO DO AGENDAMENTO");
teclado.nextLine();// comer enter
agendamentoDAO.ExcluirAgendamento(teclado.nextLong());
System.out.println("EXCLUINDO...");

break;

case 3:
long CodigoAux;
a1 = new Agendamento();

i = 0;

do {
System.out.println("CODIGO DO AGENDAMENTO QUE
DESEJA ALTERAR");
teclado.nextLine();
CodigoAux = teclado.nextLong();
a1.setCodigo(CodigoAux);
java.util.Date dataJavaAlterar = new Date();

if (agendamentoDAO.BuscarAgendamento(CodigoAux)
!= null) {

System.out.println("Digite a Data -
FORMATO: dd/MM/yyyy");// TRATAMOS O A STRING PARA/ PODERMOS ALOCAR UMA DATE// SQL;
teclado.nextLine();
 dataNaoFormatada = teclado.nextLine();//
PEGAMOS A STRING

try {
dataJavaAlterar =
formatadorData.parse(dataNaoFormatada);// PASSAMOS A STRING PARA UM DATE JAVA UTIL
} catch (ParseException e) {
System.out.println(e + "ERRO EM
ALTERAR O AGENDAMENTO NA VISAO");

dataSQL = new
java.sql.Date(dataJavaAlterar.getTime());// PARA SQL
a1.setData(dataSQL);// PREENCHEMOS DATA

System.out.println("Digite o HORARIO -
FORMATO: HH:mm");
horarioNaoFormatado =
teclado.nextLine();

try {
timeUtil =
formatadorHora.parse(horarioNaoFormatado);
timeSql = new
Time(timeUtil.getTime());
a1.setHora(timeSql);

agendamentoDAO.AlterarAgendamento(a1, CodigoAux);
} catch (ParseException e) {

System.out.println(e + "ERRO EM
ALTERAR O AGENDAMENTO NA VISAO");
}

i = 3;
} else {
System.out.println("CODIGO NAO
ENCONTRDO");
i++;
}
} while (i != 3);

break;
case 4:
Agendamento agendamentoAux = new Agendamento();
System.out.println("AGENDADEMENTO QUE DESEJA BUSCAR");
teclado.nextLine();
agendamentoAux =
agendamentoDAO.BuscarAgendamento(teclado.nextLong());

System.out.println("\t\tCODIGO\n\t" +
agendamentoAux.getCodigo());
System.out.println("\nDATA: " +
agendamentoAux.getData());
System.out.println("HORA: " +
agendamentoAux.getHora());
System.out.println("CPF CLIENTE: " +
agendamentoAux.getCliente().getCpf());
System.out.println("EMAIL CLIENTE: " +
agendamentoAux.getCliente().getEmail());
System.out.println("NUMERO CLIENTEs: " +
agendamentoAux.getCliente().getNumero());

RelatorioDeServicos =
agendaServicoDAO.ServicosDeUmAgendamento(agendamentoAux.getCodigo() );//recebendo um
arraylist
 for(int j = 0; j <RelatorioDeServicos.size() ;j++) {

System.out.println("SERVIÇO " + j +": "+

RelatorioDeServicos.get(j).getTipo());// NOME DO SERVIÇO
}

break;
case 5:

RelatorioDeAgendamentos =
agendamentoDAO.RelatorioDeAgendamentos();

System.out.println("=========================================================");

for (i = 0; i < RelatorioDeAgendamentos.size(); i++) {

System.out.println("\t\tCODIGO\n\t" +
RelatorioDeAgendamentos.get(i).getCodigo());
System.out.println("\nDATA: " +
RelatorioDeAgendamentos.get(i).getData());
System.out.println("HORA: " +
RelatorioDeAgendamentos.get(i).getHora());
System.out.println("CPF CLIENTE: " +
RelatorioDeAgendamentos.get(i).getCliente().getCpf());
System.out.println("EMAIL CLIENTE:" +
RelatorioDeAgendamentos.get(i).getCliente().getEmail());
System.out.println("NUMERO CLIENTE: " +
RelatorioDeAgendamentos.get(i).getCliente().getNumero());

for(int j = 0; j
<RelatorioDeAgendamentos.get(i).getServicos().size() ;j++) {

System.out.println("SERVIÇO " + j +": "+

RelatorioDeAgendamentos.get(i).getServicos().get(j).getTipo());// NOME DO SERVIÇO
}

System.out.println("\
n=========================================================");
}
break;

} while (opAux != 6);

break;

case 4:
i=0;
do {

do {
System.out.println("Menu Secundario SERVICO");

System.out.println("--------------------------------");
System.out.println("1-Adicionar Serviço");
System.out.println("2-Remover Serviço");
System.out.println("3-Alterar Serviço");
System.out.println("4-Ver todos os Serviço");
System.out.println("5-Ver Servico por ID");
System.out.println("6-Voltar ao Menu Principal");
op = teclado.nextInt();
switch (op) {
case 1:
chance = 0;
 int identificadorAUX;
teclado.nextLine();// comer o enter

do {

Serviço s1 = new Serviço();

System.out.println("\nDigite o ID do
SERVIÇO");
identificadorAUX = teclado.nextInt();
teclado.nextLine();
s1.setId(identificadorAUX);

if
(servicoDAO.buscarServico(identificadorAUX) == null) {// teste para ver se ja existe

System.out.println("Digite o
Tipo do Serviço");
s1.setTipo(teclado.nextLine());

//=============================
SETAR FUNCIONARIO EM SERVIÇO =============================================

System.out.println("================================FUNCIONARIOS=================================
");
RelatorioDeFuncionarios =
funcionarioDAO.RelatorioFuncionarios();

System.out.println("=========================================================");
for (i = 0; i <
RelatorioDeFuncionarios.size(); i++) {

System.out.println("CARTEIRA DE TRABALHO DO FUNCIONARIO" + i + " -> "+

RelatorioDeFuncionarios.get(i).getCarteiraTrab() +
"\nNUMERO
DO FUNCIONARIO:" + i + "-> "+ RelatorioDeFuncionarios.get(i).getNumero());

System.out.println("=========================================================");
}
String funcionarioResponsavel;
System.out.println("DIGITE A
FUNCIONARIO RESPONSAVEL");
//USO A DAO DE FUNCIONARIO
PARA BUSCAR UM FUNCIONARIO COM ID QUE FOI ESCOLHIDO A DAO RETORNA UM OBJETO QUE PREENCHO O
FK_FUNCIOINARIO DE SERVIÇO;

funcionarioResponsavel =
teclado.nextLine();
funcionarioAux =
funcionarioDAO.buscarFun(funcionarioResponsavel);

if(funcionarioDAO.buscarFun(funcionarioResponsavel) != null){

servicoDAO.inserirServico(s1,funcionarioAux.getCarteiraTrab());

}else {

// ========== funcionario
inexistente ==========

System.out.println("FUNCIONARIO INEXISTENTE | 1 - CADASTRAR NOVO FUNCIONARIO | 2 -VOLTAR

");
if(op == 1) {
 System.out.println("Digite a carteira de Trabalho");

funcionarioAux.setCarteiraTrab(teclado.nextLine());

System.out.println("Digite o Salario");

funcionarioAux.setSalario(teclado.nextFloat());

teclado.nextLine();

System.out.println("Digite o Email");

funcionarioAux.setEmail(teclado.nextLine());

System.out.println("Digite Numero do Funcionario");

funcionarioAux.setNumero(teclado.nextInt());

funcionarioDAO.AdicionarFuncionario(funcionarioAux);
}else {

System.out.println("VOLTANDO AO MENU DE SERVIÇO");

chance = 3;

chance = 3;

} else {
chance++;
i = 3 - chance;
System.out.println("SERVIÇO JA
CADASTRADO!!");
System.out.println("\nVOCE
TEM : " + i + " tentativas!!");

}
} while (chance != 3);

break;
case 2:
String op2;
System.out.println("ID DO SERVIÇO QUE DESEJA
REMOVER");
teclado.nextLine();
int idAUX = teclado.nextInt();// antes de
exluir deve-se ver se ele não tem nem um
// agendamento, ou seja buscamos o cliente
verificamos se n
// há agendamento e depois exluimos.
System.out.println(
"VOCÊ TEM CERTEZA QUE DESEJA
EXCLUIR O SERVICO ?\nTODOS OS SEUS AGENDAMENTOS EM ABERTOS SERAM EXLUIDOS CONSEQUENTEMENTE!!\n 1-
SIM, EU CONFIRMO|2-CANCELAR");
op2 = teclado.nextLine();

if (op2 == "1") {
servicoDAO.excluirServico(idAUX);
} else {
System.out.println("CANCELANDO...");
}

break;

case 3:
 Serviço s1 = new Serviço();
i = 0;

do {
System.out.println("ID DO SERVIÇO QUE
DESEJA ALTERAR");
teclado.nextLine();
idAUX = teclado.nextInt();
s1.setId(idAUX);
if (servicoDAO.buscarServico(idAUX) !=
null) {
System.out.println("DIGITE O
ID");
s1.setId(teclado.nextInt());
System.out.println("DIGITE O
TIPO");
s1.setTipo(teclado.nextLine());

i = 3;
} else {
System.out.println("ID nao
encontrado");
i++;
}
} while (i != 3);

break;
case 4:

System.out.println("Todos os SERVIÇOS: ");

RelatorioDeServicos =
servicoDAO.servicoTotal();

System.out.println("=========================================================");
for (i = 0; i < RelatorioDeServicos.size(); i+
+) {
System.out.println("ID do SERVIÇO" + i +
" -> "+ RelatorioDeServicos.get(i).getId() +
"\nTIPO do SERVIÇO:" + i
+ "-> "+ RelatorioDeServicos.get(i).getTipo()+
"\nFUNCIONARIO
RESPONSAVEL:" + i + "-> "+ RelatorioDeServicos.get(i).getFuncionario().getCarteiraTrab());

System.out.println("=========================================================");
}

break;
case 5:
int servico1;
Serviço s2 = new Serviço();
System.out.println("ID DO SERVICO QUE DESEJA
BUSCAR");
teclado.nextLine();
servico1 = teclado.nextInt();
s2.setId(servico1);
servicoAux =
servicoDAO.buscarServico(servico1);

if(servicoDAO.buscarServico(servico1)!= null){

System.out.println("=========================================================");
System.out.println("\nID: " +
servicoAux.getId());
System.out.println("TIPO: " +
servicoAux.getTipo());
 System.out.println("=========================================================");
}else {
System.out.println("Servico nao
entrado");
}

break;
case 6:
i = 3;
break;
default:
System.out.println("Opção invalida");
}
} while (op != 6);

} while (i != 3);
break;

case 5:
System.out.println("ENCERRANDO...");

}
} while (op != 5);
}
=============================================================================================================

package Dominio;

public class Agenda_Servico {

private int id;
private Agendamento fk_agendamento;
private Serviço fk_servico;

public Agenda_Servico() {

public Agenda_Servico(int id, Agendamento fk_agendamento, Serviço fk_servico) {

this.id = id;
this.fk_agendamento = fk_agendamento;
this.fk_servico = fk_servico;

public int getId() {

return id;
}
public void setId(int id) {
this.id = id;
}
public Agendamento getFk_agendamento() {
return fk_agendamento;
}
public void setFk_agendamento(Agendamento fk_agendamento) {
this.fk_agendamento = fk_agendamento;
}
public Serviço getFk_servico() {
return fk_servico;
}
 public void setFk_servico(Serviço fk_servico) {
this.fk_servico = fk_servico;
}

=================================================================================================
============

package Dominio;

import java.sql.Date;
import java.sql.Time;
import java.util.ArrayList;

import persistencia.ClienteDAO;

public class Agendamento {

private long codigo;

private Date data;
private Time hora;
private Cliente fk_cliente;
ArrayList <Serviço> servicos;

public Agendamento(long codigo,Date data, Time hora) {

this.codigo=codigo;
this.data = data;
this.hora = hora;
}

public Agendamento(long codigo,Date data, Time hora,Cliente fk_cliente) {

this.codigo =codigo;
this.data = data;
this.hora = hora;
this.servicos = new ArrayList<Serviço>();
}

public Agendamento() {
this.servicos = new ArrayList<Serviço>();
}

// metodos
public Date getData() {
return data;
}
public void setData(Date data) {
this.data = data;
}
public Time getHora() {
return hora;
}
public void setHora(Time hora) {
this.hora = hora;
}

public long getCodigo() {

return codigo;
}
 public void setCodigo(long codigo) {
this.codigo = codigo;
}

public Cliente getCliente() {

return fk_cliente;
}
public void setCliente(Cliente cliente) {

ClienteDAO cliDAO= new ClienteDAO();

this.fk_cliente = cliDAO.buscar(cliente.getCpf());
}

public void setServicos(Serviço servico) {

this.servicos.add(servico);

public ArrayList<Serviço> getServicos( ) {

return this.servicos;
}

=================================================================================================
============

package Dominio;

public class Cliente {

private String email;
private String numero;
private String cpf;

public Cliente(){

public Cliente(String email, String numero, String cpf) {

this.email = email;
this.numero = numero;
this.cpf = cpf;
}
public String getEmail() {
return email;

public void setEmail(String email) {

this.email = email;
}
public String getNumero() {
return numero;
}
public void setNumero(String numero) {
this.numero = numero;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf.replaceAll("[.]", "");
 }
=================================================================================================
============

package Dominio;

public class Funcionario {

private float salario;
private String email;
private String carteiraTrab;
private int numero;

public Funcionario() {

public Funcionario(String carteiraTrab,float salario, String email, int numero){

this.salario = salario;
this.email = email;
this.carteiraTrab = carteiraTrab;
this.numero = numero;

public float getSalario() {

return salario;
}
public void setSalario(float salario) {
this.salario = salario;

}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getCarteiraTrab() {
return carteiraTrab;
}
public void setCarteiraTrab(String carteiraTrab) {
this.carteiraTrab = carteiraTrab;
}

public int getNumero() {

return numero;
}

public void setNumero(int numero) {

this.numero = numero;
}

=================================================================================================
package Dominio;

import java.sql.Date;
import java.sql.Time;
import java.util.ArrayList;

import persistencia.ClienteDAO;
import persistencia.FuncionarioDAO;

public class Serviço {

private int id ;
 private String tipo;
private Funcionario funcionario;

public Serviço(){

public Serviço(int id ,String tipo,Funcionario funcionario) {

this.id = id;
this.tipo = tipo;
}

public Serviço(int id ,String tipo) {

this.id = id;
this.tipo = tipo;
}

public void setId(int id) {

this.id = id;
}

public int getId() {

return id;
}

public String getTipo() {

return tipo;
}

public void setTipo(String tipo) {

this.tipo = tipo;
}

public Funcionario getFuncionario() {

return funcionario;
}

public void setFuncionario(Funcionario funcionario) {

FuncionarioDAO funcionarioDAO= new FuncionarioDAO();

this.funcionario = funcionarioDAO.buscarFun(funcionario.getCarteiraTrab());
}
=================================================================================================
}
package persistencia;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;

import Dominio.Agenda_Servico;
import Dominio.Agendamento;
import Dominio.Serviço;
import persistencia.Conexao;

public class Agenda_ServicoDAO {

privateConexao c;
private final String INSERIR = "insert into Agenda_Servico (fk_agendamento ,fk_servico)
values (?,?)";
 private final String relatorioSERVICOS = "select fk_servico from Agenda_Servico where
fk_agendamento = (?)";

public Agenda_ServicoDAO() {
c = new Conexao("jdbc:postgresql://localhost:5432/postgres","postgres","davi");
}

public void inserirAgendaServico( Agenda_Servico servico ) {

try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(INSERIR);

instrucao.setLong(1,servico.getFk_agendamento().getCodigo());
instrucao.setInt(2,servico.getFk_servico().getId());
instrucao.execute();
c.Desconectar();
}catch(Exception e) {
System.out.println("erro de conexão"+ e);
}

public ArrayList<Serviço> ServicosDeUmAgendamento(Long codigo){

ArrayList<Serviço> ServicosDeUmAgendamento = new ArrayList<Serviço>();

Serviço servicoAux = new Serviço();
servicoDAO servicoDAO = new servicoDAO();

try {

c.Conectar();
PreparedStatement instrucao =
c.getConexao().prepareStatement(relatorioSERVICOS);
instrucao.setLong(1,codigo);
ResultSet rs = instrucao.executeQuery();

while(rs.next()) {

servicoAux = servicoDAO.buscarServico(rs.getInt("fk_servico")) ;

ServicosDeUmAgendamento.add(servicoAux);
}
c.Desconectar();
}catch(Exception e) {System.out.println("ERRO NA BUSCA GERAL!!" + e);}

return ServicosDeUmAgendamento;

=================================================================================================
============}
}
package persistencia;
import persistencia.Conexao;
import Dominio.Agendamento;
import Dominio.Cliente;
import Dominio.Serviço;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Scanner;

import org.postgresql.util.PSQLException;

import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class AgendamentoDAO {

privateConexao c;
private final String INSERIR = "insert into\"agendamento\"
"+"(\"codigo\", \"data\", \"hora\", \"fk_cliente\") values (?,?,?,?)";
private final String EXCLUIR = "delete from \"agendamento\" where \"codigo\" = ?";
private final String BUSCAR = "select * from \"agendamento\" where \"codigo\" = ?";
private final String GERAL = "select * from \"agendamento\"";
private final String ALTERAR = "update \"agendamento\"set \"data\" = ?,\"hora\" = ?
where \"codigo\" = ?" ;
Scanner teclado = new Scanner(System.in);

ClienteDAO cliDAO = new ClienteDAO();

Cliente clienteAux = new Cliente();
Agenda_ServicoDAO agendaServicoDAOAux = new Agenda_ServicoDAO();
public AgendamentoDAO() {
c = new
Conexao("jdbc:postgresql://localhost:5432/postgres","postgres","davi");

public void Agendar(Agendamento a, String cpf) {

try {
c.Conectar();
ClienteDAO cliDAO = new ClienteDAO();

cliDAO.buscar(cpf);
Cliente clienteAux = new Cliente();
clienteAux = cliDAO.buscar(cpf);

PreparedStatement instrucao =
c.getConexao().prepareStatement(INSERIR);
instrucao.setLong(1,a.getCodigo());
instrucao.setDate(2, a.getData());
instrucao.setTime(3,a.getHora());
instrucao.setString(4,clienteAux.getCpf());
instrucao.execute();
c.Desconectar();
}catch(Exception e) {
System.out.println("erro de conexão"+ e);
}

public void AlterarAgendamento(Agendamento agendamento,long codigo) {

try {

c.Conectar();

PreparedStatement instrucao =
c.getConexao().prepareStatement(ALTERAR);
instrucao.setDate(1,agendamento.getData());
instrucao.setTime(2,agendamento.getHora());
instrucao.setLong(3,codigo);
instrucao.execute();
 c.Desconectar();
}catch(SQLException e) {
System.out.println("ERRO EM ALTERAR AGENDAMENTO"+ e);
}

public void ExcluirAgendamento(long codigo) {

try {

c.Conectar();
PreparedStatement instrucao =
c.getConexao().prepareStatement(EXCLUIR);
instrucao.setLong(1,codigo);
instrucao.execute();
c.Desconectar();

}catch(Exception e){
System.out.println("erro em excluir agendamento!!"+ e);
}

public Agendamento BuscarAgendamento(Long codigo) {

Agendamento agenda = null;

try {
c.Conectar();
PreparedStatement instrucao =
c.getConexao().prepareStatement(BUSCAR);
Cliente c1 = new Cliente();
instrucao.setLong(1, codigo);
ResultSet rs = instrucao.executeQuery();

if(rs.next()) {
agenda = new
Agendamento(rs.getLong("codigo"),rs.getDate("data"),rs.getTime("hora"));

c1.setCpf(rs.getString("fk_cliente"));
agenda.setCliente(c1);
}

}catch( Exception e){// n to conseguindo tratar essa exe

System.out.println("CLIENTE NÃO POSSUI AGENDAMENTOS EM ABERTO!"+e);
}

return agenda;

public ArrayList<Agendamento> RelatorioDeAgendamentos(){

ArrayList<Agendamento> RelatorioDeAgendamentos = new

ArrayList<Agendamento>();
ArrayList<Serviço> ServicosDeUmAgendamento = new ArrayList<Serviço>();
Serviço servicoAux;
servicoDAO servicoDAO = new servicoDAO();

try {

c.Conectar();
 Statement instrucao = c.getConexao().createStatement();
ResultSet rs = instrucao.executeQuery(GERAL);
while(rs.next()) {

Agendamento a = new Agendamento(

rs.getLong("codigo"),
rs.getDate("data"),
rs.getTime("hora"),
clienteAux =
cliDAO.buscar(rs.getString("fk_cliente")));
a.setCliente(clienteAux);

ServicosDeUmAgendamento =
agendaServicoDAOAux.ServicosDeUmAgendamento(rs.getLong("codigo"));

for(int i = 0 ; i < ServicosDeUmAgendamento.size();i++){//

for percorrendo o Array de Serviços
servicoAux = new Serviço();//instancio um novo obj
serviço
servicoAux =
servicoDAO.buscarServico(ServicosDeUmAgendamento.get(i).getId()); // preencho ele
a.setServicos(servicoAux);// coloco ele no array list
do objeto
}

RelatorioDeAgendamentos.add(a);
}
c.Desconectar();
}catch(Exception e) {System.out.println("ERRO NA BUSCA GERAL!!" + e);}

return RelatorioDeAgendamentos;

=================================================================================================
============

package persistencia;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import persistencia.Conexao;
import Dominio.Cliente;
public class ClienteDAO {
private Conexao c;
private final String INCLUIR = "insert into \"cliente\" " +
"(\"email\", \"numero\" ,\"cpf\") values (?,?,?)";
private final String EXCLUIR = "delete from \"cliente\" where \"cpf\"=?";
private final String BUSCAR = "select * from \"cliente\" where \"cpf\"=?";
private final String ALTERAR = "update \"cliente\"
set \"cpf\"=?, \"numero\"=?, \"email\"=? where \"cpf\"=?";
private final String GERAL = "select * from \"cliente\"";

public ClienteDAO() {
c = new Conexao("jdbc:postgresql://localhost:5432/postgres","postgres","davi");
}

public void inserirCliente(Cliente cli) {

try {

c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(INCLUIR);
instrucao.setString(1, cli.getEmail());
instrucao.setString(2, cli.getNumero());
instrucao.setString(3, cli.getCpf());
 instrucao.execute();

c.Desconectar();
}catch(SQLException e) {
System.out.println("Erro na inclusao" + e);
}
}
public void excluirCliente(String cpf) {
try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(EXCLUIR);
instrucao.setString(1, cpf);
instrucao.execute();
c.Desconectar();

}catch(SQLException e){
System.out.println("Erro na exclusao"+e);
}

public Cliente buscar(String cpf) {

Cliente cli = null;
try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(BUSCAR);
instrucao.setString(1, cpf);
ResultSet rs = instrucao.executeQuery();
if(rs.next()) {
cli = new Cliente (rs.getString("email"), rs.getString("numero"),
rs.getString("cpf"));
}
c.Desconectar();
}catch(SQLException e) {
System.out.println("Erro na busca"+e);
}
return cli;

public void alterarCliente(Cliente cli, String cpfAntigo) {

try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(ALTERAR);
instrucao.setString(1, cli.getCpf());
instrucao.setString(2, cli.getNumero());
instrucao.setString(3, cli.getEmail());
instrucao.setString(4, cpfAntigo);
instrucao.execute();
c.Desconectar();

}catch(SQLException e) {
System.out.println("Erro na alteracao" + e);
}

public ArrayList<Cliente> clientesTotal(){

ArrayList<Cliente> lista = new ArrayList<>();

try {
c.Conectar();
Statement instrucao = c.getConexao().createStatement();
ResultSet rs = instrucao.executeQuery(GERAL);
while(rs.next()) {
Cliente cli = new Cliente (rs.getString("email"), rs.getString("numero"),
rs.getString("cpf"));
 lista.add(cli);
}
c.Desconectar();
}catch(SQLException e){
System.out.println("Erro na lista"+e);
}
return lista;
}

}package persistencia;
import java.sql.Connection;
import java.sql.DriverManager;

public class Conexao {

private String usuario;
private String senha;
private String caminho;
private Connection conexao;

public Conexao(String c, String u, String s) {

this.usuario = u;
this.senha = s ;
this.caminho = c;

public void Conectar() {

try{
Class.forName("org.postgresql.Driver");//caminho do driver \ cria a conexao
com o postgre
conexao = DriverManager.getConnection(caminho,usuario,senha);

}catch(Exception e) {
System.out.println("erro!");
};

public void Desconectar() {

try {
conexao.close();

}catch(Exception e) {System.out.println("ERRO DE DESCONEXÃO");}

}

public Connection getConexao() {

return conexao;
}

}============================================================================================================
=

package persistencia;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;

import Dominio.Cliente;
import Dominio.Funcionario;
import Dominio.Serviço;

public class FuncionarioDAO {

private Conexao c;
private final String INSERIR = "insert into \"funcionario\"
"+"(\"carteiradetrabalho\",\"salario\",\"email\",\"numero\") values (?,?,?,?)";
private final String EXCLUIR = "delete
from \"funcionario\"where \"carteiradetrabalho\"=?";
private final String GERAL = "select * from \"funcionario\"";
private final String BUSCAR = "select * from \"funcionario\"
where \"carteiradetrabalho\"=?";
private final String ALTERAR = "update \"funcionario\"
set \"carteiradetrabalho\"=?, \"salario\"=?, \"email\"=?, \"numero\"=?
where \"carteiradetrabalho\"=?";

public FuncionarioDAO() {
c = new Conexao("jdbc:postgresql://localhost:5432/postgres","postgres","davi");
}

public void AdicionarFuncionario(Funcionario f) {

try {
c.Conectar();

PreparedStatement instrucao = c.getConexao().prepareStatement(INSERIR);

instrucao.setString(1,f.getCarteiraTrab());
instrucao.setFloat(2,f.getSalario());
instrucao.setString(3,f.getEmail());
instrucao.setInt(4,f.getNumero());

instrucao.execute();
c.Desconectar();

}catch(SQLException e) {
System.out.println("ERRO AO INSERIR O USUARIO "+e);
};
}

public void alterarFuncionario(Funcionario f, String trab) {

try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(ALTERAR);
instrucao.setString(1,f.getCarteiraTrab());
instrucao.setFloat(2,f.getSalario());
instrucao.setString(3,f.getEmail());
instrucao.setInt(4,f.getNumero());

instrucao.setString(5, trab);
instrucao.execute();
c.Desconectar();

}catch(SQLException e) {
System.out.println("ERRO AO ALTERAR" + e);
}
}

public void excluirFuncionario(String carteiraTrab) {

try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(EXCLUIR);
instrucao.setString (1, carteiraTrab);
instrucao.execute();
 c.Desconectar();
}catch(SQLException e) {
System.out.println("Erro para excluir");
}
}

public ArrayList<Funcionario> RelatorioFuncionarios(){

ArrayList<Funcionario> RelatorioDeFuncionarios = new ArrayList<>();
FuncionarioDAO funcionarioDAOaux = new FuncionarioDAO();

try {
c.Conectar();

Statement instrucao = c.getConexao().createStatement();

ResultSet rs = instrucao.executeQuery(GERAL);

while(rs.next()) {
Funcionario f1 = new Funcionario(
rs.getString("carteiradetrabalho"),
rs.getFloat("salario"),
rs.getString("email"),
rs.getInt("numero"));
RelatorioDeFuncionarios.add(f1);

c.Desconectar();
}catch(SQLException e){
System.out.println("ERRO NO RELATORIO "+e);
}
return RelatorioDeFuncionarios;
}

public Funcionario buscarFun(String carteiraTrab) {

Funcionario f = null;
try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(BUSCAR);
instrucao.setString(1, carteiraTrab);
ResultSet rs = instrucao.executeQuery();
if(rs.next()) {
f = new Funcionario (rs.getString("carteiradetrabalho"), rs.getFloat("salario"),
rs.getString("email"), rs.getInt("numero"));
}
c.Desconectar();
}catch(SQLException e) {
System.out.println("Erro na busca " +e);
}
return f;

=============================================================================================================

}
package persistencia;

import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import Dominio.Cliente;
import Dominio.Funcionario;
import Dominio.Serviço;
public class servicoDAO {
private Conexao c;
private final String INSERIR = "insert into \"servico\"
"+"(\"id\",\"tipo\",\"fk_funcionario\") values (?,?,?)";
private final String EXCLUIR = "delete from \"servico\"where \"id\"=?";
private final String GERAL = "select * from \"servico\"";
private final String BUSCAR = "select * from \"servico\" where \"id\"=?";
private final String ALTERAR = "update \"servico\" set \"id\"=?, \"tipo\"=?,
where \"id\"=?";

public servicoDAO() {
c = new Conexao("jdbc:postgresql://localhost:5432/postgres","postgres","davi");
}

FuncionarioDAO funcionarioDAO = new FuncionarioDAO();

Funcionario funcionarioAux = new Funcionario();

public void inserirServico(Serviço servico,String carteiraTrab) {

try {

c.Conectar();

funcionarioAux = funcionarioDAO.buscarFun(carteiraTrab);
PreparedStatement instrucao = c.getConexao().prepareStatement(INSERIR);
instrucao.setInt(1, servico.getId());
instrucao.setString(2, servico.getTipo());
instrucao.setString(3,funcionarioAux.getCarteiraTrab());
instrucao.execute();

c.Desconectar();
}catch(SQLException e) {
System.out.println("Erro na inclusao" + e);
}
}

public void excluirServico(int id) {

try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(EXCLUIR);
instrucao.setInt(1, id);
instrucao.execute();
c.Desconectar();

}catch(SQLException e){
System.out.println("Erro na exclusao do servico"+e);
}

public Serviço buscarServico(int id) {

Serviço servico = null;
try {
c.Conectar();
PreparedStatement instrucao = c.getConexao().prepareStatement(BUSCAR);
instrucao.setInt(1, id);
ResultSet rs = instrucao.executeQuery();

if(rs.next()) {
servico = new Serviço (rs.getInt("id"), rs.getString("tipo"));
funcionarioAux.setCarteiraTrab(rs.getString("fk_funcionario"));
}
c.Desconectar();
 }catch(SQLException e) {
System.out.println("Erro na busca"+e);
}
return servico;

public void alterarCliente(Serviço servico, int idDeBusca) {

try {
c.Conectar();
PreparedStatement instrucao =
c.getConexao().prepareStatement(ALTERAR);
instrucao.setInt(1, servico.getId());
instrucao.setString(2, servico.getTipo());
instrucao.setInt(2, idDeBusca);

instrucao.execute();
c.Desconectar();

}catch(SQLException e) {
System.out.println("Erro na alteracao" + e);
}

public ArrayList<Serviço> servicoTotal(){

ArrayList<Serviço> lista = new ArrayList<>();

try {
c.Conectar();
Statement instrucao = c.getConexao().createStatement();
ResultSet rs = instrucao.executeQuery(GERAL);
while(rs.next()) {
Serviço servico = new Serviço (
rs.getInt("id"),
rs.getString("tipo"),
funcionarioAux =
funcionarioDAO.buscarFun(rs.getString("fk_funcionario")));

servico.setFuncionario(funcionarioAux);

lista.add(servico);
}
c.Desconectar();
}catch(SQLException e){
System.out.println("Erro na lista "+e);
}
return lista;
}