void spanRow(HoraMinuto inicio, HoraMinuto fin, HorariosGrid nuevo) {
// traer todos los cursos de un semestre y año
List<SalonCurso> horarios = new ArrayList();
for (Curso curso : cursoController.getItems()) {
horarios.addAll(curso.getSalonesCurso());
}
// List<SalonCurso> horarios = cursoController.getSelected().getSalonesCurso();
//
for (SalonCurso sc : horarios) {
HoraMinuto scInicio = new HoraMinuto();
scInicio.transformarStringEnHoraMinuto(sc.getHoraInicio());
HoraMinuto scfin = new HoraMinuto();
scfin.transformarStringEnHoraMinuto(sc.getHoraFin());
if (scInicio.compare(inicio) == 0) {
if (scfin.compare(fin) == 1) {
setDiasHorario(nuevo, sc);
setSpanrow(nuevo, sc, inicio, fin, scInicio, scfin);
} else {
setDiasHorario(nuevo, sc);
}
}
if (scInicio.compare(inicio) == -1 && (scfin.compare(fin) == 1 || scfin.compare(fin) == 0)) {
desabilitarCol(nuevo, sc);
} // else abilitarCol(nuevo, sc);
}
}
private void printCurso(Curso c) {
int rowNum;
XSSFSheet sheet =
report.createSheet("Curso " + c.getNombre() + (c.getIsMixto() ? "(Mixto)" : "(No Mixto)"));
rowNum = 0;
for (Alumno a : c.getAlumnos()) {
XSSFRow row = sheet.createRow(rowNum++);
int cellNum = 0;
if (rowNum == 1) {
XSSFCell cell = row.createCell(cellNum++);
cell.setCellValue("Id");
cell = row.createCell(cellNum++);
cell.setCellValue("Apellido");
cell = row.createCell(cellNum++);
cell.setCellValue("Nombre");
cell = row.createCell(cellNum++);
cellNum = 0;
row = sheet.createRow(rowNum++);
}
XSSFCell cell = row.createCell(cellNum++);
cell.setCellValue(a.getId());
cell = row.createCell(cellNum++);
cell.setCellValue(a.getApellido());
cell = row.createCell(cellNum++);
cell.setCellValue(a.getNombres());
cell = row.createCell(cellNum++);
}
}
public static Curso buscarCurso(int numero) {
Curso cur = null;
if (!cursos.isEmpty()) {
for (Iterator<Curso> it = cursos.iterator(); it.hasNext(); cur = it.next()) {
if (cur.getNumero() == numero) return cur;
}
}
return cur;
}
@GET
@Path("/consultar")
@Produces({MediaType.APPLICATION_JSON})
public List<Curso> consultarCurso(@QueryParam(value = "matricula") String matricula) {
return Curso.consultarPorUsuario(matricula);
}
public static Collection<Curso> getAll() throws ClassNotFoundException, SQLException {
Collection<Curso> colCurso = new ArrayList<Curso>();
ResultSet rs = null;
Conexao.initConnection();
String prepare = "Select * from curso;";
PreparedStatement psmt = Conexao.prepare(prepare);
rs = psmt.executeQuery();
while (rs.next()) {
Curso curso = new Curso();
colCurso.add(curso.load(rs));
}
Conexao.closeConnection();
return colCurso;
}
public static Curso _buscarCurso(String sigla) throws ClassNotFoundException, SQLException {
ResultSet rs = null;
Conexao.initConnection();
Curso curso = null;
String prepare = "Select * from curso where sigla = ?;";
PreparedStatement psmt = Conexao.prepare(prepare);
psmt.setString(1, sigla);
rs = psmt.executeQuery();
if (rs.next()) {
Curso _curso = new Curso();
curso = _curso.load(rs);
}
rs.close();
Conexao.closeConnection();
return curso;
}
@Override
public Insert getInsert() {
return Insert.into("BANCO.ALUNO")
.value("NOME", nome)
.value("MATRICULA", matricula)
.value("CURSO_ID", curso.getId())
.value("DATA_CRIACAO", dataDeCriacao)
.onGeneratedKey(
new GeneratedKeyCallback() {
@Override
public void set(ResultSet rs) throws SQLException {
id = rs.next() ? rs.getInt(1) : 0;
}
});
}
@Test
public void testeMatricula() {
try {
curso1 = testes.criarCurso(001, "SI");
Iterator<Curso> itC = testes.getCursosIterator();
Curso c = null;
while (itC.hasNext()) {
Curso curso = itC.next();
if (curso.getCodigo() == 001 && curso.getNome().equals("SI")) {
c = curso;
}
}
assertEquals(c.getCodigo(), 001);
assertEquals(c.getNome(), "SI");
} catch (SCARuntimeException e) {
assertEquals("Ja existe Curso com esse codigo", e.getMessage());
} catch (SCAException e) {
assertEquals(e.getMessage(), "Erro no arquivo");
}
}
public static void main(String[] args) {
conex = new Conexao();
CriteriaBuilder builder = conex.getEm().getCriteriaBuilder();
// CONSULTA 1
// Todos os cursos com ch > 3600
CriteriaQuery<Curso> query = builder.createQuery(Curso.class);
Root<Curso> curso = query.from(Curso.class);
Predicate pred = builder.gt(curso.get("cargaHoraria"), 3600);
query.select(curso);
query.where(pred);
TypedQuery<Curso> tpQuery = conex.getEm().createQuery(query);
List<Curso> CursoList = tpQuery.getResultList();
System.out.println();
System.out.println("***************************************");
System.out.println("Todos os cursos com carga horaria maior que 3600:");
System.out.println();
for (Curso c : CursoList) {
System.out.println(c.getNomeCurso() + " = Carga horaria: " + c.getCargaHoraria());
}
System.out.println("---------------------------------------");
// CONSULTA 2
// Todos as turmas do periodo da tarde e noite
CriteriaQuery<Turma> criteriaQuery2 = builder.createQuery(Turma.class);
Root<Turma> turma = criteriaQuery2.from(Turma.class);
Predicate pred1 = builder.equal(turma.get("periodo"), "Noturno");
Predicate pred2 = builder.equal(turma.get("periodo"), "Vespertino");
Predicate p1orP2 = builder.or(pred1, pred2);
criteriaQuery2.select(turma);
criteriaQuery2.where(p1orP2);
TypedQuery<Turma> query2 = conex.getEm().createQuery(criteriaQuery2);
List<Turma> turmasConsulta2 = query2.getResultList();
System.out.println();
System.out.println("***************************************");
System.out.println("Todos as turmas do periodo vespertino e noturno:");
System.out.println();
for (Turma turm : turmasConsulta2) {
System.out.println(
"Turma: "
+ turm.getIdTurma()
+ " - data de inicio: "
+ turm.getDataInicio()
+ " - data de termino: "
+ turm.getDataTermino());
}
System.out.println("---------------------------------------");
// CONSULTA 3
// todas as turmas com situação = "Aberta" e curso = "Ciência da Computação“;
CriteriaQuery<Turma> criteriaQuery3 = builder.createQuery(Turma.class);
Root<Turma> turma2 = criteriaQuery3.from(Turma.class);
Join<Turma, Curso> cursoJoin = turma2.join("curso");
Predicate pred3 = builder.equal(turma2.get("situacao"), true);
Predicate pred4 = builder.equal(cursoJoin.get("nomeCurso"), "Ciencias da Computacao");
Predicate p3andP4 = builder.and(pred3, pred4);
criteriaQuery3.select(turma2);
criteriaQuery3.where(p3andP4);
TypedQuery<Turma> query3 = conex.getEm().createQuery(criteriaQuery3);
List<Turma> turmasConsulta3 = query3.getResultList();
System.out.println();
System.out.println("***************************************");
System.out.println("Todos as turmas abertas do curso Ciencias da Computacao:");
System.out.println();
for (Turma turm : turmasConsulta3) {
System.out.println(
"Turma: "
+ turm.getIdTurma()
+ ", Curso: "
+ turm.getCurso().getNomeCurso()
+ " - data de inicio: "
+ turm.getDataInicio()
+ " - data de termino: "
+ turm.getDataTermino());
}
System.out.println("---------------------------------------");
// CONSULTA 4
// todos os professores que lecionam no curso de "Bacharelado em Tecnologia da Informação“;
CriteriaQuery<Professor> c4 = builder.createQuery(Professor.class);
Root<Professor> prof = c4.from(Professor.class);
Join<Professor, Turma> profTurma = prof.join("turmas");
Join<Turma, Curso> turmaCurso = profTurma.join("curso");
Predicate p1 =
builder.equal(turmaCurso.get("nomeCurso"), "Bacharelado em Tecnologia da Informacao");
c4.select(prof);
c4.where(p1);
TypedQuery<Professor> q4 = conex.getEm().createQuery(c4);
List<Professor> profsC4 = q4.getResultList();
System.out.println();
System.out.println("***************************************");
System.out.println("Todos os professores do Bacharelado em Tecnologia da Informação");
System.out.println();
for (Professor prof4 : profsC4) {
System.out.println("Professor: " + prof4.getNome() + ", matricula: " + prof4.getMatricula());
}
System.out.println("---------------------------------------");
// CONSULTA 5
// todos os professores de turmas com periodo = Tarde e com cursos de carga horária > 4000
CriteriaQuery<Professor> c5 = builder.createQuery(Professor.class);
Root<Professor> prof5 = c5.from(Professor.class);
Join<Professor, Turma> profTurma5 = prof5.join("turmas");
Join<Turma, Curso> turmaCurso5 = profTurma5.join("curso");
Predicate p1c5 = builder.equal(profTurma5.get("periodo"), "Vespertino");
Predicate p2c5 = builder.gt(turmaCurso5.get("cargaHoraria"), 4000);
Predicate pgeral = builder.and(p1c5, p2c5);
c5.select(prof5);
c5.where(pgeral);
c5.distinct(true);
TypedQuery<Professor> q5 = conex.getEm().createQuery(c5);
List<Professor> profsC5 = q5.getResultList();
System.out.println();
System.out.println("***************************************");
System.out.println(
"Todos os professores de turmas com periodo = Tarde e com cursos de carga horária > 4000");
System.out.println();
for (Professor p5 : profsC5) {
System.out.println("Professor: " + p5.getNome() + ", matricula: " + p5.getMatricula());
}
System.out.println("---------------------------------------");
/*
http://www.objectdb.com/java/jpa/query/jpql/logical
*/
}
public Curso addCurso(Curso curso) {
getCursos().add(curso);
curso.setInformacionCurso(this);
return curso;
}
public Curso removeCurso(Curso curso) {
getCursos().remove(curso);
curso.setInformacionCurso(null);
return curso;
}
