private void setFromRequest(HttpServletRequest request) {
    InfoExecutionDegree infoExecutionDegree =
        (InfoExecutionDegree) request.getAttribute(PresentationConstants.EXECUTION_DEGREE);

    String shift = request.getParameter("shift");
    if (shift == null) {
      shift = (String) request.getAttribute("shift");
    }
    if (shift == null) {
      shift = "false";
    }

    request.setAttribute("shift", shift);

    String degreeId = getFromRequest("degreeID", request);
    if (degreeId == null) {
      degreeId = infoExecutionDegree.getInfoDegreeCurricularPlan().getInfoDegree().getExternalId();
    }
    request.setAttribute("degreeID", degreeId);

    String executionDegreeId = getFromRequest("executionDegreeID", request);
    if (executionDegreeId == null) {
      executionDegreeId = infoExecutionDegree.getExternalId();
    }
    request.setAttribute("executionDegreeID", executionDegreeId);
    String degreeCurricularPlanId = getFromRequest("degreeCurricularPlanID", request);
    if (degreeCurricularPlanId == null) {
      degreeCurricularPlanId = infoExecutionDegree.getInfoDegreeCurricularPlan().getExternalId();
    }
    request.setAttribute("degreeCurricularPlanID", degreeCurricularPlanId);
  }
  public ActionForward nextPage(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

    DynaActionForm escolherContextoForm = (DynaActionForm) form;

    String nextPage = (String) request.getAttribute(PresentationConstants.NEXT_PAGE);
    if (nextPage == null) {
      nextPage = request.getParameter(PresentationConstants.NEXT_PAGE);
    }

    Integer semestre =
        ((InfoExecutionPeriod) request.getAttribute(PresentationConstants.EXECUTION_PERIOD))
            .getSemester();
    Integer anoCurricular = (Integer) escolherContextoForm.get("curricularYear");

    int index = Integer.parseInt((String) escolherContextoForm.get("index"));

    request.setAttribute("anoCurricular", anoCurricular);
    request.setAttribute("semestre", semestre);

    List infoExecutionDegreeList =
        ReadExecutionDegreesByExecutionYear.run(
            ((InfoExecutionPeriod) request.getAttribute(PresentationConstants.EXECUTION_PERIOD))
                .getInfoExecutionYear());
    List licenciaturas = new ArrayList();
    licenciaturas.add(new LabelValueBean("escolher", ""));
    Collections.sort(infoExecutionDegreeList, new ComparatorByNameForInfoExecutionDegree());
    // ////

    InfoExecutionDegree infoExecutionDegree =
        (InfoExecutionDegree) infoExecutionDegreeList.get(index);

    if (infoExecutionDegree != null) {
      CurricularYearAndSemesterAndInfoExecutionDegree cYSiED =
          new CurricularYearAndSemesterAndInfoExecutionDegree(
              anoCurricular, semestre, infoExecutionDegree);
      request.setAttribute(PresentationConstants.CONTEXT_KEY, cYSiED);

      request.setAttribute(PresentationConstants.CURRICULAR_YEAR_KEY, anoCurricular);
      request.setAttribute(PresentationConstants.CURRICULAR_YEAR_OID, anoCurricular.toString());
      request.setAttribute(PresentationConstants.INFO_EXECUTION_DEGREE_KEY, infoExecutionDegree);
      request.setAttribute(PresentationConstants.EXECUTION_DEGREE, infoExecutionDegree);
      request.setAttribute(
          PresentationConstants.EXECUTION_DEGREE_OID,
          infoExecutionDegree.getExternalId().toString());
    } else {
      return mapping.findForward("Licenciatura execucao inexistente");
    }

    if (nextPage != null) {
      return mapping.findForward(nextPage);
    }

    // TODO : throw a proper exception
    throw new Exception("SomeOne is messing around with the links");
  }
  /**
   * Method existencesOfInfoDegree.
   *
   * @param executionDegreeList
   * @param infoExecutionDegree
   * @return int
   */
  private boolean duplicateInfoDegree(
      List executionDegreeList, InfoExecutionDegree infoExecutionDegree) {
    InfoDegree infoDegree = infoExecutionDegree.getInfoDegreeCurricularPlan().getInfoDegree();
    Iterator iterator = executionDegreeList.iterator();

    while (iterator.hasNext()) {
      InfoExecutionDegree infoExecutionDegree2 = (InfoExecutionDegree) iterator.next();
      if (infoDegree.equals(infoExecutionDegree2.getInfoDegreeCurricularPlan().getInfoDegree())
          && !(infoExecutionDegree.equals(infoExecutionDegree2))) {
        return true;
      }
    }
    return false;
  }
  public List<InfoExecutionCourse> run(
      InfoExecutionPeriod infoExecutionPeriod,
      InfoExecutionDegree infoExecutionDegree,
      InfoCurricularYear infoCurricularYear,
      String executionCourseName) {

    List<InfoExecutionCourse> result = null;

    final ExecutionSemester executionSemester =
        FenixFramework.getDomainObject(infoExecutionPeriod.getExternalId());

    ExecutionDegree executionDegree = null;
    if (infoExecutionDegree != null) {
      executionDegree = FenixFramework.getDomainObject(infoExecutionDegree.getExternalId());
    }

    CurricularYear curricularYear = null;
    if (infoCurricularYear != null) {
      curricularYear = FenixFramework.getDomainObject(infoCurricularYear.getExternalId());
    }

    List<ExecutionCourse> executionCourses = new ArrayList<ExecutionCourse>();
    if (executionSemester != null) {
      executionCourses =
          executionSemester
              .getExecutionCoursesByDegreeCurricularPlanAndSemesterAndCurricularYearAndName(
                  executionDegree.getDegreeCurricularPlan(), curricularYear, executionCourseName);
    }

    return fillInfoExecutionCourses(executionSemester.getAcademicInterval(), executionCourses);
  }
