Subversion Repositories bacoAlunos

package pt.estgp.estgweb.services.sigesimports;

import jomm.dao.impl.AbstractDao;

import org.apache.log4j.Logger;

import pt.estgp.estgweb.Globals;

import pt.estgp.estgweb.domain.Course;

import pt.estgp.estgweb.domain.CourseUnit;

import pt.estgp.estgweb.domain.CourseUnitImpl;

import pt.estgp.estgweb.domain.DomainObjectFactory;

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

import pt.estgp.estgweb.domain.views.CourseView;

import pt.estgp.estgweb.services.courses.CoursesService;

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.DisciplinaDao;

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

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

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.SQLException;

import java.util.*;

/**

 * @author Jorge Machado

 */

public class ImportCourseService 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(ImportCourseService.class);

    private CoursesService coursesService = new CoursesService();

    int newUnits = 0;

    int newCourses = 0;

    int unitsRepeated = 0;

    int unitsAtualizadas = 0;

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

    {

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

        serviceLogInfo(msgS);

        logger.info(msgS);

        newUnits = 0;

        newCourses = 0;

        unitsRepeated = 0;

        unitsAtualizadas = 0;

        DefaultLogMessages logMessages = new DefaultLogMessages();

        try

        {

            logMessages.addMessage(new DefaultLogMessage("import.semestre.separated", LogMessageTypeEnum.INFO, "instituicao " + DaoFactory.getConfigurationDaoImpl().getSigesInstitutionCode()));

            serviceLogInfo(logMessages.getLastMessage());

            HashMap<String, Disciplina> disciplinasMap = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapS1 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapS2 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapA = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapT1 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapT2 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapT3 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> disciplinasMapT4 = new HashMap<String, Disciplina>();

            HashMap<String, Disciplina> cursosMap = new HashMap<String, Disciplina>();

            /**

             * Build Course Units Maps

             */

            /*SiGesWEB service;

            String WSDL = DaoFactory.getConfigurationDaoImpl().getSigesWebServicesWsdl();

            try

            {

                serviceLogInfo("STARTING WEB SERVICE AT " + WSDL);

                service = new SiGesWEB(new URL(WSDL), new QName(Globals.SIGES_WEBSERVICE_TARGET_NAMESPACE, "SiGesWEB"));

            }

            catch (MalformedURLException e)

            {

                logger.fatal(e, e);

                logMessages.addMessage(new DefaultLogMessage("import.error",e.toString(),"erro na configuracao do WEB Service", LogMessageTypeEnum.INFO));

                serviceLogError(logMessages.getLastMessage(), e);

                return logMessages;

            }

            */

            DisciplinaDao service = DisciplinaDao.getInstance();

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

            importUnitsSemestre(service,conn, "S1", year, disciplinasMap, disciplinasMapS1, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "S2", year, disciplinasMap, disciplinasMapS2, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "A", year, disciplinasMap, disciplinasMapA, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "T1", year, disciplinasMap, disciplinasMapT1, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "T2", year, disciplinasMap, disciplinasMapT2, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "T3", year, disciplinasMap, disciplinasMapT3, cursosMap, logMessages);

            importUnitsSemestre(service,conn, "T4", year, disciplinasMap, disciplinasMapT4, cursosMap, logMessages);

            /**

             * Import Courses

             */

            logMessages.addMessage(new DefaultLogMessage("import.semestre.updating.courses", LogMessageTypeEnum.INFO));

            serviceLogInfo("updating courses");

            logger.info("updating courses");

            Set<Map.Entry<String, Disciplina>> set2 = cursosMap.entrySet();

            for (1.5.0/docs/api/java/util/Map.html">Map.Entry<String, Disciplina> entry : set2)

            {

                Disciplina d = entry.getValue();

                CourseView c = coursesService.loadCourseByCode("" + d.getCodigoCurso().intValue(),false);

//                Course c = DaoFactory.getCourseDaoImpl().findCourseByCode("" + d.getCodigoCurso());

                if (c == null)

                {

                    c = new CourseView();

                    newCourses++;

                    serviceLogInfo("New Course Found: (" +  d.getCodigoCurso() + ") " + d.getNomeCurso());

//                    DaoFactory.getCourseDaoImpl().save(c);

                }

                c.setName(d.getNomeCurso());

                if(d.getGrauCurso() == null || d.getGrauCurso().trim().length() == 0)

                    d.setGrauCurso("unknown");

                1.5.0/docs/api/java/lang/String.html">String grauBaco = ConfigProperties.getProperty("siges.degree."+d.getGrauCurso());

                c.setDegree(grauBaco);

                c.setCode("" + d.getCodigoCurso().intValue());

                c.setImportYear(year);

                c.setInstitutionalCode("" + d.getCodigoInstituicao().intValue());

                coursesService.submitCourse(c,null,null,0,null,null);

            }

            /**

             * Update Course Units

             */

            updateCourseUnits(disciplinasMapS1, "S1",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapS2, "S2",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapA, "A",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapT1, "T1",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapT2, "T2",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapT3, "T3",logMessages,year,service,conn);

            updateCourseUnits(disciplinasMapT4, "T4",logMessages,year,service,conn);

            conn.close();

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

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

            serviceLogInfo("#Courses Imported:" + cursosMap.size());

            serviceLogInfo("#Units Imported S1:" + disciplinasMapS1.size());

            serviceLogInfo("#Units Imported S2:" + disciplinasMapS2.size());

            serviceLogInfo("#Units Imported A:" + disciplinasMapA.size());

            serviceLogInfo("#Units Imported T1:" + disciplinasMapT1.size());

            serviceLogInfo("#Units Imported T2:" + disciplinasMapT2.size());

            serviceLogInfo("#Units Imported T3:" + disciplinasMapT3.size());

            serviceLogInfo("#Units Imported T4:" + disciplinasMapT4.size());

            serviceLogInfo("#New Courses Found:" + newCourses);

            serviceLogInfo("#New Units Found:" + newUnits);

            serviceLogInfo("#Regular Updated Units:" + unitsAtualizadas);

            serviceLogInfo("#Unidades Repetidas (A mesma para o conjunto (Codigo,Curso,Ano,Semestre)):" + unitsRepeated);

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

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

            logger.info("#Courses Imported:" + cursosMap.size());

            logger.info("#Units Imported S1:" + disciplinasMapS1.size());

            logger.info("#Units Imported S2:" + disciplinasMapS2.size());

            logger.info("#Units Imported A:" + disciplinasMapA.size());

            logger.info("#Units Imported T1:" + disciplinasMapT1.size());

            logger.info("#Units Imported T2:" + disciplinasMapT2.size());

            logger.info("#Units Imported T3:" + disciplinasMapT3.size());

            logger.info("#Units Imported T4:" + disciplinasMapT4.size());

            logger.info("#New Courses Found:" + newCourses);

            logger.info("#New Units Found:" + newUnits);

            logger.info("#Regular Updated Units:" + unitsAtualizadas);

            logger.info("#Unidades Repetidas (A mesma para o conjunto (Codigo,Curso,Ano,Semestre)):" + unitsRepeated);

        }

        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(logMessages.getLastMessage(), e);

            1.5.0/docs/api/java/lang/String.html">String cause = e.getCause() == null ? "" : e.getCause().toString();

            sendNotificationAdmin("Erro na importacao de sumarios",cause);

        }

        logger.info("terminating course import");

        serviceLogInfo("terminating course import");

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

        setProgress(100);

        return logMessages;

    }

    /**

     * 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();

        }

    }

    private void importUnitsSemestre(DisciplinaDao service,

                                     1.5.0/docs/api/java/sql/Connection.html">Connection conn,

                                     1.5.0/docs/api/java/lang/String.html">String semestre,

                                     1.5.0/docs/api/java/lang/String.html">String year,

                                     HashMap<String, Disciplina> disciplinasMap,

                                     HashMap<String, Disciplina> disciplinasMapSemestre,

                                     HashMap<String, Disciplina> cursosMap,

                                     DefaultLogMessages logMessages) throws 1.5.0/docs/api/java/sql/SQLException.html">SQLException {

        logMessages.addMessage(new DefaultLogMessage("import.semestre.course.units." + semestre, LogMessageTypeEnum.INFO));

        serviceLogInfo("importing " + semestre + " course units");

        logger.info("importing " + semestre + " course units");

        List<Disciplina> disciplinas = service.loadDisciplinas(DaoFactory.getConfigurationDaoImpl().getSigesInstitutionCode(), year, semestre,conn);

        for (Disciplina d : disciplinas)

        {

            if (disciplinasMap.get(getDisciplinaUniqueRef(d)) != null)

            {

                logMessages.addMessage(new DefaultLogMessage("import.semestre.repeated." + semestre, "unit: " + d.getCodigo().intValue(), "", LogMessageTypeEnum.WARNING));

                serviceLogWarn("repeated unit in " + semestre + ":" + d.getCodigo().intValue());

                logger.warn("repeated unit in " + semestre + ":" + d.getCodigo().intValue());

            }

            disciplinasMap.put(getDisciplinaUniqueRef(d), d);

            disciplinasMapSemestre.put(getDisciplinaUniqueRef(d), d);

            cursosMap.put(d.getCodigoCurso().intValue()+":"+year, d);

        }

    }

    private 1.5.0/docs/api/java/lang/String.html">String getDisciplinaUniqueRef(Disciplina d)

    {

        return d.getCodigo().intValue() + ":" + d.getCodigoCurso() + ":" + d.getCdDuracao(); // + ":" + d.getCdTurma();

    }

    public static final int SIGES_CODIGO_TIPO_DISCIPLINA_EXTRA_CURRICULAR = ConfigProperties.getIntProperty("siges.codigo.tipo.disciplina.extra.curricular");

    private void updateCourseUnits(HashMap<String, Disciplina> disciplinasMapS, 1.5.0/docs/api/java/lang/String.html">String semestre, DefaultLogMessages logMessages, 1.5.0/docs/api/java/lang/String.html">String year,DisciplinaDao service,1.5.0/docs/api/java/sql/Connection.html">Connection conn)

    {

        logMessages.addMessage(new DefaultLogMessage("import.semestre.updating.course.units." + semestre, LogMessageTypeEnum.INFO));

        logger.info("updating " + semestre + " course units");

        serviceLogInfo("updating " + semestre + " course units");

        Set<Map.Entry<String, Disciplina>> set = disciplinasMapS.entrySet();

        for (1.5.0/docs/api/java/util/Map.html">Map.Entry<String, Disciplina> entry : set)

        {

            Disciplina d = entry.getValue();

            //TIPO 6 é uma EXTRA CURRICULAR

            if(ImportStudentsService.isCursoFicticio(d.getCodigoCurso()))

            {

                logMessages.addMessage(new DefaultLogMessage("import.error","Ignorando disciplina com codigo de curso ficticio - codigo: " + d.getCodigoCurso(), " see log for details", LogMessageTypeEnum.WARNING));

                logger.warn(logMessages.getLastMessage());

                serviceLogWarn(logMessages.getLastMessage());

                continue;

            }

            //CourseUnit c = null;

            List<CourseUnit> cus = null;

            cus= DaoFactory.getCourseUnitDaoImpl().loadBySigesCodeUnique("" + d.getCodigo(), "" + d.getCodigoCurso(), semestre, year);

            if(cus != null && cus.size() > 1 )

            {

                unitsRepeated++;

                logMessages.addMessage(new DefaultLogMessage("import.warning","Unidade Repetida: (" + d.getCodigo() + ") curso: " + d.getCodigoCurso() + " " + semestre + " " + year, "see log for details, vai atualizar as duas", LogMessageTypeEnum.WARNING));

                logger.fatal(logMessages.getLastMessage());

                serviceLogWarn(logMessages.getLastMessage());

            }

            else if(cus != null && cus.size() == 1)

            {

                unitsAtualizadas++;

                1.5.0/docs/api/java/lang/String.html">String msg = "Regular unit update: " + "(" + d.getCodigo() + ") curso: " + d.getCodigoCurso() + " " + semestre + " " + year;

                logger.info(msg);

                serviceLogInfo(msg);

            }

            if (cus == null || cus.size() == 0)

            {

                CourseUnitImpl c = DomainObjectFactory.createCourseUnitImpl();

                DaoFactory.getCourseUnitDaoImpl().save(c);

                logMessages.addMessage(new DefaultLogMessage("import.error", "New Unit Found: (" +  d.getCodigo() + ") " + d.getNome() + " - curso (" + d.getNomeCurso() + ") " + d.getNomeCurso() + " turma(" + d.getCdTurma() + ")", "see log for details", LogMessageTypeEnum.INFO));

                logger.info(logMessages.getLastMessage());

                serviceLogInfo(logMessages.getLastMessage());

                newUnits++;

                cus = new ArrayList<CourseUnit>();

                cus.add(c);

            }

            //NOVO

            for(CourseUnit c: cus)

            {

                //todo deixa de atualizar c.setCdTurma("" + d.getCdTurma());

                c.setName(d.getNome());

                c.setInstitutionCode("" + DaoFactory.getConfigurationDaoImpl().getSigesInstitutionCode());

                c.setCode("" + d.getCodigo().intValue());

                c.setCourseCode("" + d.getCodigoCurso());

                c.setCourseName("" + d.getNomeCurso());

                c.setSemestre(semestre);

                c.setImportYear(year);

                Course course = DaoFactory.getCourseDaoImpl().findCourseByCode(c.getCourseCode());

                c.setCourse(course);

            }

        }

    }

    @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();

        ILogMessages messages = run(importYear);

        return messages;

    }

    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();

        if(args != null && args.length > 0)

            year = args[0];

        AbstractDao.getCurrentSession().beginTransaction();

        new ImportCourseService().run(year);

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

    }

}