Subversion Repositories bacoAlunos

package pt.estgp.estgweb.services.sigesimports;

import jomm.dao.impl.AbstractDao;

import jomm.utils.StringsUtils;

import org.apache.log4j.Logger;

import org.hibernate.HibernateException;

import org.hibernate.StaleStateException;

import pt.estgp.estgweb.utils.Globals;

import pt.estgp.estgweb.domain.*;

import pt.estgp.estgweb.domain.dao.DaoFactory;

import pt.estgp.estgweb.services.common.CommonServicesManager;

import pt.estgp.estgweb.services.email.SendEmailService;

import pt.estgp.estgweb.services.expceptions.ServiceException;

import pt.estgp.estgweb.services.jobs.ServiceJob;

import pt.estgp.estgweb.services.logresults.ILogMessages;

import pt.estgp.estgweb.services.logresults.LogMessageTypeEnum;

import pt.estgp.estgweb.services.logresults.impl.DefaultLogMessage;

import pt.estgp.estgweb.services.logresults.impl.DefaultLogMessages;

import pt.estgp.estgweb.services.sigesimports.oracle.dao.AlunoDao;

import pt.estgp.estgweb.services.sigesimports.oracle.dao.TurmaDao;

import pt.estgp.estgweb.services.sigesimports.oracle.dao.connection.ConnectionManager;

import pt.estgp.estgweb.services.sigesimports.oracle.domain.Aluno;

import pt.estgp.estgweb.services.sigesimports.oracle.domain.AlunoHistorico;

import pt.estgp.estgweb.services.sigesimports.oracle.domain.Disciplina;

import pt.estgp.estgweb.services.sigesimports.oracle.domain.Nacionalidade;

import pt.estgp.estgweb.utils.ConfigProperties;

import pt.estgp.estgweb.utils.Email;

import pt.utl.ist.berserk.logic.serviceManager.IService;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.text.MessageFormat;

import java.util.*;

/**

 * @author Jorge Machado

 * @date 11/May/2008

 * @time 12:51:32

 * @see pt.estgp.estgweb

 */

public class ImportStudentsService extends ServiceJob implements IService

{

    private static final 1.5.0/docs/api/java/util/logging/Logger.html">Logger logger = 1.5.0/docs/api/java/util/logging/Logger.html">Logger.getLogger(ImportStudentsService.class);

    private static final int MAX_COMMIT = 5;

    int studentsMerged = 0;

    int studentsNew = 0;

    int studentsZeroUnits = 0;

    int unitsNotFound = 0;

    int unitsNotFoundTurma = 0;

    int unitsRemovedToStudents = 0;

    int unitsLocalAddedNotRemoved = 0;

    int unitsLocallyRemovedNotAdded = 0;

    int unitsRepeated = 0;

    int alunosFound = 0;

    int studentsChangeBI = 0;

    int unitsAddedToStudents = 0;

    int alunosErasmusCadeirasEcontradas = 0;

    int alunosSemTurmaParaAUnidades = 0;

    int turmaMoreThanOneRegularCourse = 0;

    int unidadesProcuradasNumCursoAleatorio = 0;

    List<String> turmasMoreThanOneCourse = new ArrayList<String>();

    int turmasWrongSubscriptions = 0;

    int estudantesDesaparecidosDoSigesNesteAno = 0;

    int estudantesComCadeirasSemTurma = 0;

    int turmasComCodigoNullRemovidas = 0;

    int unidadesSoComAlunosExtra = 0;

    int turmasVindasANullDoSIGES = 0;

    int turmasVindasANullDoSIGESEncontradasNoutroCampo = 0;

    //Vasco da Gama

    //Cadeiras a Vulso

    //Erasmus

    //disciplinas a vulso ESS

    static 1.5.0/docs/api/java/lang/Integer.html">Integer[] cursosFicticios = null;

    static boolean studentComUnidadesRepetidas = false;

