WebSVN - bacoAlunos - Path Comparison - /branches/v3 Rev 1700 and /branches/v3 Rev 1701

Ignore whitespace Rev 1700 → Rev 1701

/branches/v3/impl/src/java/pt/estgp/estgweb/services/courses/CoursesCommonServices.java
1,7 → 1,6
package pt.estgp.estgweb.services.courses;

import org.apache.log4j.Logger;
import pt.estgp.estgweb.Globals;
import pt.estgp.estgweb.domain.Course;
import pt.estgp.estgweb.domain.DomainObject;
import pt.estgp.estgweb.domain.Teacher;
10,7 → 9,6
import pt.estgp.estgweb.services.common.*;
import pt.estgp.estgweb.services.common.impl.DefaultResult;
import pt.estgp.estgweb.services.common.impl.DefaultSearchResults;
import pt.estgp.estgweb.services.common.impl.DefaultToDo;
import pt.utl.ist.berserk.logic.serviceManager.IService;

import java.util.ArrayList;
137,6 → 135,7
}
}
}*/
/*
if(userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
{
List<Course> courses = DaoFactory.getCourseDaoImpl().findAll(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear());
149,7 → 148,7
todos.add(defaultToDo);
}
}
}/This method is invoked from object creation/
}//This method is invoked from object creation*/
return todos;
}

 /branches/v3/impl/src/java/pt/estgp/estgweb/domain/dao/impl/CourseDaoImpl.java
 ,6 → 7,7
 import org.hibernate.criterion.Expression;
 import org.hibernate.criterion.Order;
 import org.hibernate.criterion.Projections;
+import pt.estgp.estgweb.Globals;
 import pt.estgp.estgweb.domain.*;
 import pt.estgp.estgweb.domain.dao.DaoFactory;
 import pt.estgp.estgweb.domain.dao.DaoUtils;
 ,8 → 20,7
 import java.util.ArrayList;
 import java.util.List;
-import static org.hibernate.criterion.Restrictions.eq;
-import static org.hibernate.criterion.Restrictions.not;
+import static org.hibernate.criterion.Restrictions.*;
 /**
  * @author Jorge Machado
 ,6 → 408,78
         return findAllStatus(importYear,true);
     }
+    /**
+     * Return only courses if user is from CourseCommission or Coordinator or have role Globals.SERVICES_PROGRAMS_ROLE
+     * otherwise return null;
+     * @param importYear
+     * @param u
+     * @return
+     */
+    public List<Course> findActiveCoursesCoordinationsOrCommissions(String importYear,User u)
+    {
+        Criteria cri = getCriteriaForComissionsAndCoordinationsOr(u);
+        if(cri == null)
+            return new ArrayList<Course>();
+        return cri
+                //.add(eq("importYear", importYear)) Nao podemos ter isto senao caso tenhamos o sistema num ano de interface diferente nao vem cursos nenhuns a nao ser os que desapareceram
+                // no passado e mantiveram o ano anterior
+                .add(eq("status", true))
+                .addOrder(Order.asc("name"))
+                .list();
+    }
+    public Criteria getCriteriaForComissionsAndCoordinationsOr(User u)
+    {
+        return getCriteriaForComissionsAndCoordinationsOr(u,null,null);
+    }
+    /**
+     * Restricts only courses if user is from CourseCommission or Coordinator or have role Globals.SERVICES_PROGRAMS_ROLE
+     * @param u
+     * @return
+     */
+    public Criteria getCriteriaForComissionsAndCoordinationsOr(User u,String courseAlias,Criteria init)
+    {
+        if(courseAlias == null)
+            courseAlias = "";
+        else
+            courseAlias = courseAlias + ".";
+        if(u.hasRole(Globals.SERVICES_PROGRAMS_ROLE))
+        {
+            if(init != null)
+                return init;
+            else
+                return createCriteria();
+        }
+        else if(u instanceof TeacherImpl)
+        {
+            TeacherImpl tImpl = (TeacherImpl) DaoFactory.getTeacherDaoImpl().get(u.getId());
+            List<String> coordinatedRolesCourses = tImpl.obtainCourseComissionsAndCoordinationsRoles();
+            Criteria cri = init != null ? init : createCriteria();
+            if(coordinatedRolesCourses.size() > 0)
+            {
+                cri.createAlias(courseAlias + "coordinator", "coord");
+                Criterion criterion = eq("coord.id", u.getId());
+                for(String role: coordinatedRolesCourses)
+                {
+                    criterion = or(criterion,eq(courseAlias+"validationRole",role));
+                }
+                cri.add(criterion);
+                return cri;
+            }
+            else
+                return cri;
+        }
+        else
+        {
+            return null;
+        }
+    }
     public List<Course> findAllNotIn(String importYear)
     {
         return createCriteria().add(not(eq("importYear", importYear)))

 /branches/v3/impl/src/java/pt/estgp/estgweb/domain/dao/impl/CourseUnitDaoImpl.java
 ,6 → 15,7
 import pt.estgp.estgweb.utils.DatesUtils;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import static org.hibernate.criterion.Restrictions.*;
 ,6 → 659,21
                 .list();
     }
