/*
* Contem todo so campos pertinentes. Assumo aqui que a chave primaria para
* a entidade Turma eh a conjuncao de 'ano', 'semestre' e 'cpfProfessor'
*/
public void cadastraTurma(
String ano,
String semestre,
String cpfProfessor,
String horario,
String nivel,
ArrayList<String> matriculasAlunos)
throws Exception {
Turma turma = new Turma(validaAno(ano), validaSemestre(semestre), horario, nivel, cpfProfessor);
Professor p = fachada.recuperaProfessor(new Professor(cpfProfessor));
Nivel n = fachada.recuperaNivel(new Nivel(nivel));
if (p == null) {
throw new Exception("Professor Invalido!");
}
if (n == null) {
throw new Exception("Nivel Invalido!");
}
for (String aluno : matriculasAlunos) {
turma.alunos.add(aluno);
}
fachada.cadastraTurma(turma);
}
/*
* Contem todos os campos pertinentes. Assumo aqui que a chave primaria eh a
* conjuncao de matriculaAluno, valor, dia, mes e an. Sao passadas as chaves
* primarias de antes da modificacao, para que seja possivel identificar a
* linhas a ser alterada.
*/
public void editaPagamento(
String codigo,
String matriculaAluno,
String valorPagamento,
String diaPagamento,
String mesPagamento,
String anoPagamento)
throws Exception {
Date dataPagamento = null;
validaMatricula(matriculaAluno);
double valorPagamento_d = validaValorPagamento(valorPagamento);
dataPagamento = validaData(diaPagamento + "/" + mesPagamento + "/" + anoPagamento);
Aluno a = fachada.recuperaAluno(new Aluno(matriculaAluno));
if (a == null) {
throw new Exception("Aluno nao encontrado!");
}
Pagamento pagamento =
new Pagamento(Long.parseLong(codigo), valorPagamento_d, dataPagamento, matriculaAluno);
fachada.editaPagamento(pagamento);
}
/*
* Trivial
*/
public void cadastraNivel(String nome, String codigo) throws Exception {
validaNomeNivel(nome);
validaCodigoNivel(codigo);
Nivel nivel = new Nivel(codigo, nome);
fachada.cadastraNivel(nivel);
}
public ArrayList<ConsultaPagamentoRow> getTodosPagamentos() {
ArrayList<ConsultaPagamentoRow> pagamentos = new ArrayList<ConsultaPagamentoRow>();
ArrayList<Pagamento> array = fachada.listarPagamentos();
for (Pagamento p : array) {
Aluno a = fachada.recuperaAluno(new Aluno(p.aluno));
pagamentos.add(
new ConsultaPagamentoRow(
p.id + "",
a.matricula + " " + a.nome,
p.valorPagamento + "",
formatter.format(p.dataPagamento)));
}
return pagamentos;
}
public ArrayList<ConsultaTurmaRow> getTodasTurmas() {
ArrayList<ConsultaTurmaRow> turmas = new ArrayList<ConsultaTurmaRow>();
ArrayList<Turma> array_turmas = fachada.listarTurmas();
for (Turma turma : array_turmas) {
ArrayList<CadastraTurmaRow> array_alunos = new ArrayList<CadastraTurmaRow>();
for (String a : turma.alunos) {
array_alunos.add(new CadastraTurmaRow(fachada.recuperaAluno(new Aluno(a))));
}
Professor p = fachada.recuperaProfessor(new Professor(turma.professor));
String cpf_nome = p.CPF + " " + p.nome;
turma.professor = cpf_nome;
turmas.add(new ConsultaTurmaRow(turma, array_alunos));
}
return turmas;
}
public ArrayList<ConsultaProfessorRow> getTodosProfessores() {
ArrayList<ConsultaProfessorRow> professores = new ArrayList<ConsultaProfessorRow>();
ArrayList<Professor> profList = fachada.listarProfessores();
for (Professor professor : profList) {
professores.add(new ConsultaProfessorRow(professor));
}
return professores;
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaProfessorRow> consultaProfessor(ArrayList<String> parametros) {
ArrayList<ConsultaProfessorRow> professores = new ArrayList<ConsultaProfessorRow>();
ArrayList<Professor> profList = fachada.consultaProfessores(parametros);
for (Professor professor : profList) {
professores.add(new ConsultaProfessorRow(professor));
}
return professores;
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaAlunoRow> consultaAlunos(ArrayList<String> parametros) {
ArrayList<ConsultaAlunoRow> alunos = new ArrayList<ConsultaAlunoRow>();
ArrayList<Aluno> array = fachada.consultaAlunos(parametros);
for (Aluno a : array) {
alunos.add(new ConsultaAlunoRow(a));
}
return alunos;
}
/*
* Pega todos os horarios presentes na tabela de Turmas.
*/
public String[] getHorariosTurmas() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Turma> arrayTurmas = fachada.listarTurmas();
for (Turma turma : arrayTurmas) {
if (!retorno.contains(turma.horario + "")) retorno.add(turma.horario);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Contem todos os campos pertinentes. Eh passado o cpf de antes da
* modificacao, para que seja possivel saber que linha alterar. Lembrando
* que o proprio cpf pode ser modificado.
*/
public void editaProfessor(
String cpfOriginal,
String nome,
String diaDataNascimento,
String mesDataNascimento,
String anoDataNascimento,
String cpf,
String rg,
String telefone,
String celular,
String email,
String diaDataAdmissao,
String mesDataAdmissao,
String anoDataAdmissao,
String salario,
String diaPagamento,
String endereco)
throws Exception {
Date dataNasc = null;
Date dataAdmissao = null;
validaNomeProfessor(nome);
dataNasc = validaData(diaDataNascimento + "/" + mesDataNascimento + "/" + anoDataNascimento);
validaCpf(cpf);
validaRg(rg);
validaTelefone(telefone);
validaCelular(celular);
validaEmail(email);
dataAdmissao = validaData(diaDataAdmissao + "/" + mesDataAdmissao + "/" + anoDataAdmissao);
validaDatasNascimentoAdmissao(dataNasc, dataAdmissao);
double salario_d = 0;
if (!salario.isEmpty()) salario_d = validaSalario(salario);
int dataPagamento = 5;
if (!diaPagamento.isEmpty()) dataPagamento = validaDataPagamento(diaPagamento);
validaEndereco(endereco);
Professor professor =
new Professor(
cpfOriginal,
nome,
rg,
dataNasc,
salario_d,
dataPagamento,
telefone,
celular,
endereco,
email,
dataAdmissao);
fachada.editaProfessor(professor);
}
public ArrayList<ConsultaAlunoRow> getTodosAlunos() {
ArrayList<Aluno> array = fachada.listarAlunos();
ArrayList<ConsultaAlunoRow> alunos = new ArrayList<ConsultaAlunoRow>();
for (Aluno a : array) {
alunos.add(new ConsultaAlunoRow(a));
}
return alunos;
}
/*
* Pega todos os dias presentes na tabela de pagamentos.
*/
public String[] getDiasPagamentos() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Pagamento> arrayPagamentos = fachada.listarPagamentos();
for (Pagamento pagamento : arrayPagamentos) {
String data = formatter.format(pagamento.dataPagamento);
if (!retorno.contains(data.split("/")[0])) retorno.add(data.split("/")[0]);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
public void removeAluno(String matricula) {
fachada.removeAluno(new Aluno(matricula));
}
/*
* Cpf é chave primária de professor. Trivial.
*/
public void removeProfessor(String cpf) {
fachada.removeProfessor(new Professor(cpf));
}
/*
* Nao tenho o id, mas creio que esses quatro campos identificam unicamente.
*/
public void removeTurma(String codigo) {
fachada.removeTurma(new Turma(Integer.parseInt(codigo)));
}
/*
* Nao tenho o id, mas creio que esses tres campos identificam unicamente. A
* data eh no formato "dd/<mes por extenso>/yyyy"
*/
public void removePagamento(String codigo) {
fachada.removePagamento(new Pagamento(Long.parseLong(codigo)));
}
/*
* Trivial
*/
public void removeNivel(String codigo) {
fachada.removeNivel(new Nivel(codigo));
}
/*
* Funcao que retorna todos os alunos cadastrados, em forma de objeto Aluno,
* que contem 'matricula' e 'nome'.
*/
public ArrayList<Aluno> getAllAlunos() {
ArrayList<Aluno> retorno = fachada.listarAlunos();
return retorno;
}
/*
* Funcao que retorna todos os alunos cadastrados, em forma de objeto
* Professor, que contem 'cpf' e 'nome'.
*/
public ArrayList<Professor> getAllProfessores() {
ArrayList<Professor> professores = fachada.listarProfessores();
return professores;
}
/** @author silas */
public class AraraMaster {
static Fachada fachada = Fachada.getInstance();
public static SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy", Locale.US);
/*
* Contem todos os campos pertinentes. O campo 'matricula' eh uma chave
* primaria gerada pelo banco, nao eh pertinente aqui.
*/
public void cadastraAluno(
String nome,
String matricula,
String dataDeNascimentoDia,
String dataDeNascimentoMes,
String dataDeNascimentoAno,
String cpf,
String rg,
String telefone,
String celular,
String email,
String dataDeEntradaDia,
String dataDeEntradaMes,
String dataDeEntradaAno,
String valorDaMensalidade,
String vencimentoDaMensalidade,
String endereco,
String nomeDoPai,
String nomeDaMae,
String nomeDoResponsavel,
String celularDoResponsavel)
throws Exception {
Date dataNasc = null;
Date dataEntradaNoCurso = null;
validaNomeAluno(nome);
validaMatricula(matricula); // se for vazia, da excecao
dataNasc =
validaData(dataDeNascimentoDia + "/" + dataDeNascimentoMes + "/" + dataDeNascimentoAno);
if (!cpf.isEmpty()) validaCpf(cpf); // da excecao se for vazia
validaRg(rg); // nao da excecao se for vazia
validaTelefone(telefone); // nao da excecao se for vazia
validaCelular(celular); // nao da excecao se for vazia
validaEmail(email); // nao da excecao se for vazia
dataEntradaNoCurso =
validaData(dataDeEntradaDia + "/" + dataDeEntradaMes + "/" + dataDeEntradaAno);
validaDatasNascimentoEntrada(dataNasc, dataEntradaNoCurso);
double valorMensalidade = 0;
if (!valorDaMensalidade.isEmpty()) {
valorMensalidade = validaMensalidade(valorDaMensalidade);
}
int diaVencimentoMensalidade = 5;
if (!vencimentoDaMensalidade.isEmpty()) {
diaVencimentoMensalidade = validaDiaVencimento(vencimentoDaMensalidade);
}
validaEndereco(endereco);
validaNomePai(nomeDoPai);
validaNomeMae(nomeDaMae);
validaNomeResponsavel(nomeDoResponsavel);
validaCelularResponsavel(celularDoResponsavel); // nao da excecao se for
// vazia
Aluno aluno =
new Aluno(
matricula,
nome,
cpf,
rg,
dataNasc,
telefone,
nomeDoPai,
nomeDaMae,
nomeDoResponsavel,
celularDoResponsavel,
endereco,
valorMensalidade,
diaVencimentoMensalidade,
email,
dataEntradaNoCurso);
fachada.cadastraAluno(aluno);
}
/*
* Contem todos os campos pertinentes. O campo 'matricula' eh passado como
* parametro, para que seja possivel saber que linha da tabela deve ser
* alterada.
*/
public void editaAluno(
String matriculaOriginal,
String nome,
String matricula,
String dataDeNascimentoDia,
String dataDeNascimentoMes,
String dataDeNascimentoAno,
String cpf,
String rg,
String telefone,
String celular,
String email,
String dataDeEntradaDia,
String dataDeEntradaMes,
String dataDeEntradaAno,
String valorDaMensalidade,
String vencimentoDaMensalidade,
String endereco,
String nomeDoPai,
String nomeDaMae,
String nomeDoResponsavel,
String celularDoResponsavel)
throws Exception {
Date dataNasc = null;
Date dataEntradaNoCurso = null;
validaNomeAluno(nome);
validaMatricula(matricula); // se for vazia, da excecao
dataNasc =
validaData(dataDeNascimentoDia + "/" + dataDeNascimentoMes + "/" + dataDeNascimentoAno);
if (!cpf.isEmpty()) validaCpf(cpf); // da excecao se for vazia
validaRg(rg); // nao da excecao se for vazia
validaTelefone(telefone); // nao da excecao se for vazia
validaCelular(celular); // nao da excecao se for vazia
validaEmail(email); // nao da excecao se for vazia
dataEntradaNoCurso =
validaData(dataDeEntradaDia + "/" + dataDeEntradaMes + "/" + dataDeEntradaAno);
validaDatasNascimentoEntrada(dataNasc, dataEntradaNoCurso);
double valorMensalidade = 0;
if (!valorDaMensalidade.isEmpty()) {
valorMensalidade = validaMensalidade(valorDaMensalidade);
}
int diaVencimentoMensalidade = 5;
if (!vencimentoDaMensalidade.isEmpty()) {
diaVencimentoMensalidade = validaDiaVencimento(vencimentoDaMensalidade);
}
validaEndereco(endereco);
validaNomePai(nomeDoPai);
validaNomeMae(nomeDaMae);
validaNomeResponsavel(nomeDoResponsavel);
validaCelularResponsavel(celularDoResponsavel); // nao da excecao se for
// vazia
Aluno aluno =
new Aluno(
matriculaOriginal,
nome,
cpf,
rg,
dataNasc,
telefone,
nomeDoPai,
nomeDaMae,
nomeDoResponsavel,
celularDoResponsavel,
endereco,
valorMensalidade,
diaVencimentoMensalidade,
email,
dataEntradaNoCurso);
fachada.editaAluno(aluno);
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaAlunoRow> consultaAlunos(ArrayList<String> parametros) {
ArrayList<ConsultaAlunoRow> alunos = new ArrayList<ConsultaAlunoRow>();
ArrayList<Aluno> array = fachada.consultaAlunos(parametros);
for (Aluno a : array) {
alunos.add(new ConsultaAlunoRow(a));
}
return alunos;
}
public ArrayList<ConsultaAlunoRow> getTodosAlunos() {
ArrayList<Aluno> array = fachada.listarAlunos();
ArrayList<ConsultaAlunoRow> alunos = new ArrayList<ConsultaAlunoRow>();
for (Aluno a : array) {
alunos.add(new ConsultaAlunoRow(a));
}
return alunos;
}
/*
* Contem todo so campos pertinentes. Assumo aqui que a chave primaria para
* a entidade Turma eh a conjuncao de 'ano', 'semestre' e 'cpfProfessor'
*/
public void cadastraTurma(
String ano,
String semestre,
String cpfProfessor,
String horario,
String nivel,
ArrayList<String> matriculasAlunos)
throws Exception {
Turma turma = new Turma(validaAno(ano), validaSemestre(semestre), horario, nivel, cpfProfessor);
Professor p = fachada.recuperaProfessor(new Professor(cpfProfessor));
Nivel n = fachada.recuperaNivel(new Nivel(nivel));
if (p == null) {
throw new Exception("Professor Invalido!");
}
if (n == null) {
throw new Exception("Nivel Invalido!");
}
for (String aluno : matriculasAlunos) {
turma.alunos.add(aluno);
}
fachada.cadastraTurma(turma);
}
/*
* Contem todo so campos pertinentes. Assumo aqui que a chave primaria para
* a entidade Turma eh 'codigo'.
*/
public void editaTurma(
String codigo,
String ano,
String semestre,
String cpfProfessor,
String horario,
String nivel,
ArrayList<String> matriculasAlunos)
throws Exception {
Turma turma =
new Turma(
Integer.parseInt(codigo),
validaAno(ano),
validaSemestre(semestre),
horario,
nivel,
cpfProfessor);
Professor p = fachada.recuperaProfessor(new Professor(cpfProfessor));
Nivel n = fachada.recuperaNivel(new Nivel(nivel));
if (p == null) {
throw new Exception("Professor Invalido!");
}
if (n == null) {
throw new Exception("Nivel Invalido!");
}
for (String aluno : matriculasAlunos) {
turma.alunos.add(aluno);
}
fachada.editaTurma(turma);
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaTurmaRow> consultaTurma(ArrayList<String> parametros) {
ArrayList<ConsultaTurmaRow> turmas = new ArrayList<ConsultaTurmaRow>();
ArrayList<Turma> array_turmas = fachada.consultaTurmas(parametros);
for (Turma turma : array_turmas) {
ArrayList<CadastraTurmaRow> array_alunos = new ArrayList<CadastraTurmaRow>();
for (String a : turma.alunos) {
array_alunos.add(new CadastraTurmaRow(fachada.recuperaAluno(new Aluno(a))));
}
Professor p = fachada.recuperaProfessor(new Professor(turma.professor));
String cpf_nome = p.CPF + " " + p.nome;
turma.professor = cpf_nome;
turmas.add(new ConsultaTurmaRow(turma, array_alunos));
}
return turmas;
}
public ArrayList<ConsultaTurmaRow> getTodasTurmas() {
ArrayList<ConsultaTurmaRow> turmas = new ArrayList<ConsultaTurmaRow>();
ArrayList<Turma> array_turmas = fachada.listarTurmas();
for (Turma turma : array_turmas) {
ArrayList<CadastraTurmaRow> array_alunos = new ArrayList<CadastraTurmaRow>();
for (String a : turma.alunos) {
array_alunos.add(new CadastraTurmaRow(fachada.recuperaAluno(new Aluno(a))));
}
Professor p = fachada.recuperaProfessor(new Professor(turma.professor));
String cpf_nome = p.CPF + " " + p.nome;
turma.professor = cpf_nome;
turmas.add(new ConsultaTurmaRow(turma, array_alunos));
}
return turmas;
}
/*
* Contem todos os campos pertinentes. Assumo aqui que a chave primaria eh a
* conjuncao de matriculaAluno, valor, dia, mes e ano
*/
public void cadastraPagamento(
String matriculaAluno,
String valorPagamento,
String diaPagamento,
String mesPagamento,
String anoPagamento)
throws Exception {
Date dataPagamento = null;
validaMatricula(matriculaAluno);
double valorPagamento_d = validaValorPagamento(valorPagamento);
dataPagamento = validaData(diaPagamento + "/" + mesPagamento + "/" + anoPagamento);
Aluno a = fachada.recuperaAluno(new Aluno(matriculaAluno));
if (a == null) {
throw new Exception("Aluno nao encontrado!");
}
Pagamento pagamento = new Pagamento(valorPagamento_d, dataPagamento, matriculaAluno);
fachada.cadastraPagamento(pagamento);
}
/*
* Contem todos os campos pertinentes. Assumo aqui que a chave primaria eh a
* conjuncao de matriculaAluno, valor, dia, mes e an. Sao passadas as chaves
* primarias de antes da modificacao, para que seja possivel identificar a
* linhas a ser alterada.
*/
public void editaPagamento(
String codigo,
String matriculaAluno,
String valorPagamento,
String diaPagamento,
String mesPagamento,
String anoPagamento)
throws Exception {
Date dataPagamento = null;
validaMatricula(matriculaAluno);
double valorPagamento_d = validaValorPagamento(valorPagamento);
dataPagamento = validaData(diaPagamento + "/" + mesPagamento + "/" + anoPagamento);
Aluno a = fachada.recuperaAluno(new Aluno(matriculaAluno));
if (a == null) {
throw new Exception("Aluno nao encontrado!");
}
Pagamento pagamento =
new Pagamento(Long.parseLong(codigo), valorPagamento_d, dataPagamento, matriculaAluno);
fachada.editaPagamento(pagamento);
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaPagamentoRow> consultaPagamento(ArrayList<String> parametros) {
ArrayList<ConsultaPagamentoRow> pagamentos = new ArrayList<ConsultaPagamentoRow>();
ArrayList<Pagamento> array = fachada.consultaPagamentos(parametros);
for (Pagamento p : array) {
Aluno a = fachada.recuperaAluno(new Aluno(p.aluno));
pagamentos.add(
new ConsultaPagamentoRow(
p.id + "",
a.matricula + " " + a.nome,
p.valorPagamento + "",
formatter.format(p.dataPagamento)));
}
return pagamentos;
}
public ArrayList<ConsultaPagamentoRow> getTodosPagamentos() {
ArrayList<ConsultaPagamentoRow> pagamentos = new ArrayList<ConsultaPagamentoRow>();
ArrayList<Pagamento> array = fachada.listarPagamentos();
for (Pagamento p : array) {
Aluno a = fachada.recuperaAluno(new Aluno(p.aluno));
pagamentos.add(
new ConsultaPagamentoRow(
p.id + "",
a.matricula + " " + a.nome,
p.valorPagamento + "",
formatter.format(p.dataPagamento)));
}
return pagamentos;
}
/*
* Trivial
*/
public void cadastraNivel(String nome, String codigo) throws Exception {
validaNomeNivel(nome);
validaCodigoNivel(codigo);
Nivel nivel = new Nivel(codigo, nome);
fachada.cadastraNivel(nivel);
}
/*
* Eh passado o nome antigo, para que seja possivel identificar a linha na
* tabela e o nome novo.
*/
public void editaNivel(String codigoOriginal, String nome, String codigo) throws Exception {
validaNomeNivel(nome);
Nivel nivel = new Nivel(codigoOriginal, nome);
fachada.editaNivel(nivel);
}
/*
* Retorna a lista de todos os niveis, ordenada alfabeticamente.
*/
public ArrayList<Nivel> getAllNiveis() {
return fachada.listarNiveis();
}
/*
* Contem todos os campos pertinentes. O campo 'cpf' eh a chave primaria.
*/
public void cadastraProfessor(
String nome,
String diaDataNascimento,
String mesDataNascimento,
String anoDataNascimento,
String cpf,
String rg,
String telefone,
String celular,
String email,
String diaDataAdmissao,
String mesDataAdmissao,
String anoDataAdmissao,
String salario,
String diaPagamento,
String endereco)
throws Exception {
Date dataNasc = null;
Date dataAdmissao = null;
validaNomeProfessor(nome);
dataNasc = validaData(diaDataNascimento + "/" + mesDataNascimento + "/" + anoDataNascimento);
validaCpf(cpf);
validaRg(rg);
validaTelefone(telefone);
validaCelular(celular);
validaEmail(email);
dataAdmissao = validaData(diaDataAdmissao + "/" + mesDataAdmissao + "/" + anoDataAdmissao);
validaDatasNascimentoAdmissao(dataNasc, dataAdmissao);
double salario_d = 0;
if (!salario.isEmpty()) salario_d = validaSalario(salario);
int dataPagamento = 5;
if (!diaPagamento.isEmpty()) dataPagamento = validaDataPagamento(diaPagamento);
validaEndereco(endereco);
Professor professor =
new Professor(
cpf,
nome,
rg,
dataNasc,
salario_d,
dataPagamento,
telefone,
celular,
endereco,
email,
dataAdmissao);
fachada.cadastraProfessor(professor);
}
/*
* Recebe os campos que devem ser utilizados para realizar a busca. Cada
* elemento do ArrayList eh uma string da forma
* "<apelido do campo>::<valor procurado>"
*/
public ArrayList<ConsultaProfessorRow> consultaProfessor(ArrayList<String> parametros) {
ArrayList<ConsultaProfessorRow> professores = new ArrayList<ConsultaProfessorRow>();
ArrayList<Professor> profList = fachada.consultaProfessores(parametros);
for (Professor professor : profList) {
professores.add(new ConsultaProfessorRow(professor));
}
return professores;
}
public ArrayList<ConsultaProfessorRow> getTodosProfessores() {
ArrayList<ConsultaProfessorRow> professores = new ArrayList<ConsultaProfessorRow>();
ArrayList<Professor> profList = fachada.listarProfessores();
for (Professor professor : profList) {
professores.add(new ConsultaProfessorRow(professor));
}
return professores;
}
/*
* Contem todos os campos pertinentes. Eh passado o cpf de antes da
* modificacao, para que seja possivel saber que linha alterar. Lembrando
* que o proprio cpf pode ser modificado.
*/
public void editaProfessor(
String cpfOriginal,
String nome,
String diaDataNascimento,
String mesDataNascimento,
String anoDataNascimento,
String cpf,
String rg,
String telefone,
String celular,
String email,
String diaDataAdmissao,
String mesDataAdmissao,
String anoDataAdmissao,
String salario,
String diaPagamento,
String endereco)
throws Exception {
Date dataNasc = null;
Date dataAdmissao = null;
validaNomeProfessor(nome);
dataNasc = validaData(diaDataNascimento + "/" + mesDataNascimento + "/" + anoDataNascimento);
validaCpf(cpf);
validaRg(rg);
validaTelefone(telefone);
validaCelular(celular);
validaEmail(email);
dataAdmissao = validaData(diaDataAdmissao + "/" + mesDataAdmissao + "/" + anoDataAdmissao);
validaDatasNascimentoAdmissao(dataNasc, dataAdmissao);
double salario_d = 0;
if (!salario.isEmpty()) salario_d = validaSalario(salario);
int dataPagamento = 5;
if (!diaPagamento.isEmpty()) dataPagamento = validaDataPagamento(diaPagamento);
validaEndereco(endereco);
Professor professor =
new Professor(
cpfOriginal,
nome,
rg,
dataNasc,
salario_d,
dataPagamento,
telefone,
celular,
endereco,
email,
dataAdmissao);
fachada.editaProfessor(professor);
}
/*
* Funcao que retorna todos os alunos cadastrados, em forma de objeto
* Professor, que contem 'cpf' e 'nome'.
*/
public ArrayList<Professor> getAllProfessores() {
ArrayList<Professor> professores = fachada.listarProfessores();
return professores;
}
/*
* Funcao auxiliar que extrai o 'dia' de uma data no formato
* 'dd/mesporextenso/yyyy'
*/
public int getDia(String data, String separador) {
return Integer.parseInt(data.split(separador)[0]) - 1;
}
/*
* Funcao auxiliar que extrai o 'mes' de uma data no formato
* 'dd/mesporextenso/yyyy'
*/
public int getMes(String data, String separador) {
String mes = data.split(separador)[1];
int retorno;
if (mes.equals("Janeiro") || mes.equals("01")) retorno = 0;
else if (mes.equals("Fevereiro") || mes.equals("02")) retorno = 1;
else if (mes.equals("Março") || mes.equals("03")) retorno = 2;
else if (mes.equals("Abril") || mes.equals("04")) retorno = 3;
else if (mes.equals("Maio") || mes.equals("05")) retorno = 4;
else if (mes.equals("Junho") || mes.equals("06")) retorno = 5;
else if (mes.equals("Julho") || mes.equals("07")) retorno = 6;
else if (mes.equals("Agosto") || mes.equals("08")) retorno = 7;
else if (mes.equals("Setembro") || mes.equals("09")) retorno = 8;
else if (mes.equals("Outubro") || mes.equals("10")) retorno = 9;
else if (mes.equals("Novembro") || mes.equals("11")) retorno = 10;
else if (mes.equals("Dezembro") || mes.equals("12")) retorno = 11;
else retorno = -1;
return retorno;
}
/*
* Funcao auxiliar que extrai o 'ano' de uma data no formato
* 'dd/mesporextenso/yyyy', lembrando que o menor ano possível é '1900'
*/
public int getAno(String data, String separador) {
int ano = Integer.parseInt(data.split(separador)[2]);
return ano - 1900; // primeira opcao eh 1900
}
/*
* Funcao que retorna todos os alunos cadastrados, em forma de objeto Aluno,
* que contem 'matricula' e 'nome'.
*/
public ArrayList<Aluno> getAllAlunos() {
ArrayList<Aluno> retorno = fachada.listarAlunos();
return retorno;
}
/*
* Pega todos os anos presentes na tabela de pagamentos.
*/
public String[] getAnosPagamentos() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Pagamento> arrayPagamentos = fachada.listarPagamentos();
for (Pagamento pagamento : arrayPagamentos) {
String data = formatter.format(pagamento.dataPagamento);
if (!retorno.contains(data.split("/")[2])) retorno.add(data.split("/")[2]);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Pega todos os meses presentes na tabela de pagamentos.
*/
public String[] getMesesPagamentos() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Pagamento> arrayPagamentos = fachada.listarPagamentos();
for (Pagamento pagamento : arrayPagamentos) {
String data = formatter.format(pagamento.dataPagamento);
if (!retorno.contains(data.split("/")[1])) retorno.add(data.split("/")[1]);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Pega todos os dias presentes na tabela de pagamentos.
*/
public String[] getDiasPagamentos() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Pagamento> arrayPagamentos = fachada.listarPagamentos();
for (Pagamento pagamento : arrayPagamentos) {
String data = formatter.format(pagamento.dataPagamento);
if (!retorno.contains(data.split("/")[0])) retorno.add(data.split("/")[0]);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Pega todos os anos presentes na tabela de Turmas.
*/
public String[] getAnosTurmas() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Turma> arrayTurmas = fachada.listarTurmas();
for (Turma turma : arrayTurmas) {
if (!retorno.contains(turma.ano + "")) retorno.add(turma.ano + "");
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Pega todos os semestres presentes na tabela de Turmas.
*/
public String[] getSemestresTurmas() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Turma> arrayTurmas = fachada.listarTurmas();
for (Turma turma : arrayTurmas) {
if (!retorno.contains(turma.semestre + "")) retorno.add(turma.semestre + "");
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Pega todos os horarios presentes na tabela de Turmas.
*/
public String[] getHorariosTurmas() {
ArrayList<String> retorno = new ArrayList<String>();
ArrayList<Turma> arrayTurmas = fachada.listarTurmas();
for (Turma turma : arrayTurmas) {
if (!retorno.contains(turma.horario + "")) retorno.add(turma.horario);
}
String[] ret = new String[retorno.size()];
return retorno.toArray(ret);
}
/*
* Trivial
*/
public void removeNivel(String codigo) {
fachada.removeNivel(new Nivel(codigo));
}
/*
* Nao tenho o id, mas creio que esses tres campos identificam unicamente. A
* data eh no formato "dd/<mes por extenso>/yyyy"
*/
public void removePagamento(String codigo) {
fachada.removePagamento(new Pagamento(Long.parseLong(codigo)));
}
/*
* Nao tenho o id, mas creio que esses quatro campos identificam unicamente.
*/
public void removeTurma(String codigo) {
fachada.removeTurma(new Turma(Integer.parseInt(codigo)));
}
/*
* Cpf é chave primária de professor. Trivial.
*/
public void removeProfessor(String cpf) {
fachada.removeProfessor(new Professor(cpf));
}
public void removeAluno(String matricula) {
fachada.removeAluno(new Aluno(matricula));
}
public String converteData(String string) {
SimpleDateFormat formatter_sql = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
String retorno = "1967-05-01";
try {
retorno = formatter_sql.format(formatter.parse(string));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return retorno;
}
public static String[] getAlunoStringArray(ArrayList<Aluno> alunos) {
String[] array = new String[alunos.size()];
for (int i = 0; i < array.length; i++) {
array[i] = alunos.get(i).matricula + " " + alunos.get(i).nome;
}
return array;
}
public static Object[] getProfessorStringArray(ArrayList<Professor> professores) {
String[] array = new String[professores.size()];
for (int i = 0; i < array.length; i++) {
array[i] = professores.get(i).CPF + " " + professores.get(i).nome;
}
return array;
}
private void validaEndereco(String endereco) throws Exception {
if (endereco.length() >= 70) throw new Exception("Endereço muito longo.");
}
private void validaCpf(String cpf) throws Exception {
boolean retorno = true;
retorno = cpf.length() == 11;
for (int i = 0; i < cpf.length() && retorno; i++) {
retorno = Character.isDigit(cpf.charAt(i));
}
if (!retorno) {
throw new Exception("CPF inválido. Deve conter 11 dígitos e apenas números.");
}
}
private void validaRg(String rg) throws Exception {
boolean retorno = true;
retorno = rg.length() == 7 || rg.length() == 0;
for (int i = 0; i < rg.length() && retorno; i++) {
retorno = Character.isDigit(rg.charAt(i));
}
if (!retorno) {
throw new Exception("RG inválido. Deve conter 7 dígitos e apenas números.");
}
}
private void validaEmail(String email) throws Exception {
Pattern pattern;
if (email.length() >= 75) throw new Exception("E-mail muito loingo");
pattern =
Pattern.compile(
"^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
+ "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$");
if (!pattern.matcher(email).matches() && email.length() > 0) { // se for
// vazia,
// deixa
// passar
if (!email.isEmpty()) throw new Exception("E-mail inválido");
}
}
private void validaTelefone(String telefone) throws Exception {
if (telefone.length() > 10) throw new Exception("Telefone muito longo.");
else {
try {
Long.parseLong(telefone);
} catch (Exception e) {
if (!telefone.isEmpty()) throw new Exception("Telefone inválido");
}
}
}
private void validaCelular(String celular) throws Exception {
if (celular.length() > 10) throw new Exception("Celular muito longo.");
else {
try {
Long.parseLong(celular);
} catch (Exception e) {
if (!celular.isEmpty()) throw new Exception("Celular inválido");
}
}
}
private void validaCelularResponsavel(String celular) throws Exception {
if (celular.length() > 10) throw new Exception("Celular do responsável muito longo.");
else {
try {
Long.parseLong(celular);
} catch (Exception e) {
if (!celular.isEmpty()) throw new Exception("Celular do responsável inválido");
}
}
}
private double validaMensalidade(String valorDaMensalidade) throws Exception {
double resultado = 0.0;
for (int i = 0; i < valorDaMensalidade.length(); i++) {
if (!Character.isDigit(valorDaMensalidade.charAt(i)) && valorDaMensalidade.charAt(i) != '.') {
throw new Exception("Caracteres inválidos no valor da mensalidade.");
}
}
try {
resultado = Double.parseDouble(valorDaMensalidade);
} catch (Exception e) {
throw new Exception("Valor da mensalidade inválido.");
}
return resultado;
}
private int validaDiaVencimento(String numero) throws Exception {
int resultado = 0;
try {
resultado = Integer.parseInt(numero);
} catch (Exception e) {
throw new Exception("Dia de vencimento inválido.");
}
return resultado;
}
private int validaDataPagamento(String numero) throws Exception {
int resultado = 0;
try {
resultado = Integer.parseInt(numero);
} catch (Exception e) {
throw new Exception("Dia de pagamento inválido.");
}
return resultado;
}
private void validaMatricula(String matricula) throws Exception {
if (matricula.isEmpty()) throw new Exception("Insira a matrícula.");
else if (matricula.length() >= 15) throw new Exception("Matrícula muito longa.");
try {
Integer.parseInt(matricula);
} catch (Exception e) {
throw new Exception("Matrícula inválida, apenas números são permitidos");
}
}
private int validaSemestre(String semestre) throws Exception {
int resultado = 0;
if (semestre.isEmpty()) throw new Exception("Insira o semestre.");
try {
resultado = Integer.parseInt(semestre);
} catch (Exception e) {
throw new Exception("Semestre inválido.");
}
return resultado;
}
private int validaAno(String ano) throws Exception {
int resultado = 0;
if (ano.isEmpty()) throw new Exception("Insira o ano.");
try {
resultado = Integer.parseInt(ano);
} catch (Exception e) {
throw new Exception("Ano inválido.");
}
return resultado;
}
private Date validaData(String data) throws Exception {
Date date = null;
try {
date = formatter.parse(data);
} catch (Exception e) {
throw new Exception("Data inválida");
}
return date;
}
private void validaDatasNascimentoEntrada(Date antes, Date depois) throws Exception {
if (antes.after(depois))
throw new Exception(
"Inconsistência: data de nascimento é posterior à data de entrada no curso.");
}
private void validaDatasNascimentoAdmissao(Date antes, Date depois) throws Exception {
if (antes.after(depois))
throw new Exception("Inconsistência: data de nascimento é posterior à data de admissão.");
}
private double validaSalario(String salario) throws Exception {
double resultado = 0.0;
for (int i = 0; i < salario.length(); i++) {
if (!Character.isDigit(salario.charAt(i)) && salario.charAt(i) != '.') {
throw new Exception("Caracteres inválidos no salário.");
}
}
try {
resultado = Double.parseDouble(salario);
} catch (Exception e) {
throw new Exception("Salário inválido.");
}
return resultado;
}
private void validaNomeAluno(String nome) throws Exception {
if (nome.isEmpty()) throw new Exception("Insira o nome.");
else if (nome.length() >= 50) throw new Exception("Nome muito longo.");
}
private void validaNomeProfessor(String nome) throws Exception {
if (nome.isEmpty()) throw new Exception("Insira o nome.");
else if (nome.length() >= 40) throw new Exception("Nome muito longo.");
}
private void validaCodigoNivel(String codigo) throws Exception {
if (codigo.isEmpty()) throw new Exception("Insira o código.");
else if (codigo.length() > 5) throw new Exception("Código muito longo.");
}
private void validaNomeNivel(String nome) throws Exception {
if (nome.isEmpty()) throw new Exception("Insira o nome.");
else if (nome.length() > 15) throw new Exception("Nome muito longo.");
}
private void validaNomeResponsavel(String nomeDoResponsavel) throws Exception {
if (nomeDoResponsavel.length() >= 50) throw new Exception("Nome do responsável muito longo.");
}
private void validaNomeMae(String nomeDaMae) throws Exception {
if (nomeDaMae.length() >= 50) throw new Exception("Nome da mãe muito longo.");
}
private void validaNomePai(String nomeDoPai) throws Exception {
if (nomeDoPai.length() >= 50) throw new Exception("Nome do pai muito longo.");
}
private double validaValorPagamento(String valorPagamento) throws Exception {
double resultado = 0.0;
for (int i = 0; i < valorPagamento.length(); i++) {
if (!Character.isDigit(valorPagamento.charAt(i)) && valorPagamento.charAt(i) != '.') {
throw new Exception("Caracteres inválidos no valor do pagamento.");
}
}
if (valorPagamento.isEmpty()) throw new Exception("Insira o valor do pagamento.");
try {
resultado = Double.parseDouble(valorPagamento);
} catch (Exception e) {
throw new Exception("Valor do pagamento inválido.");
}
return resultado;
}
}
/*
* Retorna a lista de todos os niveis, ordenada alfabeticamente.
*/
public ArrayList<Nivel> getAllNiveis() {
return fachada.listarNiveis();
}
/*
* Eh passado o nome antigo, para que seja possivel identificar a linha na
* tabela e o nome novo.
*/
public void editaNivel(String codigoOriginal, String nome, String codigo) throws Exception {
validaNomeNivel(nome);
Nivel nivel = new Nivel(codigoOriginal, nome);
fachada.editaNivel(nivel);
}
/*
* Contem todos os campos pertinentes. O campo 'matricula' eh uma chave
* primaria gerada pelo banco, nao eh pertinente aqui.
*/
public void cadastraAluno(
String nome,
String matricula,
String dataDeNascimentoDia,
String dataDeNascimentoMes,
String dataDeNascimentoAno,
String cpf,
String rg,
String telefone,
String celular,
String email,
String dataDeEntradaDia,
String dataDeEntradaMes,
String dataDeEntradaAno,
String valorDaMensalidade,
String vencimentoDaMensalidade,
String endereco,
String nomeDoPai,
String nomeDaMae,
String nomeDoResponsavel,
String celularDoResponsavel)
throws Exception {
Date dataNasc = null;
Date dataEntradaNoCurso = null;
validaNomeAluno(nome);
validaMatricula(matricula); // se for vazia, da excecao
dataNasc =
validaData(dataDeNascimentoDia + "/" + dataDeNascimentoMes + "/" + dataDeNascimentoAno);
if (!cpf.isEmpty()) validaCpf(cpf); // da excecao se for vazia
validaRg(rg); // nao da excecao se for vazia
validaTelefone(telefone); // nao da excecao se for vazia
validaCelular(celular); // nao da excecao se for vazia
validaEmail(email); // nao da excecao se for vazia
dataEntradaNoCurso =
validaData(dataDeEntradaDia + "/" + dataDeEntradaMes + "/" + dataDeEntradaAno);
validaDatasNascimentoEntrada(dataNasc, dataEntradaNoCurso);
double valorMensalidade = 0;
if (!valorDaMensalidade.isEmpty()) {
valorMensalidade = validaMensalidade(valorDaMensalidade);
}
int diaVencimentoMensalidade = 5;
if (!vencimentoDaMensalidade.isEmpty()) {
diaVencimentoMensalidade = validaDiaVencimento(vencimentoDaMensalidade);
}
validaEndereco(endereco);
validaNomePai(nomeDoPai);
validaNomeMae(nomeDaMae);
validaNomeResponsavel(nomeDoResponsavel);
validaCelularResponsavel(celularDoResponsavel); // nao da excecao se for
// vazia
Aluno aluno =
new Aluno(
matricula,
nome,
cpf,
rg,
dataNasc,
telefone,
nomeDoPai,
nomeDaMae,
nomeDoResponsavel,
celularDoResponsavel,
endereco,
valorMensalidade,
diaVencimentoMensalidade,
email,
dataEntradaNoCurso);
fachada.cadastraAluno(aluno);
}