    public ILogMessages run(1.5.0/docs/api/java/lang/String.html">String year,int institutionCode) throws ServiceException

    {

        studentsMerged = 0;

        studentsNew = 0;

        studentsZeroUnits = 0;

        unitsNotFound = 0;

        unitsNotFoundTurma = 0;

        unitsRemovedToStudents = 0;

        unitsLocalAddedNotRemoved = 0;

        unitsLocallyRemovedNotAdded = 0;

        alunosFound = 0;

        studentsChangeBI = 0;

        unitsAddedToStudents = 0;

        alunosErasmusCadeirasEcontradas = 0;

        unitsRepeated = 0;

        turmaMoreThanOneRegularCourse = 0;

        turmasMoreThanOneCourse = new ArrayList<String>();

        turmasWrongSubscriptions = 0;

        estudantesDesaparecidosDoSigesNesteAno = 0;

        estudantesComCadeirasSemTurma = 0;

        turmasComCodigoNullRemovidas = 0;

        unidadesSoComAlunosExtra = 0;

        unidadesProcuradasNumCursoAleatorio = 0;

        alunosSemTurmaParaAUnidades = 0;

        turmasVindasANullDoSIGES = 0;

        ImportCourseService.resetCourseYearTurmaPolicy();

        1.5.0/docs/api/java/lang/String.html">String activeImportYearParaVerificacaoDePropinasEmDia = DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear();

        1.5.0/docs/api/java/lang/String.html">String msgS = "STARTING STUDENTS IMPORT SERVICE FOR YEAR: " + year;

        serviceLogInfo(msgS);

        logger.info(msgS);

        DefaultLogMessages logMessages = new DefaultLogMessages();

        logMessages.addMessage(new DefaultLogMessage("import.students", LogMessageTypeEnum.INFO, "instituicao " + institutionCode));

        try

        {

            AlunoDao service = AlunoDao.getInstance();

            1.5.0/docs/api/java/sql/Connection.html">Connection conn = ConnectionManager.openConnection();

            HashMap<Integer,Nacionalidade> nacionalidades = service.loadNacionalidades(conn);

            /**

             * Carrega alunos do SIGES com cadeiras no ano requerido

             */

            List<Integer> codigos = service.loadCodigosAlunos(institutionCode, year,conn);

            /**

             * Este método vai procurar alunos no BACO neste ano que não vieram do SIGES

             * Os alunos que não vieram da extração do SIGES e terão de ser consistidos

             * pois as suas unidades ter desaparecido todas de uma vez e vão aqui ficar penduradas

             * Se foram adicionadas manualmente então nao serao removidas

             */

            removerUnidadesDosDesaparecidosDoSiges(year, institutionCode, codigos);

            int i = 1;

            for (1.5.0/docs/api/java/lang/Integer.html">Integer c : codigos)

            {

                alunosFound++;

                if (i++ >= MAX_COMMIT)

                {

                    i = 0;

                    setProgress((int) ((((float) alunosFound) / ((float) codigos.size())) * 0.95f * 100.0f));

                    conn.close();

                    commitPartially();

                    conn = ConnectionManager.openConnection();

                }

                Aluno alunoSiges = service.loadInscrito(c,institutionCode, year,conn);

                if(alunoSiges.getCodigo()==15726)

                    1.5.0/docs/api/java/lang/System.html">System.out.println("");

                Student s = loadStudent(alunoSiges,nacionalidades);

                boolean newUser = false;

                if(s.getId() <= 0)

                {

                    i = MAX_COMMIT+1; //Para fazer commit já na póxima iteração

                    DaoFactory.getStudentDaoImpl().save(s);

                    newUser = true;

                }

                //if(alunoSiges.getCodigo() == 11211)

                //    System.out.println("Aqui");

                persist(alunoSiges, s, newUser,year,institutionCode,activeImportYearParaVerificacaoDePropinasEmDia,logMessages,service,nacionalidades);

                if(studentComUnidadesRepetidas)

                    unitsRepeated++;

                if (newUser)

                {

                    CommonServicesManager.getInstance().adviseNew(s);

                }

                else

                {

                    //Advising CommonsServicesManager before change password at this time 03/2015 this does not do anything important

                    1.5.0/docs/api/java/lang/String.html">String password = s.getPassword();

                    s.setPassword(null);

                    CommonServicesManager.getInstance().adviseUpdate(s);

                    s.setPassword(password);

                }

            }

            logMessages.addMessage(new DefaultLogMessage("import.students.consisting.turmas", LogMessageTypeEnum.INFO));

            logger.info("Consisting turma students");

            serviceLogInfo("Consisting turma students");

            setProgress(95);

            commitPartially();

            /**

             * Este metodo vai remover inconsistencias de alunos que têm unidades em Turmas

             * e depois não as têm na lista de unidades subscritas

             * TURMAS SEPARADAS_ANALISE: Usa codigos de Turma do Baco não é necessario comparacoes por codigos siges

             * logo nao e afetado com pelos detalhes das turmas separadas

             */

            removeUnitsFromTurmaSubscriptionsThatAreNotInCourseUnitSubscriptions(year,institutionCode,logMessages);

            /**

             * Este metodo e apenas uma verificação de consistência

             * O normal será não produzir resultados, pois caso os produza significa que os alunos não foram removidos das

             * cadeiras tal como deveriam ter sido

             * ou então são alunos adicionados manualmente às cadeiras

             * TURMAS SEPARADAS_ANALISE: Usa codigos de Turma do Baco não é necessario comparacoes por codigos siges

             * logo nao e afetado com pelos detalhes das turmas separadas

             */

            obterAlunosInconsitentesComCadeirasSemTurma(codigos,year,institutionCode);

            /**

             * Turmas penduradas com código vazio serão removidas

             */

            eliminarTurmasInvalidas(year,logMessages);

            logMessages.addMessage(new DefaultLogMessage("import.students.terminating", LogMessageTypeEnum.INFO));

            logger.info("terminating student import");

            serviceLogInfo("terminating student import");

            conn.close();

        }

        catch(StaleStateException e)

        {

            AbstractDao.getCurrentSession().getTransaction().rollback();

            AbstractDao.getCurrentSession().beginTransaction();

            logger.error(e,e);

            logMessages.addMessage(new DefaultLogMessage("import.error",e.toString(), "see log for details", LogMessageTypeEnum.ERROR));

            serviceLogError("Rolling back will lost previous updates: " + e.toString(),e);

            sendNotificationAdmin("Erro de importacao de alunos",e.toString());

        }

        catch(HibernateException e)

        {

            AbstractDao.getCurrentSession().getTransaction().rollback();

            AbstractDao.getCurrentSession().beginTransaction();

            logger.error(e,e);

            logMessages.addMessage(new DefaultLogMessage("import.error",e.toString(), "see log for details", LogMessageTypeEnum.ERROR));

            serviceLogError("Rolling back will lost previous updates: " + e.toString(),e);

            sendNotificationAdmin("Erro de base de dados importacao de alunos, provavelmente chave errada, corrigir no MySql",e.toString());

        }

        catch(1.5.0/docs/api/java/lang/Throwable.html">Throwable e)

        {

            logger.error(e,e);

            logMessages.addMessage(new DefaultLogMessage("import.error",e.toString(), "see log for details", LogMessageTypeEnum.ERROR));

            serviceLogError(e.toString(),e);

            sendNotificationAdmin("Erro de importacao de alunos",e.toString());

        }

        serviceLogInfo("############################");

        serviceLogInfo("############################");

        serviceLogInfo("#Students found: " + alunosFound);

        serviceLogInfo("#Students New: " + studentsNew);

        serviceLogInfo("#Students Merged: " + studentsMerged);

        serviceLogInfo("#Students Zero Units: " + studentsZeroUnits);

        serviceLogInfo("#Units not found: " + unitsNotFound);

        serviceLogInfo("#Units not found in real course (turma ok): " + unitsNotFoundTurma);

        serviceLogInfo("#Units added to Students: " + unitsAddedToStudents);

        serviceLogInfo("#Units removed to Students: " + unitsRemovedToStudents);

        serviceLogInfo("#Units not Removed because localy added: " + unitsLocalAddedNotRemoved);

        serviceLogInfo("#Units not Added because localy removed: " + unitsLocallyRemovedNotAdded);

        serviceLogInfo("#Alunos com Unidades repetidas: " + unitsRepeated);

        serviceLogWarn("#ERASMUS Sum Subscriptions Replaced: " + alunosErasmusCadeirasEcontradas);

        if(turmasVindasANullDoSIGES > 0)

        {

            serviceLogError("######!!!!!Turmas a NULL NO SIGES " + turmasVindasANullDoSIGES + " - POSSIVEL CAMPO DE TURMA diferente de TURMA_T na tabela T_INSCR, procure no LOG pela frase: (turmasVindasANullDoSIGES) ");

        }

        if(turmasVindasANullDoSIGESEncontradasNoutroCampo > 0)

        {

            serviceLogInfo("######!!!!!Foram no entanto encontradas noutro campo P L TP O C S E: " + turmasVindasANullDoSIGESEncontradasNoutroCampo + " turmas ver mais info no LOG");

        }

        if(alunosSemTurmaParaAUnidades > 0)

        {

            serviceLogError("######!!!!!Alunos com Unidade mas sem Turma: " + alunosSemTurmaParaAUnidades + " -> verificar situação junto da administração de software do PAE - procure no LOG pela frase:(alunosSemTurmaParaAUnidades)");

        }

        if(unidadesProcuradasNumCursoAleatorio > 0)

            serviceLogInfo("######!!!!!Unidades atribuidas com curso aleatoriamente escolhido derivado a duvidas: " + unidadesProcuradasNumCursoAleatorio + " (procurar por \"tem mais de um curso vamos procurar num qualquer\")");

        if(turmaMoreThanOneRegularCourse > 0)

        {

            serviceLogWarn("#########!!!!!!!ATENÇÃO TURMAS COM MAIS DE UM CURSO: " + turmaMoreThanOneRegularCourse);

            serviceLogWarn(turmasMoreThanOneCourse.toString());

        }

        if(turmasWrongSubscriptions > 0)

        {

            serviceLogWarn("Inscrições em TURMAS sem correspondencia nas disciplinas foram removidas: " + turmasWrongSubscriptions);

        }

        else

        {

            serviceLogInfo("CHECK OK - Todas as TURMAS com correspondencia nas disciplinas: ");

        }

        if(estudantesComCadeirasSemTurma > 0)

        {

            serviceLogWarn("########!!!!!!!Estudantes com cadeiras sem TURMA no BACO: " + estudantesComCadeirasSemTurma);

        }

        else

        {

            serviceLogInfo("CHECK TURMAS REVERSE OK - Todas as disciplinas subsescritas com turmas verificadas");

        }

        if(estudantesDesaparecidosDoSigesNesteAno > 0)

        {

            serviceLogWarn("########!!!!!!!Estudantes que desapareceram do Siges neste ano e tinham cadeiras no BACO: " + estudantesDesaparecidosDoSigesNesteAno);

        }

        else

        {

            serviceLogInfo("CHECK DESAPARECIDOS OK - Não existem estudantes desaparecidos");

        }

        if(turmasComCodigoNullRemovidas > 0)

        {

            serviceLogWarn("########Turmas com codigo vazio removidas:" + turmasComCodigoNullRemovidas);

        }

        else

        {

            serviceLogInfo("CHECK OK zero Turmas com codigo vazio");

        }

        if(unidadesSoComAlunosExtra > 0)

        {

            //Acontece com cadeiras criadas especialmente para alunos de erasmus

            serviceLogInfo("########Unidades sem Curso Real não criadas:" + unidadesSoComAlunosExtra);

            serviceLogInfo("procure no log por: \"Problema Encontrado Turma não tem Curso Real\"");

        }

        logger.info("############################");

        logger.info("############################");

        logger.info("#Students found: " + alunosFound);

        logger.info("#Students New: " + studentsNew);

        logger.info("#Students Merged: " + studentsMerged);

        logger.info("#Students Zero Units: " + studentsZeroUnits);

        logger.info("#Units not found: " + unitsNotFound);

        logger.info("#Units not found in real course (turma ok): " + unitsNotFoundTurma);

        logger.info("#Units added to Students: " + unitsAddedToStudents);

        logger.info("#Units removed to Students: " + unitsRemovedToStudents);

        logger.info("#Units not Removed because localy added: " + unitsLocalAddedNotRemoved);

        logger.info("#Units not Added because localy removed: " + unitsLocallyRemovedNotAdded);

        logger.info("#Alunos com Unidades repetidas: " + unitsRepeated);

        logger.info("#ERASMUS Sum Subscriptions Replaced: " + alunosErasmusCadeirasEcontradas);

        if(turmasVindasANullDoSIGES > 0)

        {

            logger.error("######!!!!!Turmas a NULL NO SIGES " + turmasVindasANullDoSIGES + " - POSSIVEL CAMPO DE TURMA diferente de TURMA_T na tabela T_INSCR procure no LOG pela frase: (turmasVindasANullDoSIGES) ");

        }

        if(turmasVindasANullDoSIGESEncontradasNoutroCampo > 0)

        {

            logger.info("######!!!!!Foram no entanto encontradas noutro campo P L TP O C S E: " + turmasVindasANullDoSIGESEncontradasNoutroCampo + " turmas ver mais info no LOG");

        }

        if(alunosSemTurmaParaAUnidades > 0)

        {

            logger.error("######!!!!!Alunos com Unidade mas sem Turma: " + alunosSemTurmaParaAUnidades + " -> verificar situação junto da administração de software do PAE - procure no LOG pela frase:(alunosSemTurmaParaAUnidades)");

        }

        if(unidadesProcuradasNumCursoAleatorio > 0)

            logger.warn("######!!!!!Unidades atribuidas com curso aleatoriamente escolhido derivado a duvidas: " + unidadesProcuradasNumCursoAleatorio + " (procurar por \"tem mais de um curso vamos procurar num qualquer\")");

        if(turmaMoreThanOneRegularCourse > 0)

        {

            logger.warn("#########!!!!!!!ATENÇÃO TURMAS COM MAIS DE UM CURSO: " + turmaMoreThanOneRegularCourse);

            logger.warn(turmasMoreThanOneCourse.toString());

        }

        if(turmasWrongSubscriptions > 0)

        {

            logger.warn("Inscrições em TURMAS sem correspondencia nas disciplinas: " + turmasWrongSubscriptions);

        }

        else

        {

            logger.info("CHECK TURMAS OK - Todas as TURMAS com correspondencia nas disciplinas subscritas");

        }

        if(estudantesComCadeirasSemTurma > 0)

        {

            logger.warn("########!!!!!!!Estudantes com cadeiras sem TURMA no BACO: " + estudantesComCadeirasSemTurma);

        }

        else

        {

            logger.info("CHECK TURMAS REVERSE OK - Todas as disciplinas subsescritas com turmas verificadas");

        }

        if(estudantesDesaparecidosDoSigesNesteAno > 0)

        {

            logger.warn("########!!!!!!!Estudantes que desapareceram do Siges neste ano e tinham cadeiras no BACO: " + estudantesDesaparecidosDoSigesNesteAno);

        }

        else

        {

            logger.info("CHECK DESAPARECIDOS OK - Não existem estudantes desaparecidos");

        }

        if(turmasComCodigoNullRemovidas > 0)

        {

            logger.warn("########Turmas com codigo vazio removidas:" + turmasComCodigoNullRemovidas);

        }

        else

        {

            logger.info("CHECK OK zero Turmas com codigo vazio");

        }

        if(unidadesSoComAlunosExtra > 0)

        {

            logger.warn("########Unidades sem Curso Real não criadas:" + unidadesSoComAlunosExtra);

            logger.warn("procure no log por: \"Problema Encontrado Turma não tem Curso Real\"");

        }

        if(studentsChangeBI>0)

        {

            serviceLogInfo("#>>>>>AVISO AVISO<<<<<<<<<: ");

            serviceLogInfo("#>>>>>AVISO AVISO<<<<<<<<<: ");

            serviceLogInfo("#>>>>>NUMEROS DE ALUNOS MUDARAM DE BI<<<<<<<<<: CONSULTAR LOG");

            serviceLogInfo("#CODIGO SIGES COM BIs DIFERENTES:" + studentsChangeBI);

            logger.info("#>>>>>AVISO AVISO<<<<<<<<<: ");

            logger.info("#>>>>>AVISO AVISO<<<<<<<<<: ");

            logger.info("#>>>>>NUMEROS DE ALUNOS MUDARAM DE BI<<<<<<<<<: CONSULTAR LOG");

            logger.info("#CODIGO SIGES COM BIs DIFERENTES:" + studentsChangeBI);

        }

        setProgress(100);

        return logMessages;

    }

    private void eliminarTurmasInvalidas(1.5.0/docs/api/java/lang/String.html">String year,DefaultLogMessages logMessages) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {

        1.5.0/docs/api/java/sql/PreparedStatement.html">PreparedStatement ps = AbstractDao.getCurrentSession().connection().prepareStatement(

                "select courseunitturma.id as id, courseunit.code as code, courseunit.name as name, courseunit.coursename as coursename  from courseunitturma " +

                        "join courseunit on courseunit.id = courseunitturma.courseunit " +

                        "where courseunit.importYear = \"" + year + "\" and (courseunitturma.turma is null or courseunitturma.turma = \"\")");

        1.5.0/docs/api/java/sql/ResultSet.html">ResultSet rs = ps.executeQuery();

        while(rs.next())

        {

            CourseUnitTurma cut = DaoFactory.getCourseUnitTurmaDaoImpl().load(rs.getLong("id"));

            /****logging*****/

            turmasComCodigoNullRemovidas++;

            1.5.0/docs/api/java/lang/String.html">String msg = "Removing courseunit turma:" + cut.getId() + " from unit:" + rs.getString("code") + ":" + rs.getString("name") + "(" + rs.getString("coursename") + ")"  + " has null turma";

            logger.warn(msg);

            logMessages.addMessage(new DefaultLogMessage("import.warning",LogMessageTypeEnum.WARNING,msg));

            serviceLogWarn(msg);

            /****logging*****/

            if(cut.getStudents().size() > 0)

            {

                Iterator<StudentImpl> sd = cut.getStudents().iterator();

                while(sd.hasNext())

                {

                    StudentImpl s = sd.next();

                    /****logging*****/

                    msg = "Removing student " + s.getSigesCode() + " from turma:" + cut.getId() + " from unit:" + rs.getString("code") + ":" + rs.getString("name") + "(" + rs.getString("coursename") + ")"  + " has null turma";

                    logger.warn(msg);

                    logMessages.addMessage(new DefaultLogMessage("import.warning",LogMessageTypeEnum.WARNING,msg));

                    serviceLogWarn(msg);

                    /****logging*****/

                    s.getTurmas().remove(cut);

                    sd.remove();

                }

            }

            cut.getCourseUnit().getTurmas().remove(cut);

            cut.setCourseUnit(null);

        }

        rs.close();

        ps.close();

    }

    private Student loadStudent(Aluno alunoSiges,HashMap<Integer,Nacionalidade> nacionalidades)

    {

        Student s = null;

        User u = DaoFactory.getUserDaoImpl().loadByUsernameOrSigesCode(alunoSiges.getCodigo().intValue());

        boolean newUser = false;

        studentComUnidadesRepetidas = false;

        if(u != null && !(u instanceof Student))

        {

            /*****logging*******/

            1.5.0/docs/api/java/lang/String.html">String msgS = "Student " + u.getUsername() + " already exist in system but is not a Student is a standard USER, will merge both users";

            studentsMerged++;

            serviceLogWarn(msgS);

            logger.warn(msgS);

            /*****logging*******/

            DaoFactory.getUserDaoImpl().delete(u);

            /*****logging*******/

            msgS = "Student " + u.getUsername() + "1";

            logger.warn(msgS);

            serviceLogWarn(msgS);

            /*****logging*******/

            AbstractDao.getCurrentSession().getTransaction().commit();

            AbstractDao.getCurrentSession().beginTransaction();

            /*****logging*******/

            msgS = "Student " + u.getUsername() + "2";

            logger.warn(msgS);

            serviceLogWarn(msgS);

            /*****logging*******/

            s = DomainObjectFactory.createStudentImpl();

        }

        else if(u != null)

        {

            s = DaoFactory.getStudentDaoImpl().load(u.getId());

        }

        if (s == null)

        {

            s = DomainObjectFactory.createStudentImpl();

        }

        return s;

    }

    /**

     * Obter os alunos que tem cadeiras na lista de subscribed units que depois não têm uma associação com turma

     * associada na CourseUnitTurma

     * Este metodo usa dois selects

     * O interior vai ler todas as possibilidades de unidade, estudante olhando para a tabela das turmas

     * O exterior seleciona todas as ocorrencias da subscribedUnits e verifica com um left join quais

     * não verificam correspondencia no select interior

     * Assim ficamos a saber os alunos que estão subscritos numa unidade mas que não estão subscritos

     * numa Turma com essa mesma unidade

     * @param codigos

     * @return

     * @throws SQLException

     */

    private List<Integer> obterAlunosInconsitentesComCadeirasSemTurma(List<Integer> codigos,1.5.0/docs/api/java/lang/String.html">String year,int institutionCode) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {

        /**EXTRA PARA DETECTAR ALUNOS COM CADEIRAS SEM TURMA***/

        1.5.0/docs/api/java/sql/PreparedStatement.html">PreparedStatement ps= AbstractDao.getCurrentSession().connection().prepareStatement(

                "select distinct (user.sigesCode)\n" +

                        "from subscribedunits \n" +

                        "join courseunit on subscribedunits.courseUnitId = courseunit.id\n" +

                        "join course on courseunit.course = course.id\n" +

                        "join course_department on course.area = course_department.sigla\n" +

                        "join course_school on course_department.school_id = course_school.id\n" +

                        "join user on user.id = subscribedunits.studentid\n" +

                        "left join (\n" +

                        "select subscribedturmaunits.studentId,courseunitturma.courseUnit,courseunitturma.turma from subscribedturmaunits \n" +

                        "join courseunitturma on courseunitturma.id = subscribedturmaunits.courseunitturmaid\n" +

                        "join courseunit on courseunit.id = courseunitturma.courseUnit\n" +

                        "where courseunit.importYear=\"" + year + "\") as turmas\n" +

                        "on turmas.studentId = subscribedunits.studentId and turmas.courseUnit = subscribedunits.courseunitid\n" +

                        "where courseunit.importYear=\"" + year + "\" and course_school.institutionalCode = \"" + institutionCode + "\" and turmas.studentId is null ");

        1.5.0/docs/api/java/sql/ResultSet.html">ResultSet rs = ps.executeQuery();

        List<Integer> longs = new ArrayList<Integer>();

        //alunosSemTurmaParaAUnidades = longs.size();

        while(rs.next())

        {

            longs.add(rs.getInt("sigesCode"));

        }

        alunosSemTurmaParaAUnidades = longs.size();

        rs.close();

        ps.close();

        if(longs.size() > 0)

        {

            1.5.0/docs/api/java/lang/String.html">String msgS = "(alunosSemTurmaParaAUnidades) ATENÇÃO_ Existem estudantes no BACO com unidades sem turma respectiva ano: " + year + " institution:" + institutionCode + " possiveis adicionados manualmente, confirmar";

            serviceLogWarn(msgS);

            logger.warn(msgS);

            msgS = "";

            for (1.5.0/docs/api/java/lang/Integer.html">Integer c : longs)

            {

                msgS+=c + ", ";

            }

            serviceLogWarn(msgS);

            logger.warn(msgS);

        }

        else

        {

            1.5.0/docs/api/java/lang/String.html">String msgS = "OK check - Estudantes no BACO todos com respectiva turma ano: " + year + " institution:" + institutionCode + " possiveis adicionados manualmente, confirmar";

            serviceLogInfo(msgS);

            logger.info(msgS);

        }

        return longs;

    }

    /**

     * Este métido vai consistir os alunos que não eram tratados porque não vinham do SIGES logo não constavam do

     * ciclo

     * @param year

     * @param institutionCode

     * @param codigos

     */

    private void removerUnidadesDosDesaparecidosDoSiges(1.5.0/docs/api/java/lang/String.html">String year, int institutionCode, List<Integer> codigos) {

        1.5.0/docs/api/java/lang/String.html">String msgS;

        List<Integer> codesInBaco = DaoFactory.getStudentDaoImpl().findAllSigesCodesYear(year,institutionCode);

        codesInBaco.removeAll(codigos);

        if(codesInBaco.size() > 0)

        {

            msgS = "Existem estudantes no BACO que não estao no SIGES no ano: " + year + " institution:" + institutionCode + " possiveis adicionados manualmente, confirmar";

            serviceLogWarn(msgS);

            logger.warn(msgS);

            msgS = "";

            for (1.5.0/docs/api/java/lang/Integer.html">Integer c : codesInBaco)

            {

                msgS+=c + ", ";

            }

            serviceLogWarn(msgS);

            logger.warn(msgS);

            for (1.5.0/docs/api/java/lang/Integer.html">Integer c : codesInBaco)

            {

                estudantesDesaparecidosDoSigesNesteAno++;

                Student s = DaoFactory.getStudentDaoImpl().loadBySigesCode(c);

                StudentImpl studentImpl = (StudentImpl) DaoFactory.getStudentDaoImpl().narrow(s);

                removerUnidadesQueDesapareceramNoSiges(year, new HashSet<CourseUnit>(), studentImpl,institutionCode);

                consistirTurmasAluno(studentImpl, year, new HashMap<CourseUnit, String>(),institutionCode);

            }

        }

        else

        {

            msgS = "OK check - Não existem alunos desaparecidos no SIGES ano: " + year + " institution:" + institutionCode + " possiveis adicionados manualmente, confirmar";

            serviceLogInfo(msgS);

            logger.info(msgS);

        }

    }

    /**

     *

     * QUERY DAS INCONSISTENCIAS PARA REMOVER ALUNOS DAS TURMAS

     * Estes casos são aqueles em que temos alunos em turmas de disciplinas

     * sem que os alunos estejam subscritos na tabela de subscrições antiga

     * Estes casos sao para remover

     *

     * Este caso aconteceu quando se deu o caso do Bug do session.refresh

     * que estragava o aluno e ia gravando alunos novos sempre com cadeiras penduradas

     *

     *

     * @param year

     * @param institutionCode

     * @param logMessages

     * @throws SQLException

     */

    private void removeUnitsFromTurmaSubscriptionsThatAreNotInCourseUnitSubscriptions(1.5.0/docs/api/java/lang/String.html">String year,int institutionCode,DefaultLogMessages logMessages) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {

        1.5.0/docs/api/java/lang/String.html">String query = "select {0} " +

                "from subscribedturmaunits " +

                "join courseunitturma on courseunitturma.id = subscribedturmaunits.courseUnitTurmaId " +

                "join courseunit on courseunitturma.courseUnit = courseunit.id " +

                "join course on courseunit.course = course.id\n" +

                "join course_department on course.area = course_department.sigla\n" +

                "join course_school on course_department.school_id = course_school.id\n" +

                "join user on user.id = subscribedturmaunits.studentId " +

                "left join subscribedunits on " +

                "subscribedturmaunits.studentId = subscribedunits.studentId " +

                "and subscribedunits.courseUnitId = courseunit.id " +

                "where courseunit.importYear = \"" + year + "\" and course_school.institutionalCode = " + institutionCode + " and subscribedunits.studentId is null";

        1.5.0/docs/api/java/lang/String.html">String fields = "courseunit.code as unidSigesCode," +

                "user.name as name, " +

                "user.sigesCode as sigesCode, " +

                "subscribedturmaunits.studentId as studentId, " +

                "courseunit.id as unitId ," +

                "courseunit.name as unitname ," +

                "courseunitturma.id as turmaId ," +

                "courseunitturma.turma as turma";

        1.5.0/docs/api/java/sql/PreparedStatement.html">PreparedStatement ps = AbstractDao.getCurrentSession().connection().prepareStatement(

                1.5.0/docs/api/java/text/MessageFormat.html">MessageFormat.format(query,"count(*) as total"));

        1.5.0/docs/api/java/sql/ResultSet.html">ResultSet rs = ps.executeQuery();

        rs.next();

        int size = rs.getInt("total");

        rs.close();

        ps.close();

        if(size > 0)

        {

            /**********logging*********/

            turmasWrongSubscriptions=size;

            1.5.0/docs/api/java/lang/String.html">String msg = "Found " + size + " subscritions in turmas wich are not in subscribedUnits will remove them";

            logger.warn(msg);

            serviceLogInfo(msg);

            /**********logging*********/

            ps = AbstractDao.getCurrentSession().connection().prepareStatement(

                    1.5.0/docs/api/java/text/MessageFormat.html">MessageFormat.format(query,fields));

            rs = ps.executeQuery();

            int i = 0;

            while(rs.next())

            {

                1.5.0/docs/api/java/lang/String.html">String unidSigesCode = rs.getString("unidSigesCode");

                1.5.0/docs/api/java/lang/String.html">String studentName = rs.getString("name");

                long sigesCode = rs.getInt("sigesCode");

                long studentId = rs.getLong("studentId");

                long unitId = rs.getLong("unitId");

                1.5.0/docs/api/java/lang/String.html">String unitname = rs.getString("unitname");

                long turmaId = rs.getLong("turmaId");

                1.5.0/docs/api/java/lang/String.html">String turma = rs.getString("turma");

                CourseUnitTurma cut = DaoFactory.getCourseUnitTurmaDaoImpl().load(turmaId);

                Student s = DaoFactory.getStudentDaoImpl().load(studentId);

                cut.getStudents().remove(s);

                s.getTurmas().remove(cut);

                /**********logging*********/

                msg = "Inconsistencia encontrada na turma " + turma + " para o aluno " + studentName + " siges: " + sigesCode + " id:" + studentId + " na unidade siges:" + unidSigesCode + " unitid:" + unitId + " " + unitname + " O aluno nao tinha esta unidade e tinha uma turma para ela ";

                logger.warn(msg);

                serviceLogWarn(msg);

                logMessages.addMessage(new DefaultLogMessage("import.students.consisting.turmas", LogMessageTypeEnum.WARNING,msg));

                /**********logging*********/

            }

            rs.close();

            ps.close();

        }

        else

        {

            1.5.0/docs/api/java/lang/String.html">String msgS = "OK check - Todos os alunos com cadeiras em turmas tem a cadeira subscrita ano: " + year + " institution:" + institutionCode + " possiveis adicionados manualmente, confirmar";

            serviceLogInfo(msgS);

            logger.info(msgS);

        }

    }

    /**

     * Envio de Notificação aos operadores do CI

     * @param subject

     * @param cause

     */

    private void sendNotificationAdmin(1.5.0/docs/api/java/lang/String.html">String subject, 1.5.0/docs/api/java/lang/String.html">String cause)

    {

        List<String> emails = ConfigProperties.getListValues("admin.email");

        for(1.5.0/docs/api/java/lang/String.html">String email:emails)

        {

            serviceLogWarn(">>>>>>>>ENVIANDO NOTIFICACAO A ADMINISTRACAO: " + email);

            logger.warn(">>>>>>>>ENVIANDO NOTIFICACAO A ADMINISTRACAO: " + email);

        }

        List<String> arguments = new ArrayList<String>();

        arguments.add(cause.replace("\n","<br/>"));

        Email email = new Email(subject,emails,Globals.SYSTEM_EMAIL_BOX,"messageToAdmin_pt.txt",arguments);

        email.setHtml(true);

        try {

            new SendEmailService().sendEmail(email);

        } catch (ServiceException e) {

            e.printStackTrace();

        }

    }

    public 1.5.0/docs/api/java/lang/Integer.html">Integer getRealCourse(1.5.0/docs/api/java/lang/String.html">String turma,1.5.0/docs/api/java/lang/String.html">String year, int institutionCode,1.5.0/docs/api/java/lang/String.html">String semestre, DefaultLogMessages messages) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {

        HashMap<String,List<Integer>> pairs = getCourseTurmaPairs(year,institutionCode,semestre,messages);

        List<Integer> cursos = pairs.get(turma);

        if(cursos.size() > 1)

        {

            1.5.0/docs/api/java/lang/String.html">String msgAdmin = "";

            1.5.0/docs/api/java/lang/String.html">String msg = "####Atenção existe um caso de dúvida nas inscrições : " + year + "-" + semestre + " turma " + turma;

            msgAdmin += msg + "\n";

            logger.warn(msg);

            serviceLogWarn(msg);

            msg = "####A turma " + turma + " tem " + cursos.size() + " cursos associados: ";

            logger.warn(msg);

            serviceLogWarn(msg);

            msgAdmin += msg + "\n";

            for(1.5.0/docs/api/java/lang/Integer.html">Integer curso: cursos)

            {

                msg = "######->turma:" +  turma + " -> curso siges: " + curso.longValue();