+    public List<CourseUnit> loadMissingProgramOptimizedComissionsAndSecreariat(User u)
+    {
+        Criteria crit = createCriteria()
+                .createAlias("course", "c")
+                .add(eq("importYear", DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear()))
+                .add(eq("semestre", DatesUtils.getSemestre()))
+                .add((or(isNull("programStreamId"), eq("programStreamId", ""))));
+        crit = DaoFactory.getCourseDaoImpl().getCriteriaForComissionsAndCoordinationsOr(u,"c",crit);
+        if(crit == null)
+            return new ArrayList<CourseUnit>();
+        else
+            return crit.list();
+    }
     public List<CourseUnit> loadMissingProgramGivenCourse(long courseId)
     {
         return createCriteria()
 ,12 → 691,29
                 .createAlias("course", "c")
                 .add(eq("c.id", courseId))
                 .add(eq("importYear", DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear()))
-                .add(eq("semestre", DatesUtils.getSemestre()))
+                //.add(eq("semestre", DatesUtils.getSemestre()))
                 .add((and(isNotNull("programStreamId"), not(eq("programStreamId", "")))))
                 .add((eq("validProgram", false)))
                 .list();
     }
+    public List<CourseUnit> loadMissingProgramValidateOptimizedComissionsAndSecreariat(User u)
+    {
+        Criteria crit = createCriteria()
+                .createAlias("course", "c")
+                .add(eq("importYear", DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear()))
+                //.add(eq("semestre", DatesUtils.getSemestre()))
+                .add((and(isNotNull("programStreamId"), not(eq("programStreamId", "")))))
+                .add((eq("validProgram", false)));
+        crit = DaoFactory.getCourseDaoImpl().getCriteriaForComissionsAndCoordinationsOr(u,"c",crit);
+        if(crit == null)
+            return new ArrayList<CourseUnit>();
+        else
+            return crit.list();
+    }
     public List<CourseUnit> loadMissingObjectivesOrProgramGivenCourse(long courseId)
     {
         return createCriteria()
 ,12 → 761,13
     public List<CourseMissingValidationProgram> loadMissingProgramValidate(UserSession userSession)
     {
         List<CourseMissingValidationProgram> result = new ArrayList<CourseMissingValidationProgram>();
-        List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCourses(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear());
+        //List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCourses(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear());
+        List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCoursesCoordinationsOrCommissions(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear(),userSession.getUser());
         for(Course course: courses)
         {
-            CourseImpl cImpl = (CourseImpl) DaoFactory.getCourseDaoImpl().narrow(course);
-            if(cImpl.isFromCourseCommission(userSession) || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
-            {
+            //CourseImpl cImpl = (CourseImpl) DaoFactory.getCourseDaoImpl().narrow(course);
+            //if(cImpl.isFromCourseCommission(userSession) || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
+            //{
                 List<CourseUnit> courseUnits = loadMissingProgramValidateGivenCourse(course.getId());
                 if(courseUnits != null && courseUnits.size() > 0)
                 {
 ,11 → 776,43
                     c.courseUnits = courseUnits;
                     result.add(c);
                 }
+            //}
+        }
+        return result;
+    }
+    //TODO
+    public List<CourseMissingValidationProgram> loadMissingProgramValidateOptimized(UserSession userSession)
+    {
+        List<CourseMissingValidationProgram> result = new ArrayList<CourseMissingValidationProgram>();
+        //todo Em vez de FindAll faco a listagem total de cadeiras e é la dentro que restringe ou a todas
+        //os cursos caso seja da secretaria ou aos cursos de que faz parte da comissao
+        //Obtenho todas as cadeiras de todos os cursos
+        //Organizo-as por curso
+        //devolvo a lista final
+        HashMap<Course,CourseMissingValidationProgram> mapaUnidadesCurso = new HashMap<Course, CourseMissingValidationProgram>();
+        List<CourseUnit> courseUnits = loadMissingProgramValidateOptimizedComissionsAndSecreariat(userSession.getUser());
+        for(CourseUnit cu : courseUnits)
+        {
+            if(mapaUnidadesCurso.get(cu.getCourse()) == null)
+            {
+                CourseMissingValidationProgram c = new CourseMissingValidationProgram();
+                c.course = DaoFactory.getCourseDaoImpl().narrow(cu.getCourse());
+                c.courseUnits = new ArrayList<CourseUnit>();
+                c.courseUnits.add(cu);
+                result.add(c);
+                mapaUnidadesCurso.put(c.course,c);
             }
+            else
+            {
+                CourseMissingValidationProgram c = mapaUnidadesCurso.get(cu.getCourse());
+                c.courseUnits.add(cu);
+            }
         }
         return result;
     }
     /**
      * Load all programs missing from active courses
      * @param userSession
 ,13 → 821,13
     public List<CourseMissingValidationProgram> loadMissingPrograms(UserSession userSession)
     {
         List<CourseMissingValidationProgram> result = new ArrayList<CourseMissingValidationProgram>();
-        List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCourses(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear());
+        //List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCourses(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear());
+        List<Course> courses = DaoFactory.getCourseDaoImpl().findActiveCoursesCoordinationsOrCommissions(DaoFactory.getConfigurationDaoImpl().getInterfaceImportYear(),userSession.getUser());
         for(Course course: courses)
         {
-            //TODO IR BUSCAR APENAS CURSOS DAS COMISSOES OU COORDENACOES PARA ABREVIAR
-            CourseImpl cImpl = (CourseImpl) DaoFactory.getCourseDaoImpl().narrow(course);
-            if(cImpl.isFromCourseCommission(userSession) || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
-            {
+            //CourseImpl cImpl = (CourseImpl) DaoFactory.getCourseDaoImpl().narrow(course);
+            //if(cImpl.isFromCourseCommission(userSession) || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
+            //{
                 List<CourseUnit> courseUnits = loadMissingProgramGivenCourse(course.getId());
                 if(courseUnits != null && courseUnits.size() > 0)
                 {
 ,16 → 836,54
                     c.courseUnits = courseUnits;
                     result.add(c);
                 }
+            //}
+        }
+        return result;
+    }
+    public List<CourseMissingValidationProgram> loadMissingProgramsOptimized(UserSession userSession)
+    {
+        List<CourseMissingValidationProgram> result = new ArrayList<CourseMissingValidationProgram>();
+        //todo Em vez de FindAll faco a listagem total de cadeiras e é la dentro que restringe ou a todas
+        //os cursos caso seja da secretaria ou aos cursos de que faz parte da comissao
+        //Obtenho todas as cadeiras de todos os cursos
+        //Organizo-as por curso
+        //devolvo a lista final
+        HashMap<Course,CourseMissingValidationProgram> mapaUnidadesCurso = new HashMap<Course, CourseMissingValidationProgram>();
+        List<CourseUnit> courseUnits = loadMissingProgramOptimizedComissionsAndSecreariat(userSession.getUser());
+        for(CourseUnit cu : courseUnits)
+        {
+            if(mapaUnidadesCurso.get(cu.getCourse()) == null)
+            {
+                CourseMissingValidationProgram c = new CourseMissingValidationProgram();
+                c.course = DaoFactory.getCourseDaoImpl().narrow(cu.getCourse());
+                c.courseUnits = new ArrayList<CourseUnit>();
+                c.courseUnits.add(cu);
+                result.add(c);
+                mapaUnidadesCurso.put(c.course,c);
             }
+            else
+            {
+                CourseMissingValidationProgram c = mapaUnidadesCurso.get(cu.getCourse());
+                c.courseUnits.add(cu);
+            }
         }
         return result;
     }
     public static class CourseMissingValidationEvaluation
     {
         public Course course;
         public List<CourseUnit> courseUnits;
     }
+    /**
+     * METODO ANTIGO QUE ESTAVA NA COURSE COMISSION
+     * @param userSession
+     * @return
+     */
     public List<CourseMissingValidationEvaluation> loadMissingEvaluationValidate(UserSession userSession)
     {
         List<CourseMissingValidationEvaluation> result = new ArrayList<CourseMissingValidationEvaluation>();
 ,7 → 891,7
         for(Course course: courses)
         {
             CourseImpl cImpl = (CourseImpl) DaoFactory.getCourseDaoImpl().narrow(course);
-            if(cImpl.isFromCourseCommission(userSession)  || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
+            if(cImpl.isFromCourseCommission(userSession) || userSession.getUser().hasRole(Globals.SERVICES_PROGRAMS_ROLE))
             {
                 List<CourseUnit> courseUnits = loadMissingEvaluationValidateGivenCourse(course.getId());
                 if(courseUnits != null && courseUnits.size() > 0)
 ,8 → 906,73
         return result;
     }
+    public List<CourseMissingValidationEvaluation> loadMissingEvaluationValidateOptimized(UserSession userSession)
+    {
+        List<CourseMissingValidationEvaluation> result = new ArrayList<CourseMissingValidationEvaluation>();
+        //todo Em vez de FindAll faco a listagem total de cadeiras e é la dentro que restringe ou a todas
+        //os cursos caso seja da secretaria ou aos cursos de que faz parte da comissao
+        //Obtenho todas as cadeiras de todos os cursos
+        //Organizo-as por curso
+        //devolvo a lista final
+        HashMap<Course,CourseMissingValidationEvaluation> mapaUnidadesCurso = new HashMap<Course, CourseMissingValidationEvaluation>();
+        List<CourseUnit> courseUnits = loadMissingEvaluationValidateOptimizedComissionsAndSecreariat(userSession.getUser());
+        for(CourseUnit cu : courseUnits)
+        {
+            if(mapaUnidadesCurso.get(cu.getCourse()) == null)
+            {
+                CourseMissingValidationEvaluation c = new CourseMissingValidationEvaluation();
+                c.course = DaoFactory.getCourseDaoImpl().narrow(cu.getCourse());
+                c.courseUnits = new ArrayList<CourseUnit>();
+                c.courseUnits.add(cu);
+                result.add(c);
+                mapaUnidadesCurso.put(c.course,c);
+            }
+            else
+            {
+                CourseMissingValidationEvaluation c = mapaUnidadesCurso.get(cu.getCourse());
+                c.courseUnits.add(cu);
+            }
+        }
+        return result;
+    }
+    //TODO PARA USAR MAIS TARDE
+    /**
+     * @param u utilizador com vista para cursos
+     *          Se for secretaria considera todos os cursos
+     *          Se nao for considera apenas comissoes de curso do professor se for TeacherImpl
+     * @return
+     */
+    public List<CourseUnit> loadMissingEvaluationValidateOptimizedComissionsAndSecreariat(User u)
+    {
+        String activeYear = DaoFactory.getConfigurationDaoImpl().getCourseUnitEvaluationActiveYear();
+        Criterion degreesCrit = getCourseUnitActiveDegreeCourseIdsCriterion(activeYear);
+        if(degreesCrit == null)
+            return new ArrayList<CourseUnit>();
+        Criteria c = createCriteria()
+                .createAlias("course", "c")
+                .createAlias("courseUnitEvaluation", "ce")
+                .add(eq("importYear", activeYear))
+                .add(degreesCrit)
+                .add((eq("ce.closed", false)))
+                .add((eq("ce.teacherComplete", true)));
+        //NOVO para restringir os cursos de que é coordenador ou todos se for da secretaria de cursos
+        c = DaoFactory.getCourseDaoImpl().getCriteriaForComissionsAndCoordinationsOr(u,"c",c);
+        if(c == null)
+            return new ArrayList<CourseUnit>();
+        else
+            return c.list();
+    }
     /*
     * Neste caso apenas se validam as do ano anterior*/
 ,7 → 1098,38
         return teacherCompleteFalse;
     }
+    public List<CourseMissingValidationEvaluation> loadMissingEvaluationOptimized(UserSession userSession)
+    {
+        List<CourseMissingValidationEvaluation> result = new ArrayList<CourseMissingValidationEvaluation>();
+        //todo Em vez de FindAll faco a listagem total de cadeiras e é la dentro que restringe ou a todas
+        //os cursos caso seja da secretaria ou aos cursos de que faz parte da comissao
+        //Obtenho todas as cadeiras de todos os cursos
+        //Organizo-as por curso
+        //devolvo a lista final
+        HashMap<Course,CourseMissingValidationEvaluation> mapaUnidadesCurso = new HashMap<Course, CourseMissingValidationEvaluation>();
+        List<CourseUnit> courseUnits = loadMissingEvaluationOptimizedComissionsAndSecreariat(userSession.getUser());
+        for(CourseUnit cu : courseUnits)
+        {
+            if(mapaUnidadesCurso.get(cu.getCourse()) == null)
+            {
+                CourseMissingValidationEvaluation c = new CourseMissingValidationEvaluation();
+                c.course = DaoFactory.getCourseDaoImpl().narrow(cu.getCourse());
+                c.courseUnits = new ArrayList<CourseUnit>();
+                c.courseUnits.add(cu);
+                result.add(c);
+                mapaUnidadesCurso.put(c.course,c);
+            }
+            else
+            {
+                CourseMissingValidationEvaluation c = mapaUnidadesCurso.get(cu.getCourse());
+                c.courseUnits.add(cu);
+            }
+        }
+        return result;
+    }
     public List<CourseMissingValidationEvaluation> loadMissingEvaluation(UserSession userSession)
     {
         List<CourseMissingValidationEvaluation> result = new ArrayList<CourseMissingValidationEvaluation>();
 ,6 → 1152,43
         return result;
     }
+    public List<CourseUnit> loadMissingEvaluationOptimizedComissionsAndSecreariat(User u)
+    {
+        String activeYear = DaoFactory.getConfigurationDaoImpl().getCourseUnitEvaluationActiveYear();
+        Criterion degreesCrit = getCourseUnitActiveDegreeCourseIdsCriterion(activeYear);
+        if(degreesCrit == null)
+            return new ArrayList<CourseUnit>();
+        Criteria nullsCrit = createCriteria()
+                .createAlias("course", "c")
+                .add(eq("importYear", activeYear))
+                .add(degreesCrit)
+                .add(isNull("courseUnitEvaluation"));
+        Criteria teachrCompleteCrit = createCriteria()
+                .createAlias("course", "c")
+                .createAlias("courseUnitEvaluation", "ce")
+                .add(degreesCrit)
+                .add(eq("importYear", activeYear))
+                .add(eq("ce.teacherComplete", false));
+        //NOVO para restringir os cursos de que é coordenador ou todos se for da secretaria de cursos
+        nullsCrit = DaoFactory.getCourseDaoImpl().getCriteriaForComissionsAndCoordinationsOr(u,"c",nullsCrit);
+        if(nullsCrit == null)
+            return new ArrayList<CourseUnit>();
+        teachrCompleteCrit = DaoFactory.getCourseDaoImpl().getCriteriaForComissionsAndCoordinationsOr(u,"c",teachrCompleteCrit);
+        if(teachrCompleteCrit == null)
+            return new ArrayList<CourseUnit>();
+        List<CourseUnit> nulls = nullsCrit.list();
+        List<CourseUnit> teacherCompleteFalse = teachrCompleteCrit.list();
+        teacherCompleteFalse.addAll(nulls);
+        return teacherCompleteFalse;
+    }
     public List<CourseUnit> loadMissingEvaluation(long courseId)
     {

 /branches/v3/impl/src/java/pt/estgp/estgweb/domain/TeacherImpl.java
 ,4 → 328,9
         }
         return comissionsRoles;
     }
+    public boolean hasCoordinationsOrBelongToCourseCommissions()
+    {
+        return obtainCourseComissionsAndCoordinationsRoles().size() > 0;
+    }
 }

 /branches/v3/impl/src/java/pt/estgp/estgweb/domain/views/UserView.java
 ,6 → 65,7
     private boolean autoBlock;
     private boolean manualBlock;
+    private List<String> courseComissionsAndCoordinationsRoles;
     private List<RecordView> creatorRecords;
     private List<RecordView> contributorRecords;
 ,7 → 136,22
         {
             mainArea = ((Teacher)user).getMainArea();
             code = ((Teacher)user).getSigesCode();
-            this.academicDegree = ((Teacher)user).getAcademicDegree();
+            this.academicDegree = ((Teacher)user).getAcademicDegree();
+            try{
+                TeacherImpl tImpl;
+                if(!(user instanceof TeacherImpl))
+                {
+                    tImpl = (TeacherImpl) DaoFactory.getTeacherDaoImpl().get(user.getId());
+                }
+                else
+                {
+                    tImpl = (TeacherImpl) user;
+                }
+                this.courseComissionsAndCoordinationsRoles = tImpl.obtainCourseComissionsAndCoordinationsRoles();
+            }catch(Throwable e)
+            {
+                logger.warn("Probably no transaction trying to load course comissions and coordinations roles");
+            }
         }
         else if(user instanceof Student)
         {
 ,6 → 161,21
         }
     }
+    public List<String> getCourseComissionsAndCoordinationsRoles()
+    {
+        return courseComissionsAndCoordinationsRoles;
+    }
+    public boolean hasCoordinationsOrBelongToCourseCommissions()
+    {
+        if(courseComissionsAndCoordinationsRoles != null)
+            return getCourseComissionsAndCoordinationsRoles().size() > 0;
+        return false;
+    }
+    public void setCourseComissionsAndCoordinationsRoles(List<String> courseComissionsAndCoordinationsRoles) {
+        this.courseComissionsAndCoordinationsRoles = courseComissionsAndCoordinationsRoles;
+    }
     public List<CourseUnitView> getResponsableCourseUnits() {
         return responsableCourseUnits;
     }

 /branches/v3/impl/src/java/pt/estgp/estgweb/web/form/courseunits/CourseUnitsForm.java
 ,12 → 220,26
             return errors;
         }
-        if(getUploadFile().getFileSize() > Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES)
+        if(getUploadFile() == null || getUploadFile().getFileSize() == 0)
         {
-            addMessage(errors, httpServletRequest, "errors.file.too.long",  Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES + "MB");
+            addMessageAsString(errors,"Um Ficheiro esta Vazio");
             return errors;
         }
+        //tod verificar
+        try{
+            double fileSize = getUploadFile().getFileSize();
+            fileSize = fileSize / 1024.0 / 1024.0;
+            if(fileSize > Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES)
+            {
+                addMessage(errors, httpServletRequest, "errors.file.too.long",  Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES + "MB");
+                return errors;
+            }
+        }catch(Throwable e)
+        {
+            //muito pequeno se dividir por 0 nao faz mal
+        }
         if(courseUnitAssignementView.getDeliverDate() == null || courseUnitAssignementView.getDeliverDate().length() == 0)
         {
             addMessageWithKeys(errors,httpServletRequest,"errors.required","courseunit.assignement.deliver.date");
 ,6 → 262,20
         {
             addMessage(errors,httpServletRequest,"errors.courseunit.assignement.deliver.file");
         }
+        //tod verificar
+        try{
+            double fileSize = uploadFile.getFileSize();
+            fileSize = fileSize / 1024.0 / 1024.0;
+            if(fileSize > Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES)
+            {
+                addMessage(errors, httpServletRequest, "errors.file.too.long",  Globals.MAX_FILE_UPOLOAD_SIZE_MBYTES + "MB");
+                return errors;
+            }
+        }catch(Throwable e)
+        {
+            //muito pequeno se dividir por 0 nao faz mal
+        }
 //        if(uploadFile != null && uploadFile.getFileName() !=null && !uploadFile.getFileName().endsWith(".zip"))
 //        {
 //            addMessage(errors,httpServletRequest,"errors.courseunit.assignement.deliver.zip");

 /branches/v3/impl/src/doc/arquiteturaRequisitosDesenvolvimento/rolesUtilizacaoPreCondicoes.txt
 New file
 ,0 → 1,28
+######
+Requisitos de utilização dos UserRolesConfigs e dos Roles em String
+######
+##########################################################
+ALTERAÇÕES AO MODELO QUE USEM ROLES COMO STRING
+##########################################################
+Sempre que uma classe use roles deve ser atualizado o servico de substituicao de roles
+class: pt.estgp.estgweb.services.users.UserRoleConfigService
+metodo: addUpdateRole
+notas: deve adicionar um novo verificador de substituicao de role quando um role é substituido na administracao
+Locais que referenciam este serviço:
+ - interface: Configuração de Papeis Institucionais - salvar role com chave modificada
+ - interface: Gestão de Papeis Institucionais - Papeis de Coordenações - Criar e Normalizar Role
+Controladores que usem estes serviços dos Roles devem chamar o UserRoleProxy na camada de serviço
+para marcar os Roles como Dirty a fim de os recarregar para a cache
+Locais que referenciam este serviço:
+  class: pt.estgp.estgweb.web.controllers.courses.CoursesController
+  método: addCourseComissionRole
+  chamada necessária: UserRoleProxy.setDirty();

 /branches/v3/impl/src/web/user/home/teacher.jsp
 ,12 → 6,13
 <%@ taglib uri="/WEB-INF/tlds/struts-tiles.tld" prefix="tiles" %>
 <%@ taglib uri="/WEB-INF/tlds/baco.tld" prefix="baco" %>
 <%@ taglib uri="/WEB-INF/tlds/jomm.tld" prefix="jomm" %>
+<%@ page import="jomm.dao.impl.AbstractDao" %>
 <%@ page import="jomm.dao.utils.HibernateUtils" %>
 <%@ page import="jomm.utils.MessageResources" %>
 <%@ page import="pt.estgp.estgweb.domain.CourseUnit" %>
+<%@ page import="pt.estgp.estgweb.domain.Teacher" %>
 <%@ page import="pt.estgp.estgweb.domain.TeacherImpl" %>
 <%@ page import="pt.estgp.estgweb.domain.dao.DaoFactory" %>
-<%@ page import="pt.estgp.estgweb.domain.dao.impl.CourseUnitDaoImpl" %>
 <%@ page import="pt.estgp.estgweb.utils.DatesUtils" %>
 <%@ page import="java.util.List" %>
 <jsp:useBean id="UserSession" type="pt.estgp.estgweb.domain.UserSessionImpl" scope="request"/>
 ,8 → 154,11
         <div class="col-md-6 col-sm-12 col-xs-12" style="padding-left: 6px">
             <%
-                //todo METER AQUI FORMA DE CAREGAR OS PROFS TODOS QUE TÊM COORDENACOES
-                if(true || UserSession.getUser().getRoles().indexOf("courseValidateProgram")>=0)
+                AbstractDao.getCurrentSession().beginTransaction();
+                TeacherImpl tLoggedIn = (TeacherImpl) DaoFactory.getTeacherDaoImpl().get(UserSession.getUser().getId());
+                boolean hasCommisionsOrCoordinations = tLoggedIn.hasCoordinationsOrBelongToCourseCommissions();
+                AbstractDao.getCurrentSession().getTransaction().commit();
+                if( hasCommisionsOrCoordinations )
                 {
             %>
                     <div class="panel panel-primary">
 ,6 → 201,7
                     <jsp:include page="courseComission.jsp"/>
             <%
                 }
             %>
 ,10 → 214,10
                     long time = System.currentTimeMillis();
                     List<CourseUnit> evaluations = DaoFactory.getCourseUnitDaoImpl().loadTeacherUnitsMissingEvaluation(UserSession);
-                    System.out.println("TIME10: " + (System.currentTimeMillis()-time));
+                    //System.out.println("TIME10: " + (System.currentTimeMillis()-time));
                     time = System.currentTimeMillis();
                     List<CourseUnit> programs = DaoFactory.getCourseUnitDaoImpl().loadMissingPrograms(UserSession.getUser().getId());
-                    System.out.println("TIME11: " + (System.currentTimeMillis()-time));
+                    //System.out.println("TIME11: " + (System.currentTimeMillis()-time));
                     time = System.currentTimeMillis();
                     if(programs != null && programs.size() > 0 || evaluations!= null && evaluations.size() > 0)
                     {

 /branches/v3/impl/src/web/user/home/courseComission.jsp
 ,17 → 13,27
         String activeYear = DaoFactory.getConfigurationDaoImpl().getCourseUnitEvaluationActiveYear();
         List<String> activeDegrees = DaoFactory.getConfigurationDaoImpl().getCourseUnitEvaluationActiveDegrees();
         long time = System.currentTimeMillis();
-        List<CourseUnitDaoImpl.CourseMissingValidationProgram> result0 = DaoFactory.getCourseUnitDaoImpl().loadMissingPrograms(UserSession);
-        //System.out.println("TIME1: " + (System.currentTimeMillis()-time));
+        //List<CourseUnitDaoImpl.CourseMissingValidationProgram> result0 = DaoFactory.getCourseUnitDaoImpl().loadMissingPrograms(UserSession);
+        List<CourseUnitDaoImpl.CourseMissingValidationProgram> result0 = DaoFactory.getCourseUnitDaoImpl().loadMissingProgramsOptimized(UserSession);
+        System.out.println("TIME1: " + (System.currentTimeMillis()-time));
         time = System.currentTimeMillis();
-        List<CourseUnitDaoImpl.CourseMissingValidationProgram> result1 = DaoFactory.getCourseUnitDaoImpl().loadMissingProgramValidate(UserSession);
-        //System.out.println("TIME2: " + (System.currentTimeMillis()-time));
+        //List<CourseUnitDaoImpl.CourseMissingValidationProgram> result1 = DaoFactory.getCourseUnitDaoImpl().loadMissingProgramValidate(UserSession);
+        List<CourseUnitDaoImpl.CourseMissingValidationProgram> result1 = DaoFactory.getCourseUnitDaoImpl().loadMissingProgramValidateOptimized(UserSession);
+        System.out.println("TIME2: " + (System.currentTimeMillis()-time));
         time = System.currentTimeMillis();
-        List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result2 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluationValidate(UserSession);
-        //System.out.println("TIME3: " + (System.currentTimeMillis()-time));
+        // media de 4000 milis para administradores de programas
+        //List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result2 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluationValidate(UserSession);
+        //novo demora 90 em media
+        List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result2 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluationValidateOptimized(UserSession);
+        System.out.println("TIME3: " + (System.currentTimeMillis()-time));
         time = System.currentTimeMillis();
-        List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result3 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluation(UserSession);
-        //System.out.println("TIME4: " + (System.currentTimeMillis()-time));
+        // media de 4000 milis para administradores de programas
+        //List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result3 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluation(UserSession);
+        //novo demora 90 em media
+        List<CourseUnitDaoImpl.CourseMissingValidationEvaluation> result3 = DaoFactory.getCourseUnitDaoImpl().loadMissingEvaluationOptimized(UserSession);
+        System.out.println("TIME4: " + (System.currentTimeMillis()-time));
         time = System.currentTimeMillis();
         if(result0.size() > 0 || result1.size() > 0 || result2.size() > 0 || result3.size()>0)
         {

Subversion Repositories bacoAlunos

Compare Revisions

Ignore whitespace Rev 1700 → Rev 1701