示例#5
0
  public InfoExecutionDegree run(Integer idInternal) throws FenixServiceException {
    final ExecutionDegree executionDegree = rootDomainObject.readExecutionDegreeByOID(idInternal);

    if (executionDegree == null) {
      throw new NonExistingServiceException();
    }

    return InfoExecutionDegree.newInfoFromDomain(executionDegree);
  }
 @Atomic
 public static List<InfoExecutionCourse> runSearchExecutionCourses(
     InfoExecutionPeriod infoExecutionPeriod,
     InfoExecutionDegree infoExecutionDegree,
     InfoCurricularYear infoCurricularYear,
     String executionCourseName)
     throws NotAuthorizedException {
   CoordinatorExecutionDegreeAuthorizationFilter.instance.execute(
       infoExecutionDegree.getExternalId());
   return serviceInstance.run(
       infoExecutionPeriod, infoExecutionDegree, infoCurricularYear, executionCourseName);
 }
  private List getExecutionDegrees(HttpServletRequest request) throws FenixServiceException {
    InfoExecutionPeriod infoExecutionPeriod =
        (InfoExecutionPeriod) request.getAttribute("infoExecutionPeriod");

    List<InfoExecutionDegree> executionDegrees =
        ReadExecutionDegreesByExecutionYearAndDegreeType.run(
            infoExecutionPeriod.getInfoExecutionYear().getYear(), null);

    ComparatorChain comparatorChain = new ComparatorChain();

    comparatorChain.addComparator(
        new BeanComparator("infoDegreeCurricularPlan.infoDegree.tipoCurso"));
    comparatorChain.addComparator(new BeanComparator("infoDegreeCurricularPlan.infoDegree.nome"));

    Collections.sort(executionDegrees, comparatorChain);

    MessageResources messageResources = this.getResources(request, "ENUMERATION_RESOURCES");
    executionDegrees =
        InfoExecutionDegree.buildLabelValueBeansForList(executionDegrees, messageResources);

    return executionDegrees;
  }
  /*
   * (non-Javadoc)
   *
   * @see
   * org.apache.struts.actions.DispatchAction#dispatchMethod(org.apache.struts
   * .action.ActionMapping, org.apache.struts.action.ActionForm,
   * javax.servlet.http.HttpServletRequest,
   * javax.servlet.http.HttpServletResponse, java.lang.String)
   */
  public ActionForward prepare(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

    String inputPage = request.getParameter(PresentationConstants.INPUT_PAGE);
    String nextPage = request.getParameter(PresentationConstants.NEXT_PAGE);
    if (inputPage != null) {
      request.setAttribute(PresentationConstants.INPUT_PAGE, inputPage);
    }
    if (nextPage != null) {
      request.setAttribute(PresentationConstants.NEXT_PAGE, nextPage);
    }

    User userView = Authenticate.getUser();

    InfoExecutionPeriod infoExecutionPeriod = setExecutionContext(request);

    // TODO: this semester and curricular year list needs to be
    // refactored in order to incorporate masters
    /* Criar o bean de semestres */
    List semestres = new ArrayList();
    semestres.add(new LabelValueBean("escolher", ""));
    semestres.add(new LabelValueBean("1 º", "1"));
    semestres.add(new LabelValueBean("2 º", "2"));
    request.setAttribute("semestres", semestres);

    /* Criar o bean de anos curricutares */
    List anosCurriculares = new ArrayList();
    anosCurriculares.add(new LabelValueBean("escolher", ""));
    anosCurriculares.add(new LabelValueBean("1 º", "1"));
    anosCurriculares.add(new LabelValueBean("2 º", "2"));
    anosCurriculares.add(new LabelValueBean("3 º", "3"));
    anosCurriculares.add(new LabelValueBean("4 º", "4"));
    anosCurriculares.add(new LabelValueBean("5 º", "5"));
    request.setAttribute(PresentationConstants.CURRICULAR_YEAR_LIST_KEY, anosCurriculares);

    /* Cria o form bean com as licenciaturas em execucao. */

    List executionDegreeList =
        ReadExecutionDegreesByExecutionYear.run(infoExecutionPeriod.getInfoExecutionYear());

    List licenciaturas = new ArrayList();

    licenciaturas.add(new LabelValueBean("escolher", ""));

    Collections.sort(executionDegreeList, new ComparatorByNameForInfoExecutionDegree());

    Iterator iterator = executionDegreeList.iterator();

    int index = 0;
    while (iterator.hasNext()) {
      InfoExecutionDegree infoExecutionDegree = (InfoExecutionDegree) iterator.next();
      String name = infoExecutionDegree.getInfoDegreeCurricularPlan().getInfoDegree().getNome();

      name =
          infoExecutionDegree
                  .getInfoDegreeCurricularPlan()
                  .getInfoDegree()
                  .getDegreeType()
                  .toString()
              + " em "
              + name;

      name +=
          duplicateInfoDegree(executionDegreeList, infoExecutionDegree)
              ? "-" + infoExecutionDegree.getInfoDegreeCurricularPlan().getName()
              : "";

      licenciaturas.add(new LabelValueBean(name, String.valueOf(index++)));
    }

    request.setAttribute(PresentationConstants.INFO_EXECUTION_DEGREE_LIST_KEY, executionDegreeList);

    request.setAttribute(PresentationConstants.DEGREES, licenciaturas);

    if (inputPage != null) {
      return mapping.findForward(inputPage);
    }

    // TODO : throw a proper exception
    throw new Exception("SomeOne is messing around with the links");
  }
  public ActionForward roomViewer(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

    String roomName = request.getParameter("roomName");
    if (roomName == null) {
      roomName = (String) request.getAttribute("roomName");
    }
    // input

    InfoExecutionDegree infoExecutionDegree =
        (InfoExecutionDegree) request.getAttribute(PresentationConstants.EXECUTION_DEGREE);

    String degreeId = getFromRequest("degreeID", request);
    if (degreeId == null) {
      degreeId = infoExecutionDegree.getInfoDegreeCurricularPlan().getInfoDegree().getExternalId();
    }
    request.setAttribute("degreeID", degreeId);
    String executionDegreeId = getFromRequest("executionDegreeID", request);
    if (executionDegreeId == null) {
      executionDegreeId = infoExecutionDegree.getExternalId();
    }
    request.setAttribute("executionDegreeID", executionDegreeId);
    String degreeCurricularPlanId = getFromRequest("degreeCurricularPlanID", request);
    if (degreeCurricularPlanId == null) {
      degreeCurricularPlanId = infoExecutionDegree.getInfoDegreeCurricularPlan().getExternalId();
    }
    request.setAttribute("degreeCurricularPlanID", degreeCurricularPlanId);

    request.setAttribute(
        "infoDegreeCurricularPlan", infoExecutionDegree.getInfoDegreeCurricularPlan());

    //

    RoomKey roomKey = null;

    if (roomName != null) {

      roomKey = new RoomKey(roomName);

      Integer objectCode = null;
      String objectCodeString = request.getParameter("objectCode");
      if (objectCodeString == null) {
        objectCodeString = (String) request.getAttribute("objectCode");
      }
      objectCode = new Integer(objectCodeString);
      ISiteComponent bodyComponent = new InfoSiteRoomTimeTable();

      // ****************************************************************
      // The following code was refactored from a berserk call into a not
      // compiling invocation.
      throw new FenixActionException();
      // try {
      // SiteView siteView = (SiteView)
      // RoomSiteComponentService.run(bodyComponent, roomKey, objectCode);
      //
      // request.setAttribute("sigla", ((InfoSiteRoomTimeTable)
      // siteView.getComponent()).getInfoRoom().getNome());
      // request.setAttribute("siteView", siteView);
      // request.setAttribute("objectCode", objectCode);
      //
      // } catch (NonExistingServiceException e) {
      // throw new NonExistingActionException(e);
      // } catch (FenixServiceException e) {
      // throw new FenixActionException(e);
      // }
      //
      // return mapping.findForward("roomViewer");
    }
    throw new FenixActionException();
  }