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();
                msgAdmin += msg + "\n";
                logger.warn(msg);
                serviceLogWarn(msg);
            }
            sendNotificationAdmin("Atenção existe um caso de dúvida nas inscrições vamos devolver código invalido de curso para o sistema atribuir o primeiro onde a unidade se encontre",msgAdmin);
            return -1;
        }
        else if(cursos.size() == 1)
        {
            return cursos.get(0);
        }
        else
        {
            1.5.0/docs/api/java/lang/String.html">String msg = "####Atenção existe uma turma que nao tem curso associado : " + year + "-" + semestre + " turma " + turma;
            sendNotificationAdmin("Atenção existe uma turma que nao tem curso associado",msg);
            logger.error(msg);
            serviceLogError(msg);
            return null;
        }
    }

    protected static boolean isCursoFicticio(int cursoCode)
    {
        if(cursosFicticios == null)
            cursosFicticios = DaoFactory.getConfigurationDaoImpl().getCursosFicticios();
        for(1.5.0/docs/api/java/lang/Integer.html">Integer cursoFicticio: cursosFicticios)
        {
            if(cursoFicticio.intValue() == cursoCode)
            {
                return true;
            }
        }
        return false;
    }

    HashMap<String,HashMap<String,List<Integer>>> semestreTurmaCursosPairs = new HashMap<String, HashMap<String, List<Integer>>>();

    private HashMap<String,List<Integer>> getCourseTurmaPairs(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>> turmaCourses = semestreTurmaCursosPairs.get(year + ";" + semestre);
        if(turmaCourses == null)
        {
            1.5.0/docs/api/java/lang/String.html">String msg = "Starting structure pairs turma curso para : " + year + "-" + semestre;
            logger.info(msg);
            serviceLogInfo(msg);
           /* ArrayOfTurmaCurso arrayOfTurmaCurso = service.getSiGesWEBSoap().loadParesTurmaCurso(
                    new BigDecimal(DaoFactory.getConfigurationDaoImpl().getSigesInstitutionCode())
                    , year,semestre);*/
            List<pt.estgp.estgweb.services.sigesimports.oracle.domain.TurmaCurso> turmaCursos = TurmaDao.getInstance().loadTurmasCurso(institutionCode, year, semestre);
            turmaCourses = new HashMap<String, List<Integer>>();
            for(pt.estgp.estgweb.services.sigesimports.oracle.domain.TurmaCurso turmaCursoPair: turmaCursos)
            {
                List<Integer> cursos = turmaCourses.get(turmaCursoPair.getCdTurma());
                if(cursos == null)
                {
                    cursos = new ArrayList<Integer>();
                    turmaCourses.put(turmaCursoPair.getCdTurma(),cursos);
                }
                if(turmaCursoPair.getCodigoCurso().intValue() >= 0)
                {
                    boolean cursoFicticio = isCursoFicticio(turmaCursoPair.getCodigoCurso().intValue());
                    if(!cursoFicticio)
                    {
                        cursos.add(turmaCursoPair.getCodigoCurso());

                        msg = "Adding:" + turmaCursoPair.getCdTurma() + "->" + turmaCursoPair.getCodigoCurso();
                        logger.info(msg);
                        serviceLogInfo(msg);
                        if(cursos.size()>1)
                        {
                            turmaMoreThanOneRegularCourse++;
                            turmasMoreThanOneCourse.add(turmaCursoPair.getCdTurma());
                            msg = "Warning: turma " + turmaCursoPair.getCdTurma() + " has more than one regular course associated ";
                            logger.warn(msg);
                            serviceLogWarn(msg);
                            //Nao vamos reportar aviso neste caso
                            //messages.addMessage(new DefaultLogMessage("", LogMessageTypeEnum.WARNING,msg));
                        }
                    }
                    else
                    {
                        msg = "Not adding:" + turmaCursoPair.getCdTurma() + "->" + turmaCursoPair.getCodigoCurso() + " -> Codigo de Curso Ficticio ->não vai ser considerado";
                        logger.info(msg);
                        serviceLogInfo(msg);
                    }
                }
                else
                {
                    msg = "Excluding:" + turmaCursoPair.getCdTurma() + "->" + turmaCursoPair.getCodigoCurso();
                    logger.warn(msg);
                    serviceLogInfo(msg);
                }
            }
            semestreTurmaCursosPairs.put(year + ";" + semestre,turmaCourses);
            /***END INICIALIZACAO***/
        }
        /**Inicialização da Estrutura de Suporte aos Cursos/Turma*/
        return turmaCourses;
    }


    /**
     * Nao esta testado
     * jm
     *
     * @param alunoSiges       Aluno
     * @param student Student
     * @param nacionalidades
     */
    private void persist(Aluno alunoSiges, Student student, boolean newUser, 1.5.0/docs/api/java/lang/String.html">String year, int institutionCode, 1.5.0/docs/api/java/lang/String.html">String activeImportYear, DefaultLogMessages logMessages, AlunoDao service, HashMap<Integer, Nacionalidade> nacionalidades) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {


        updateStudentFields(alunoSiges, student, newUser,nacionalidades);

        updateSituacaoPropinas(alunoSiges, student, activeImportYear);

        /*Desta forma as relacoes antigas sao ignoradas cria-se uma lista nova e atribui-se ao Teacher, o Hibernate faz resto e apaga as chaves estrangeiras antigas */
        if (alunoSiges.getDisciplinasInscrito() == null || alunoSiges.getDisciplinasInscrito().size() == 0)
        {
            studentsZeroUnits++;
            serviceLogWarn("ATENTION STUDENT WITH ZERO UNITS: codigo " + alunoSiges.getCodigo());
            logger.warn("ATENTION STUDENT WITH ZERO UNITS: codigo " + alunoSiges.getCodigo());
            StudentImpl studentImpl = (StudentImpl) DaoFactory.getStudentDaoImpl().narrow(student);
            removerUnidadesQueDesapareceramNoSiges(year, new HashSet<CourseUnit>(), studentImpl,institutionCode);
            consistirTurmasAluno(studentImpl, year, new HashMap<CourseUnit, String>(),institutionCode);
        }
        else
        {
            //1 - PROCEDIMENTO CADEIRAS SAO CARREGADAS DO BACO DA LISTA QUE VEM DO SIGES -> units      CADEIRAS SIGES PERS BACO
            //2 - Sao retiradas da lista units as que o aluno tem mas que foram removidas localmente   CADEIRAS SIGES PERS BACO - REMOVIDAS LOCALMENTE = CADEIRAS SIGES PER BACO LIMPAS
            //3 - Sao adicionadas ao aluno as que o aluno ainda nao tiver da lista units               CADEIRAS SIGES LIMPAS ---> COPY ---> ALUNO CADEIRAS
            //4 - Por fim Sao removidas da lista final as unidades que não vêm do SIGES e que não foram adicionadas localmente   CADEIRAS ALUNO - CADEIRAS SIGES = CADEIRAS EXCEDENTES
            //5 - Consistir Turmas do Aluno com novas cadeiras - Turmas do aluno sem cadeira correspondente sao apagadas, novas adicionadas

            //Mapa de unidades carregadas a partir do Siges para o aluno associadas à turma que vinha do siges
            //Para todas as cadeiras correspondentes 'as do SIGES no baco existira uma entrada com a turma nesta tabela
            Map<CourseUnit,String> map_CourseUnit_x_Turma = new HashMap<CourseUnit, String>();

            //PASSO 1
            //turmas separadas : depende da escolha de turmas separadas para o curso
            //caso aconteca a unidade será discriminada pelo código de turma como unica o mesmo é feito na importacao de cursos
            Set<CourseUnit> unitsFromSigesPersistentInBaco = obterCadeirasBacoCorrespondentes(alunoSiges, student, year, institutionCode, logMessages, map_CourseUnit_x_Turma);

            //PASSO 2 - Sao retiradas da lista unitsFromSigesPersistentInBaco as que o aluno tem mas que foram removidas localmente
            //turmas separadas : Nao afetado pelas turmas separadas usa apenas os codigos do baco nas verificacoes para remocoes
            StudentImpl studentImpl = removerRemovidasLocalmente(student, unitsFromSigesPersistentInBaco);
            student = studentImpl;//just to be allays consistent

            //PASSO 3 - Sao adicionadas ao aluno as unidades que o aluno ainda nao tiver da lista unitsFromSigesPersistentInBaco
            //turmas separadas : Seguro a verificação de existencia é feita pelo id da unidade curricular no baco nas verificacoes para remocoes
            adicionarCadeirasNovasAoAluno(studentImpl, unitsFromSigesPersistentInBaco);

            //PASSO 4 - Remover unidades deste ano que nao vem do SIGES e que nao foram adicionadas localmente
            //turmas separadas : Seguro a verificação de existencia é feita pelo id da unidade curricular no baco nas verificacoes para remocoes
            removerUnidadesQueDesapareceramNoSiges(year, unitsFromSigesPersistentInBaco, studentImpl,institutionCode);

            //PASSO 5 - Consistir Turmas do Aluno com novas cadeiras - Turmas do aluno sem cadeira correspondente sao apagadas, novas sao adicionadas
            //Este metodo vai necessitar de obter as turmas das unidades que vieram do SIGES atraves do mapa map_CourseUnit_x_Turma
            //de forma a garantir que as mesmas estão consistentes em
            //em termos de relacoes com turmas na classe CourseUnitTurma
            //deste modo se alguma unidade foi adicionada localmente poderá nao ser removida no PASSO 4 e nao havera correspondente
            //para a turma nesta tabela map_CourseUnit_x_Turma logo essas turmas nessas unidades nao serao mechidas, um aviso e emitido
            consistirTurmasAluno(studentImpl, year, map_CourseUnit_x_Turma,institutionCode);
        }
    }

    private void consistirTurmasAluno(StudentImpl student, 1.5.0/docs/api/java/lang/String.html">String year, Map<CourseUnit, String> map_CourseUnit_x_Turma, int institutionCode) {
        //PASSO 1 Para cada cadeira onde o aluno se encontra inscrito
        //        obter a turma onde o aluno esta' colocado, se nao existir criar e afectar a turma
        //PASSO 2 Colocar o aluno nessa turma se ele ainda lá nao estiver
        //PASSO 3 Para todas as turmas do aluno de cadeiras do ano corrente
        //        se essa turma nao estiver na lista de Turmas afectadas
        //        remover a turma do aluno
        //        remove ao mesmo tempo da lista da turma da unidade
        //PASSO 1
        Map<CourseUnitTurma,Boolean> turmasAfectadas = new HashMap<CourseUnitTurma,Boolean>();
        for(CourseUnit cu: student.getSubscribedUnits())
        {
            if(cu.getImportYear().equals(year) && cu.getCourse().getDepartment().getCourseSchool().getInstitutionalCode().equals(""+institutionCode))
            {
                if(cu.getTurmas() == null)
                {
                    cu.setTurmas(new HashSet<CourseUnitTurma>());
                }

                1.5.0/docs/api/java/lang/String.html">String codigoTurma = map_CourseUnit_x_Turma.get(cu);
                if(student.isLocalUnit(cu) && codigoTurma == null)
                {
                    //nao tem correspondencia no mapa de turmas uma vez que nao foi carregada no siges
                    //mas foi mantida porque foi adicionada manualmente
                    //deste modo usaremos a turma antiga
                    //e nao afetaremos uma turma nao afetada, esta nao sera verificada
                    1.5.0/docs/api/java/lang/String.html">String msg = "Atenção turma não encontrada para uma unidade do aluno, A unidade não foi importada do SIGES logo não há turma mas nao sera verificada porque e' uma local unit:" + cu.getCode() + " aluno:" + student.getSigesCode();
                    serviceLogInfo(msg);
                    logger.info(msg);
                }
                else if(codigoTurma == null)
                {
                    //Este caso nao deverá acontecer porque no PASSO 4 da persistencia apenas nao se removem as adicionadas localmente
                    1.5.0/docs/api/java/lang/String.html">String msg = "Atenção turma não encontrada para uma unidade do aluno. A Unidade não foi importada do SIGES ou vinha com turma NULL, logo nao se sabe a turma do aluno para escolher, e não e' uma unidade LOCALMENTE ADICIONADA logo devia vir do SIGES ou ter sido removida - unit:" + cu.getCode() + " aluno:" + student.getSigesCode();
                    serviceLogError(msg);
                    logger.error(msg);
                }
                else
                {
                    CourseUnitTurma courseUnitTurma = findOrCreateCourseUnitTurma(codigoTurma, cu);
                    turmasAfectadas.put(courseUnitTurma,true);
                }
            }
        }
        //PASSO 2
        for(CourseUnitTurma turmaAfectada: turmasAfectadas.keySet())
        {
            if(turmaAfectada.getStudents() == null || !turmaAfectada.getStudents().contains(student))
            {
                if(turmaAfectada.getStudents() == null)
                    turmaAfectada.setStudents(new HashSet<StudentImpl>());
                turmaAfectada.getStudents().add(student);
                //student.getTurmas().add((CourseUnitTurmaImpl) turmaAfectada);
            }
        }

        //PASSO 3
        if(student.getTurmas() != null)
        {
            Iterator<CourseUnitTurmaImpl> iter = student.getTurmas().iterator();
            while(iter.hasNext())
            {
                CourseUnitTurmaImpl turma = iter.next();
                if(turma.getCourseUnit().getImportYear().equals(year) && turma.getCourseUnit().getCourse().getDepartment().getCourseSchool().getInstitutionalCode().equals(institutionCode+""))
                {
                    if(student.isLocalUnit(turma.getCourseUnit()) && turmasAfectadas.get(turma) == null)
                    {
                        1.5.0/docs/api/java/lang/String.html">String msg = "Atenção turma com código " + turma.getTurma() + " nao sera removida porque e' a turma da local unit:" + turma.getCourseUnit().getCode() + " aluno:" + student.getSigesCode();
                        serviceLogInfo(msg);
                        logger.info(msg);
                    }
                    else if(turmasAfectadas.get(turma) == null)
                    {

                        //Este caso nao devera acontecer mas fica aqui a seguranca
                        1.5.0/docs/api/java/lang/String.html">String msg = "Atenção turma com código " + turma.getTurma() + " nao existe nas afetadas e vai ser removida ao aluno e nao e' local unit:" + turma.getCourseUnit().getCode() + " aluno:" + student.getSigesCode();
                        serviceLogError(msg);
                        logger.error(msg);
                        iter.remove();
                        turma.getStudents().remove(student);
                    }
                }
            }
        }
    }

    /**
     *
     * @param cdturma
     * @param cu
     * @return
     */
    private CourseUnitTurma findOrCreateCourseUnitTurma(1.5.0/docs/api/java/lang/String.html">String cdturma, CourseUnit cu) {
        CourseUnitTurma courseUnitTurma = null;
        try{
        for(CourseUnitTurma turma: cu.getTurmas())
        {
            if(turma.getTurma() != null && turma.getTurma().trim().equals(cdturma.trim()))
            {
                courseUnitTurma = turma;
                break;
            }
        }
        if(courseUnitTurma == null)
        {
            courseUnitTurma = DomainObjectFactory.createCourseUnitTurmaImpl();
            courseUnitTurma.setTurma(cdturma);
            DaoFactory.getCourseUnitTurmaDaoImpl().save(courseUnitTurma);
            courseUnitTurma.setCourseUnit(cu);
            cu.getTurmas().add(courseUnitTurma);
        }
        }catch(1.5.0/docs/api/java/lang/Exception.html">Exception e)
        {
            e.toString();
            e.printStackTrace();
        }
        return courseUnitTurma;
    }

    /**
     *
     * @param student
     * @param year
     * @param unitsFromSigesPersistentInBaco
     * @param student
     */
    private void removerUnidadesQueDesapareceramNoSiges(1.5.0/docs/api/java/lang/String.html">String year, Set<CourseUnit> unitsFromSigesPersistentInBaco, StudentImpl student,int institutionCode) {
        Iterator<CourseUnit> iterNowUnits = student.getSubscribedUnits().iterator();
        while(iterNowUnits.hasNext())
        {
            CourseUnit cUNow = iterNowUnits.next();
            if(cUNow.getImportYear().equals(year) && cUNow.getCourse().getDepartment().getCourseSchool().getInstitutionalCode().equals(""+institutionCode))
            //Apenas tentamos apagar as unidades do ano corrente.
            //Este servico trabalha com unidades importadas do ano que e passado como argumento
            //Se importamos unidades desse ano, as dos outros anos nao vem na lista, logo
            //iriamos constatar que nenhuma estava no SIGES o que nao e verdade.
            //Assim so apagamos unidades do ano que estamos a importar e que nao venham
            //na importacao desse ano
            {

                boolean added = false;
                for(CourseUnit c: unitsFromSigesPersistentInBaco)
                {
                    if(cUNow.getId() == c.getId())
                    {
                        added = true;
                        break;
                    }
                }
                if(!added)
                {

                    if(!student.isLocalUnit(cUNow))
                    {
                        1.5.0/docs/api/java/lang/String.html">String msg = "Removendo unidade: " + ((CourseUnitImpl)cUNow).getSigesUniqueIdentifiers() + " - do aluno: " + student.getSigesCode() + " - Associacao desapareceu do SIGES";
                        serviceLogInfo(msg);
                        logger.info(msg);
                        iterNowUnits.remove();
                        unitsRemovedToStudents++;
                    }
                    else
                    {
                        1.5.0/docs/api/java/lang/String.html">String msg = "NAO REMOVIDA - Unidade: " + ((CourseUnitImpl)cUNow).getSigesUniqueIdentifiers() + " - do aluno: " + student.getSigesCode() + " - Associacao desapareceu do SIGES mas foi adicionada localmente";
                        serviceLogInfo(msg);
                        logger.info(msg);
                        unitsLocalAddedNotRemoved++;
                    }
                }
            }
        }
    }

    private void adicionarCadeirasNovasAoAluno(Student student, Set<CourseUnit> unitsFromSigesPersistentInBacoLimpas) {
        if(student.getSubscribedUnits() != null)
        {
            for(CourseUnit c: unitsFromSigesPersistentInBacoLimpas)
            {
                boolean isIn = false;
                for(CourseUnit tc : student.getSubscribedUnits())
                {
                    if(tc.getId() == c.getId())
                    {
                        isIn = true;
                        break;
                    }
                }
                if(!isIn)
                {
                    1.5.0/docs/api/java/lang/String.html">String msg = "Adicionando unidade: " + ((CourseUnitImpl)c).getSigesUniqueIdentifiers() + " - ao aluno: " + student.getSigesCode() + " - Associacao nova no SIGES";
                    serviceLogInfo(msg);
                    logger.info(msg);
                    unitsAddedToStudents++;
                    student.getSubscribedUnits().add(c);
                }
            }
        }
        else
            student.setSubscribedUnits(unitsFromSigesPersistentInBacoLimpas);
    }

    private StudentImpl removerRemovidasLocalmente(Student student, Set<CourseUnit> unitsFromSigesPersistentInBaco) {
        Iterator<CourseUnit> iter = unitsFromSigesPersistentInBaco.iterator();
        StudentImpl studentImpl = (StudentImpl) DaoFactory.getStudentDaoImpl().narrow(student);
        while (iter.hasNext())
        {
            CourseUnit courseUnit = iter.next();
            //In case of a comming proxy

            if(studentImpl.isLocalRemovedUnit(courseUnit))
            {
                unitsLocallyRemovedNotAdded++;
                1.5.0/docs/api/java/lang/String.html">String msg = "Removendo unidade: " + ((CourseUnitImpl)courseUnit).getSigesUniqueIdentifiers() + " - do aluno: " + student.getSigesCode() + " - Associacao existe no SIGES mas foi removido LOCALMENTE";
                serviceLogInfo(msg);
                logger.info(msg);
                iter.remove();
            }
        }
        return studentImpl;
    }

    private Set<CourseUnit> obterCadeirasBacoCorrespondentes(Aluno alunoSiges, Student student, 1.5.0/docs/api/java/lang/String.html">String year, int institutionCode, DefaultLogMessages logMessages, Map<CourseUnit, String> map_CourseUnit_x_Turma) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {
        Set<CourseUnit> unitsFromSigesPersistentInBaco = new HashSet<CourseUnit>();
        for (Disciplina disciplina : alunoSiges.getDisciplinasInscrito())
        {
            if(disciplina.getCdTurma() == null)
            {
                turmasVindasANullDoSIGES++;
                1.5.0/docs/api/java/lang/String.html">String msg = "(turmasVindasANullDoSIGES) ATENÇÃO ERRO: Existe uma turma a null numa inscrição vinda do SIGES, procurar razão: unidade:" + disciplina.getCodigo() + " estudante:" + student.getSigesCode() + " possivelmente campo de turma em uso é errado, Vamos tentar usar o campo de outra TURMA P, L, TP, P, O, C, E, S";
                serviceLogWarn(msg);
                logger.warn(msg);
                if(disciplina.getOutraTurma() != null)
                {
                    turmasVindasANullDoSIGESEncontradasNoutroCampo++;
                    disciplina.setCdTurma(disciplina.getOutraTurma());
                    msg = "Encontrada Outra Turma: Atenção vai ser usada a turma " + disciplina.getOutraTurmaCode();
                    serviceLogWarn(msg);
                    logger.warn(msg);
                }
            }

            boolean cursoFicticio = isCursoFicticio(disciplina.getCodigoCurso().intValue());
            1.5.0/docs/api/java/lang/Integer.html">Integer codigoDoCurso = disciplina.getCodigoCurso().intValue();

            if(    (disciplina.getCdTipoDisciplina() != null
                &&
                disciplina.getCdTipoDisciplina().intValue() == ImportCourseService.SIGES_CODIGO_TIPO_DISCIPLINA_EXTRA_CURRICULAR)
                    ||
                cursoFicticio)
            {
                if(cursoFicticio)
                {
                    alunosErasmusCadeirasEcontradas++;
                    1.5.0/docs/api/java/lang/String.html">String msg = "Disciplina para Aluno " + student.getSigesCode() + " de Curso Ficticio " +disciplina.getCodigoCurso().intValue() + " encontrada  vamos trocar para código de curso real";
                    serviceLogInfo(msg);
                    logger.info(msg);
                }
                else
                {
                    1.5.0/docs/api/java/lang/String.html">String msg = "Disciplina para Aluno " + student.getSigesCode() + " ExtraCurricular " +disciplina.getCodigoCurso().intValue() + " encontrada  vamos trocar para código de curso real";
                    serviceLogInfo(msg);
                    logger.info(msg);
                }
                codigoDoCurso = getRealCourse(disciplina.getCdTurma(),year,institutionCode,disciplina.getCdDuracao(),logMessages);

                if(codigoDoCurso != null)
                {
                    if(codigoDoCurso < 0)
                    {
                        1.5.0/docs/api/java/lang/String.html">String msg = "Codigo de curso (" + disciplina.getCodigoCurso() + ") da disciplina " + disciplina.getCodigo() + " tipo: " + disciplina.getCdTipoDisciplina() + " turma: " + disciplina.getCdTurma() + " tem mais de um curso vamos procurar num qualquer curso onde exista ";
                        serviceLogInfo(msg);
                        logger.info(msg);
                    }
                    else
                    {
                        1.5.0/docs/api/java/lang/String.html">String msg = "Codigo de curso (" + disciplina.getCodigoCurso() + ") da disciplina " + disciplina.getCodigo() + " tipo: " + disciplina.getCdTipoDisciplina() + " turma: " + disciplina.getCdTurma() + " Modificado para o real: " + codigoDoCurso;
                        serviceLogInfo(msg);
                        logger.info(msg);
                    }
                }
                else
                {
                    1.5.0/docs/api/java/lang/String.html">String msg = "Problema Encontrado Turma não tem Curso Real --> Codigo de curso (" + disciplina.getCodigoCurso() + ") da disciplina " + disciplina.getCodigo() + " tipo: " + disciplina.getCdTipoDisciplina() + " turma: " + disciplina.getCdTurma();
                    serviceLogWarn(msg);
                    logger.warn(msg);
                    msg = "A unidade " + disciplina.getCodigo() +  " não será adicionada ao aluno " + alunoSiges.getCodigo() + " porque nao foi encontrada, possivelmente apenas existe para alunos com inscrição NORMAL";
                    serviceLogWarn(msg);
                    logger.warn(msg);
                    unidadesSoComAlunosExtra++;
                    continue;
                }
            }


            //Politica de separação de turmas em unidades independentes neste curso
            boolean separateTurmas = ImportCourseService.loadCourseYearTurmasPolicy(codigoDoCurso, year, logMessages, this);
            List<CourseUnit> courseUnits;

            /*BLOCO DE LOAD DAS UNIDADES*/
            if(codigoDoCurso <= 0) //O curso encontrado foi mais que um vamos fazer o melhor esforço e atribuir um que dê isto apenas deverá acontecer com erasmus e em turmas com mais que um curso
            {
                unidadesProcuradasNumCursoAleatorio++;
                if(separateTurmas)
                    courseUnits = DaoFactory.getCourseUnitDaoImpl().loadBySigesCodeUniqueWithTurmaIgnoreCourse("" + disciplina.getCodigo(), disciplina.getCdDuracao(), disciplina.getCdLectivo(), disciplina.getCdTurma());
                else
                    courseUnits = DaoFactory.getCourseUnitDaoImpl().loadBySigesCodeUniqueIgnoreCourse("" + disciplina.getCodigo(),disciplina.getCdDuracao(),disciplina.getCdLectivo());
                if(courseUnits.size() > 0)
                {
                    //Neste caso adicionamos apenas a primeira
                    CourseUnit cu = courseUnits.get(0);
                    courseUnits = new ArrayList<CourseUnit>();
                    courseUnits.add(cu);
                }
            }
            else
            {
                if(separateTurmas)
                    courseUnits = DaoFactory.getCourseUnitDaoImpl().loadBySigesCodeUniqueWithTurma("" + disciplina.getCodigo(), "" + codigoDoCurso, disciplina.getCdDuracao(), disciplina.getCdLectivo(), disciplina.getCdTurma());
                else
                    courseUnits = DaoFactory.getCourseUnitDaoImpl().loadBySigesCodeUnique("" + disciplina.getCodigo(),"" + codigoDoCurso,disciplina.getCdDuracao(),disciplina.getCdLectivo());
            }
            /*BLOCO DE LOAD DAS UNIDADES*/



            if(courseUnits != null && courseUnits.size() > 1 )
            {
                studentComUnidadesRepetidas=true;
                logMessages.addMessage(new DefaultLogMessage("import.warning","Unidade Repetida: (" + disciplina.getCodigo() + ") curso: " + disciplina.getCodigoCurso() + " " + disciplina.getCdDuracao() + " " + year, "see log for details", LogMessageTypeEnum.WARNING));
                logger.fatal(logMessages.getLastMessage());
                serviceLogWarn(logMessages.getLastMessage());
            }
            //CourseUnit courseUnit = null;
            //Special procedure for Aluno to check if turma not exist will find without turma code to keep old years compatibility
            /*if(courseUnit == null)
            {
                unitsNotFoundTurma++;
                courseUnit = tryFindCourseUnitWithOutTurma(logMessages,disciplina.getCdDuracao(),""+disciplina.getCodigo().intValue()
                        ,"" + codigoDoCurso.intValue(),disciplina.getCdLectivo(),disciplina.getCdTurma());
            }*/
            if(courseUnits == null || courseUnits.size() == 0)
            {
                unitsNotFound++;
                1.5.0/docs/api/java/lang/String.html">String msg = "Unit not found (student " + student.getSigesCode() + "): semestre:" + disciplina.getCdDuracao() + " codigo:" + disciplina.getCodigo() + " course:" + codigoDoCurso + " year:" + disciplina.getCdLectivo() + " turma: " + disciplina.getCdTurma();
                serviceLogWarn(msg);
                logger.warn(msg);
            }
            else
            {
                for(CourseUnit found: courseUnits)
                {
                    1.5.0/docs/api/java/lang/String.html">String turma = disciplina.getCdTurma();
                    map_CourseUnit_x_Turma.put(found, turma);
                }

                unitsFromSigesPersistentInBaco.addAll(courseUnits);
            }
        }
        return unitsFromSigesPersistentInBaco;
    }




    private void updateSituacaoPropinas(Aluno alunoSiges, Student student, 1.5.0/docs/api/java/lang/String.html">String activeImportYear) {
        if(alunoSiges.getHistoricos() == null || alunoSiges.getHistoricos().size() == 0)
        {
            student.setPropinasEmDia(false);
            serviceLogWarn("ATENTION Estudante sem historico de Matriculas para aferir propinas: codigo " + alunoSiges.getCodigo());
            logger.warn("ATENTION Estudante sem historico de Matriculas para aferir propinas: codigo " + alunoSiges.getCodigo());
        }
        else
        {
            student.setPropinasEmDia(false);
            student.setPropinasEmDiaYear(activeImportYear);

            for(AlunoHistorico hist: alunoSiges.getHistoricos())
            {
                if(hist.getCodigoLectivo()!=null && hist.getCodigoLectivo().equals(activeImportYear))
                {
                    if(hist.getPropinaEmDia().equalsIgnoreCase("s"))
                    {
                        student.setPropinasEmDia(true);
                        student.setPropinasEmDiaYear(activeImportYear);
                    }
                    break;
                }
            }
            if(!student.isPropinasEmDia())
            {
                serviceLogInfo("ATENTION Estudante sem propina em dia: codigo " + alunoSiges.getCodigo());
                logger.info("ATENTION Estudante sem propina em dia: codigo " + alunoSiges.getCodigo());
            }
        }
    }



    private void updateStudentFields(Aluno alunoSiges, Student student, boolean newUser, HashMap<Integer, Nacionalidade> nacionalidades) {
        if(newUser)
        {
            studentsNew++;
            cloneFields(alunoSiges, student, nacionalidades);
            1.5.0/docs/api/java/lang/String.html">String msg = "NOVO ALUNO ENCONTRADO: siges:" + student.getSigesCode() + " bi:" + student.getBi() + " nome:" + student.getName();
            serviceLogInfo(msg);
            logger.info(msg);
        }
        //CASO EM QUE O ALUNO NO SIGES FOI ATRIBUIDO A OUTRO ESTUDANTE PARA PREENCHER BURACO NA NUMERACAO
        else if(alunoSiges.getNumeroBi() == null || student.getBi() == null || ! alunoSiges.getNumeroBi().equals(student.getBi()))
        {
            studentsChangeBI++;

            1.5.0/docs/api/java/lang/StringBuilder.html">StringBuilder builder = new 1.5.0/docs/api/java/lang/StringBuilder.html">StringBuilder();

            builder.append("ATENCAO NUMERO DE ALUNO " + alunoSiges.getCodigo() + " MUDOU DE DONO Confirme dados\n");
            builder.append("ALTERANDO DADOS DO ALUNO " + alunoSiges.getCodigo() + "\n");
            builder.append("-----ANTES: " + "\n");
            builder.append("-----BI: " + student.getBi() + "\n");
            builder.append("-----Nome: " + student.getName() + "\n");
            builder.append("-----Username: " + student.getUserNameNetpa() + "\n");
            builder.append("-----Address: " + student.getAddress() + "\n");
            builder.append("-----Zip: " + student.getZip() + "\n");
            builder.append("-----Email: " + student.getEmail() + "\n");
            builder.append("-----Phone: " + student.getPhonenumber() + "\n");

            cloneFields(alunoSiges, student, nacionalidades);

            //todo verificar isto
            //student.setAutoBlockMode(false);
            //student.setManualBlock(true);

            builder.append("DEPOIS: " + "\n");
            builder.append("BI: " + student.getBi() + "\n");
            builder.append("Nome: " + student.getName() + "\n");
            builder.append("Username: " + student.getUserNameNetpa() + "\n");
            builder.append("Address: " + student.getAddress() + "\n");
            builder.append("Zip: " + student.getZip() + "\n");
            builder.append("Email: " + student.getEmail() + "\n");
            builder.append("Phone: " + student.getPhonenumber() + "\n");

            serviceLogWarn(builder.toString());

            sendNotificationAdmin("CODIGO SIGES " + alunoSiges.getCodigo() + " MUDOU DE DONO - FOI BLOQUEADO ",builder.toString());


        }

        actualizaNacionalidade(alunoSiges, student, nacionalidades);

        if(alunoSiges.getTiposAlunosRepresentados() != null)
        {
            for(Aluno.TipoAluno tipo:alunoSiges.getTiposAlunosRepresentados())
            {
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_NORMAL))
                    student.setTipoAlunoNormal(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_ERASMUS))
                    student.setTipoAlunoErasmus(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_TRABALHADOR_ESTUDANTE))
                    student.setTipoAlunoTrabalhadorEstudante(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_BOLSEIRO))
                    student.setTipoAlunoBolseiro(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_BOMBEIRO))
                    student.setTipoAlunoBombeiro(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_DEFICIENTE))
                    student.setTipoAlunoDeficiente(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_DIRIGENTE_ASSOCIATIVO))
                    student.setTipoAlunoDirigenteAssociativo(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_MILITAR))
                    student.setTipoAlunoMilitar(true);
                if(tipo.getCodigoTipoAluno().equals(Globals.SIGES_TIPO_ALUNO_VASCODAGAMA))
                    student.setTipoAlunoVascodagama(true);
            }
        }
    }

    private void actualizaNacionalidade(Aluno alunoSiges, Student student, HashMap<Integer, Nacionalidade> nacionalidades) {
        //NEW CLONINNG NACIONALIDADE
        try{
            if(alunoSiges.getCodigoNacionalidade() != null)
            {
                Nacionalidade nac = nacionalidades.get(alunoSiges.getCodigoNacionalidade());
                if(nac != null)
                {
                    student.setCountry(nac.getPais());
                    student.setNacionalidade(nac.getNacionalidade());
                }
            }
        }
        catch(1.5.0/docs/api/java/lang/Throwable.html">Throwable t)
        {
            logger.error("NACIONALIDADE INVALIDA NO DOCENTE: " + alunoSiges.getCodigo());
        }
    }

    /*private CourseUnit tryFindCourseUnitWithOutTurma(DefaultLogMessages logMessages, String cdDuracao, String codigo,String codigoCurso,String cdLectivo,String cdTurma)
    {
        CourseUnit courseUnit = null;
        String msg = "Unit not found with turma code : semestre:" + cdDuracao + " codigo:" + codigo + " course:" + codigoCurso + " year:" + cdLectivo + " turma: " + cdTurma;
        logMessages.addMessage(new DefaultLogMessage("", LogMessageTypeEnum.WARNING,msg));
        serviceLogWarn(msg);
        logger.warn(msg);
        msg = "Trying without Turma code...";
        serviceLogWarn(msg);
        logger.warn(msg);
        List<CourseUnit> cus = DaoFactory.getCourseUnitDaoImpl().loadBySigesCode("" + codigo,"" + codigoCurso,cdDuracao,cdLectivo);
        if(cus != null && cus.size() == 1)
        {
            courseUnit = cus.get(0);
            msg = "Found ok...";
            serviceLogInfo(msg);
            logger.info(msg);
        }
        else if(cus !=null && cus.size() > 1)
        {
            courseUnit = cus.get(0);
            msg = "Found More than one, unexpected situation..." + cus.get(0).getId() + " - " + cus.get(1).getId();
            logMessages.addMessage(new DefaultLogMessage("", LogMessageTypeEnum.WARNING,msg));
            serviceLogWarn(msg);
            logger.warn(msg);
        }
        else
        {
            msg = "Not Found ...";
            serviceLogInfo(msg);
            logger.info(msg);
        }
        return courseUnit;

    }*/

    private void cloneFields(Aluno alunoSiges, Student student, HashMap<Integer, Nacionalidade> nacionalidades) {
        student.setName(alunoSiges.getNome());
        student.setEmail(alunoSiges.getEmail());
        student.setSigesCode(alunoSiges.getCodigo().intValue());
        student.setAddress(alunoSiges.getMorada());
        student.setPhonenumber(StringsUtils.cleanKeepNumbers(alunoSiges.getTelemovel()));
        student.setZip("" + alunoSiges.getCodigoPostal().intValue());
        student.setBi(alunoSiges.getNumeroBi());
        student.setSex(alunoSiges.getSexo());
        student.setUserNameNetpa(alunoSiges.getUsernameNetpa());
        student.setBirthDate(alunoSiges.getDataNascimento());
        student.setUsername("a" + alunoSiges.getCodigo().intValue());
        actualizaNacionalidade(alunoSiges, student, nacionalidades);
    }
    @1.5.0/docs/api/java/lang/Override.html">Override
    protected ILogMessages runJobServiceTask() throws 1.5.0/docs/api/java/lang/Throwable.html">Throwable {

        1.5.0/docs/api/java/lang/String.html">String importYear = getParametersMap().get(JOB_importYear_KEY).getObject();
        1.5.0/docs/api/java/lang/String.html">String institutionCode = getParametersMap().get(JOB_institution_KEY).getObject();
        ILogMessages messages = run(importYear,1.5.0/docs/api/java/lang/Integer.html">Integer.parseInt(institutionCode));
        return messages;

    }

    /**
     * Testar por aqui poi requer Super Role e assim e' autmatico
     *
     * @param args of main
     * @throws ServiceException on error
     */

    public static void main(1.5.0/docs/api/java/lang/String.html">String[] args) throws ServiceException
    {
        1.5.0/docs/api/java/lang/String.html">String year = DaoFactory.getConfigurationDaoImpl().getImportsDefaultImportYearCreateTransaction();
            1.5.0/docs/api/java/lang/System.html">System.out.println("YEAR:" + year);
        if(args != null && args.length > 0)
            year = args[0];
        1.5.0/docs/api/java/lang/String.html">String institutionCode = "3";
        if(args != null && args.length > 1)
            institutionCode = args[1];
        AbstractDao.getCurrentSession().beginTransaction();
        new ImportStudentsService().run(year,1.5.0/docs/api/java/lang/Integer.html">Integer.parseInt(institutionCode));
        AbstractDao.getCurrentSession().getTransaction().commit();
    }
}