Example #1
0
  /**
   * Obtener el contenido del documento que tenga asignado el CSV recibido.
   *
   * @param context Contexto de tramitación.
   * @param csv CSV del documento
   * @return Contenido del documento.
   * @throws ISPACException Si se produce algún error.
   */
  public static byte[] getContenidoDocumento(IClientContext context, String csv)
      throws ISPACException {

    // Contenido del documento
    byte[] content = null;

    // Consulta
    String sqlQuery = "WHERE COD_COTEJO = '" + DBUtil.replaceQuotes(csv) + "'";
    IItemCollection documents =
        context.getAPI().getEntitiesAPI().queryEntities(SpacEntities.SPAC_DT_DOCUMENTOS, sqlQuery);
    if (documents.next()) {

      IItem document = documents.value();

      // Obtener el identificador del documento en el repositorio
      String guid = document.getString("INFOPAG_RDE");
      if (StringUtils.isBlank(guid)) {
        guid = document.getString("INFOPAG");
      }

      // Obtener el contenido del documento
      content =
          ieci.tdw.ispac.services.helpers.DocumentsHelper.getContenidoDocumento(context, guid);
    }

    return content;
  }
Example #2
0
  public void store() throws ISPACException {

    IInvesflowAPI invesFlowAPI = mContext.getAPI();
    ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

    if (getString("ORDEN") == null) {

      // Bloqueo de las fases para obtener el último orden
      // IItemCollection itemcol = catalogAPI.queryCTEntitiesForUpdate(ICatalogAPI.ENTITY_CT_STAGE,
      // " ORDER BY ORDEN DESC ");
      IItemCollection itemcol =
          catalogAPI.queryCTEntities(ICatalogAPI.ENTITY_CT_STAGE, " ORDER BY ORDEN DESC ");

      int nextOrden = 1;
      if (itemcol != null) {

        for (Iterator iter = itemcol.iterator(); iter.hasNext(); ) {

          IItem element = (IItem) iter.next();
          String orden = element.getString("ORDEN");
          if (orden != null) {

            nextOrden = Integer.parseInt(element.getString("ORDEN")) + 1;
            break;
          }
        }
      }

      setProperty("ORDEN", new Integer(nextOrden));
    }

    super.store();
  }
Example #3
0
  public String getRespStringSubProceso(int idStagePCD, int id_pcd) throws ISPACException {
    String responsibles = "";
    try {
      IInvesflowAPI invesFlowApi = context.getAPI();
      int idPcd = id_pcd;
      ISecurityAPI securityAPI = invesFlowApi.getSecurityAPI();
      responsibles = getRespString();

      // Comprobar si el usuario es SUPERVISOR
      if (!Responsible.SUPERVISOR.equalsIgnoreCase(responsibles)) {

        if (idStagePCD != 0) {
          IItem stage = invesFlowApi.getProcedureStage(idStagePCD);
          idPcd = stage.getInt("ID_PCD");
        }

        IItemCollection itemcol =
            securityAPI.getPermission(ISecurityAPI.PERMISSION_TPOBJ_PROCEDURE, idPcd, null);
        while (itemcol.next()) {
          responsibles += " , '" + itemcol.value().getString("ID_RESP") + "'";
        }
      }

    } catch (ISPACException ie) {
      logger.error("Error en WLWorklist:getRespStringSubProceso(" + idStagePCD + ")", ie);
      throw new ISPACException(
          "Error en WLWorklist:getRespStringSubProceso(" + idStagePCD + ")", ie);
    }
    return responsibles;
  }
Example #4
0
  public boolean isSupervised(IResponsible responsible, String sUID, String type)
      throws ISPACException {
    // Supervisados del usuario, del departamento y de los grupos a los que pertenece el usuario
    IItemCollection collection = getAllSuperviseds(responsible, type);
    Iterator iterator = collection.iterator();
    while (iterator.hasNext()) {
      IItem supervised = (IItem) iterator.next();
      Responsible respSupervised = getResp(supervised.getString("UID_SUPERVISADO"));

      if (respSupervised.isInResponsibleList(sUID)) return true;
    }

    return false;
  }
Example #5
0
  /**
   * Obtener los recursos de una entidad, las etiquetas de los campos en el idioma establecido.
   *
   * @param entityId Identificador de la entidad.
   * @param entityName Nombre de la entidad.
   * @param language Idioma.
   * @throws ISPACException Si se produce algún error.
   */
  public void getEntityResources(int entityId, String entityName, String language)
      throws ISPACException {

    IEntitiesAPI entitiesAPI = mContext.getAPI().getEntitiesAPI();

    // Obtener todos los recursos de la entidad para el idioma establecido
    IItemCollection collection = entitiesAPI.getEntityResources(entityId, language);
    while (collection.next()) {

      // Establecer las etiquetas
      IItem item = collection.value();
      setLabel(entityName + ":" + item.getString("CLAVE"), item.getString("VALOR"));
    }
  }
Example #6
0
  private void addRespListFromEntryUID(
      Collection respList, IItemCollection collection, String campo) throws ISPACException {

    Iterator iterator = collection.iterator();
    while (iterator.hasNext()) {
      IItem item = (IItem) iterator.next();
      List respListUser = getRespListFromEntryUID(item.getString(campo));
      int i = 0;
      for (i = 0; i < respListUser.size(); i++) {
        if (!respList.contains(respListUser.get(i))) {
          respList.add(respListUser.get(i));
        }
      }
    }
  }
  public ActionForward executeAction(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_PUB_RULES_EDIT});

    IInvesflowAPI invesFlowAPI = session.getAPI();
    IPublisherAPI publisherAPI = invesFlowAPI.getPublisherAPI();

    // Formulario asociado a la regla
    EntityForm defaultForm = (EntityForm) form;

    int keyId = Integer.parseInt(defaultForm.getKey());

    // Información de la regla
    IItem rule = publisherAPI.getRule(keyId);

    // Eliminar la regla
    publisherAPI.deleteRule(keyId);

    String pcdId = request.getParameter("pcdId");
    if (!StringUtils.isEmpty(pcdId)) {

      return new ActionForward(
          new StringBuffer()
              .append("/showPubRulesList.do?pcdId=")
              .append(pcdId)
              .append("&stageId=")
              .append(rule.getString("ID_FASE"))
              .append("&taskId=")
              .append(rule.getString("ID_TRAMITE"))
              .append("&typeDoc=")
              .append(rule.getString("TIPO_DOC"))
              .toString(),
          true);
    } else {
      return new ActionForward("/showPubRulesGroupList.do", true);
    }
  }
Example #8
0
 public String getDeadlineXML(DbCnt cnt) throws ISPACException {
   // obtener el id del proceso
   int idProcedure = getIdProcedure();
   CollectionDAO collDAO =
       PPlazoDAO.getDeadline(cnt, PRelPlazoDAO.DEADLINE_OBJ_PROCEDURE, idProcedure);
   // con el id del proceso obtener el plazo
   if (collDAO != null) {
     IItemCollection coll = collDAO.disconnect();
     if (coll != null) {
       List collList = coll.toList();
       for (Iterator iter = collList.iterator(); iter.hasNext(); ) {
         IItem element = (IItem) iter.next();
         String plazo = element.getString("PLAZO");
         return plazo;
       }
     }
   }
   return null;
 }
  public ActionForward updateWeekEnd(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    CalendarForm defaultForm = (CalendarForm) form;

    IItem item = (IItem) request.getSession().getAttribute("CALENDAR");

    String calendarioXML = (String) item.getString("CALENDARIO");

    CalendarDef calendarDef = new CalendarDef(calendarioXML);
    String[] daysSelected = defaultForm.getWeekDaysSelect();

    calendarDef.addWeekEnd(daysSelected);

    item.set("CALENDARIO", calendarDef.getXmlValues());
    item.store(session.getClientContext());

    String entityId = request.getParameter("entityId");
    if (entityId == null) {
      entityId = defaultForm.getEntity();
    }

    String regId = request.getParameter("regId");
    if (regId == null) {
      regId = defaultForm.getKey();
    }

    return getActionForwardShow(entityId, regId);
  }
  public boolean validate(IRuleContext rctx) throws ISPACRuleException {
    try {
      String numexp = rctx.getNumExp();
      IEntitiesAPI entitiesAPI = rctx.getClientContext().getAPI().getEntitiesAPI();
      IItemCollection itemcol = entitiesAPI.getEntities(SecretariaConstants.ENTITY_DECRETO, numexp);
      if (itemcol.next()) {
        IItem decreto = itemcol.value();
        if (StringUtils.isNotBlank(
            decreto.getString(SecretariaConstants.FIELD_DECRETO_NUM_DECRETO))) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "No se puede eliminar el expediente de decretos: "
                    + numexp
                    + " porque ya tiene número de decreto generado");
          }
          // Si hay que hacer mas comprobación de operaciones permitidas o no en base al num decreto
          // habri que especificar
          // el mensaje en las reglas que hereden de checknumdecretoempty
          rctx.setInfoMessage(
              SecretariaResourcesHelper.getMessage(
                  rctx.getClientContext().getLocale(), "aviso.not.allowed.delete.exp.decreto"));

          return false;
        }
      } else {
        // Si no hay registro no hay núm decreto generado
        if (logger.isDebugEnabled()) {
          logger.debug(
              "Se está intentando eliminar el expediente de decretos:"
                  + numexp
                  + " que no tiene ningún dato en la entidad decretos");
        }
      }

    } catch (ISPACException e) {
      logger.error("Error en la regla " + getClass().getName(), e);
      throw new ISPACRuleException(e);
    }
    return true;
  }
  public ActionForward deleteCalendar(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    CalendarForm defaultForm = (CalendarForm) form;
    ICatalogAPI catalogAPI = session.getAPI().getCatalogAPI();
    String[] multibox = defaultForm.getMultibox();
    for (int i = 0; i < multibox.length; i++) {
      String idCalendar = multibox[i];
      IItem item =
          catalogAPI.getCTEntity(
              ICatalogAPI.ENTITY_SPAC_CALENDARIOS, new Integer(idCalendar).intValue());
      item.delete(session.getClientContext());
    }
    return mapping.findForward("success_deleteCalendar");
  }
  public ActionForward deleteHolyday(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    CalendarForm defaultForm = (CalendarForm) form;

    IItem item = (IItem) request.getSession().getAttribute("CALENDAR");

    String calendarioXML = (String) item.getString("CALENDARIO");
    CalendarDef calendarDef = new CalendarDef(calendarioXML);
    String[] datesSelected = defaultForm.getMultibox();

    if (datesSelected != null) {
      for (int i = 0; i < datesSelected.length; i++) {
        calendarDef.removeHolyday(datesSelected[i]);
      }

      item.set("CALENDARIO", calendarDef.getXmlValues());
      item.store(session.getClientContext());
    }

    return getActionForwardShowDelete(
        request.getParameter("entityId"),
        request.getParameter("regId"),
        request.getParameter("nombre"),
        request.getParameter("weekDaysSelect"));
    // return getActionForwardShow(request.getParameter("entityId"),request.getParameter("regId"));
  }
  public ActionForward executeAction(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    ClientContext cct = session.getClientContext();

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(request, cct, new int[] {ISecurityAPI.FUNC_INV_PROCEDURES_EDIT});

    IInvesflowAPI invesFlowAPI = session.getAPI();
    ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

    int itemId = Integer.parseInt(request.getParameter("idfstd"));

    IItem item = catalogAPI.getCTEntity(ICatalogAPI.ENTITY_P_FSTD, itemId);
    item.delete(cct);

    TreeView tree =
        (TreeView)
            request
                .getSession()
                .getAttribute(ManageVistaCuadroProcedimientoAction.CUADRO_PROCEDIMIENTO);
    if (tree != null) {
      TreeNode actualnode = tree.getSelectedNode().getParent();
      tree.setSelectedNode(actualnode);
      actualnode.refresh();
    }

    request.setAttribute("Refresh", "true");

    return mapping.findForward("success");
  }
Example #14
0
  public void setItem(IItem item) throws ISPACException {

    IEntitiesAPI entitiesAPI = mContext.getAPI().getEntitiesAPI();

    if (!(item instanceof EntityDAO)) {
      throw new ISPACException("El objeto item no es una instancia de EntityDAO.");
    }
    EntityDAO mainEntityDAO = (EntityDAO) item;

    // Tabla y clave de la entidad principal
    mPrefixMainEntity = mainEntityDAO.getTableName();
    mKeyMainEntity = mainEntityDAO.getKeyName();

    // TODO Incorporar al EntityDAO campo NUMEXP y DEFINICION de la entidad para no tener que
    // consultar la definición que ya se consulta para crear el EntityDAO
    // Obtener la definición de la entidad principal
    mainEntityDef = (IEntityDef) entitiesAPI.getCatalogEntity(mMainEntityId);

    // Crear un CompositeItem al que se le añadiran las entidades secundarias de
    // de sustituto, composición y relación múltiple cuando existan en los parámetros del formulario
    CompositeItem composite = new CompositeItem(mPrefixMainEntity + ":" + mKeyMainEntity);
    composite.addItem(item, mPrefixMainEntity + ":");
    this.mitem = composite;

    // El número de expediente se establece inicialmente por parámetro en el EntityAppFactory
    // sino se busca en el item de la entidad principal a partir de su definición
    if (StringUtils.isEmpty(msExpedient)) {
      msExpedient = item.getString(mainEntityDef.getKeyNumExp());
    }

    /*
    // El identificador del procedimiento se establece inicialmente por parámetro en el EntityAppFactory
    // sino se busca en el item del expediente
    if (mPcdId == ISPACEntities.ENTITY_NULLREGKEYID) {
    	mPcdId = entitiesAPI.getExpedient(msExpedient).getInt("ID_PCD");
    }
    */

    // Obtener los campos obligatorios para la entidad principal
    EntityDef entityDefinicion = getRequiredData(mainEntityDef);

    // Obtener la definición de los campos para la entidad principal
    setFieldDefs(mainEntityDef.getName(), entityDefinicion);
  }
  public void validateHolyday(IItem item, String date, SessionAPI session, ActionMessages errors)
      throws ISPACException {

    String calendarioXML = (String) item.getString("CALENDARIO");

    // A este validate le pasaremos el nombre del calendario, el nombre y la fecha.
    // Sacamos todos los dias festivos del calendario seleccionado.
    // Miramos si alguna fecha y nombre coincide con la que queremos meter.

    CalendarDef calendarDef = new CalendarDef(calendarioXML);
    List holydays = calendarDef.getHolydays();
    Iterator itr = holydays.iterator();
    while (itr.hasNext()) {
      HolydayDef holyday = (HolydayDef) itr.next();
      String dayHolyday = holyday.getDate();

      if (dayHolyday.equalsIgnoreCase(date)) {
        ActionMessage error =
            new ActionMessage("error.calendar.date.dateDuplicated", new String[] {date});
        errors.add("property(HOLYDAY_DATE)", error);
      }
    }
  }
  public ActionForward createCopyCalendar(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    ClientContext cct = session.getClientContext();
    IInvesflowAPI invesFlowAPI = session.getAPI();
    ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

    // Formulario asociado a la acción
    CalendarForm defaultForm = (CalendarForm) form;

    String entityId = request.getParameter("entityId");
    String keyId = request.getParameter("regId");
    String name = defaultForm.getProperty("NEW_CALENDAR_NAME");
    IItemCollection calendar = null;
    IItem icalendar = null;
    IItem newCalendar = null;

    // Ejecución en un contexto transaccional
    boolean bCommit = false;

    try {
      // Abrir transacción
      cct.beginTX();

      List errorList = validate(name, session);

      if (!errorList.isEmpty()) {

        ActionMessages errors = new ActionMessages();
        Iterator iteError = errorList.iterator();
        while (iteError.hasNext()) {
          ValidationError validError = (ValidationError) iteError.next();
          ActionMessage error = new ActionMessage(validError.getErrorKey(), validError.getArgs());
          errors.add("property(NEW_CALENDAR_NAME)", error);
        }
        saveErrors(request, errors);

        return mapping.findForward("validate");
      }

      calendar =
          (IItemCollection)
              catalogAPI.queryCTEntities(ICatalogAPI.ENTITY_SPAC_CALENDARIOS, "where ID=" + keyId);
      icalendar = calendar.value();
      newCalendar = catalogAPI.createCTEntity(ICatalogAPI.ENTITY_SPAC_CALENDARIOS);
      newCalendar.set("NOMBRE", name);
      newCalendar.set("CALENDARIO", icalendar.get("CALENDARIO"));
      newCalendar.store(cct);

      // Si todo ha sido correcto se hace commit de la transacción
      bCommit = true;
    } catch (ISPACException e) {

      throw new ISPACInfo(e.getMessage());
    } finally {
      cct.endTX(bCommit);
    }

    request.setAttribute("target", "top");
    request.setAttribute(
        "url",
        "?method=show&entityId=" + entityId + "&regId=" + newCalendar.getKeyInteger().toString());

    return mapping.findForward("loadOnTarget");
  }
Example #17
0
  public boolean isInResponsibleList(String sUID, int supervisionType, IItem item)
      throws ISPACException {

    DbCnt cnt = context.getConnection();
    List listSupervisados = new ArrayList();
    List listSustituidos = new ArrayList();
    int i = 0;

    try {
      // Comprobar el UID en la cadena de responsabilidad directa del usuario
      Responsible user = context.getUser();
      if (user.isInResponsibleList(sUID)) {
        return true;
      }

      if (mWorkMode == IWorklistAPI.SUPERVISOR) {

        SecurityMgr securityMgr = new SecurityMgr(cnt);

        // Comprobar si el usuario es Supervisor en Modo Modificación
        if (securityMgr.isFunction(user.getUID(), ISecurityAPI.FUNC_TOTALSUPERVISOR)) {
          return true;
        }

        // Comprobar si el usuario es Supervisor en Modo Consulta, si aplica
        if ((supervisionType != ISecurityAPI.SUPERV_TOTALMODE)
            && securityMgr.isFunction(user.getUID(), ISecurityAPI.FUNC_MONITORINGSUPERVISOR)) {
          return true;
        }

        // Comprobar las responsabilidades referentes a las supervisiones
        IItemCollection collection = null;
        if (supervisionType == ISecurityAPI.SUPERV_TOTALMODE) {
          collection = securityMgr.getAllSuperviseds(user, ISecurityAPI.SUPERV_TOTALMODE);
        } else {
          collection = securityMgr.getAllSuperviseds(user);
        }

        while (collection.next()) {
          IItem supervisor = (IItem) collection.value();
          listSupervisados = getRespListFromEntryUID(supervisor.getString("UID_SUPERVISADO"));
          if (listSupervisados.contains(sUID)) {
            return true;
          }
        }

        // Comprobar las responsabilidades referentes a las sustituciones
        collection = securityMgr.getAllSubstitutes(user);
        while (collection.next()) {

          IItem substitute = (IItem) collection.value();
          listSustituidos = getRespListFromEntryUID(substitute.getString("UID_SUSTITUIDO"));
          if (listSustituidos.contains(sUID)) return true;
        }

        // Comprobar si tenemos permisos a nivel de catálogo
        if (item != null) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "El responsable "
                    + sUID
                    + "No tiene permisos genéricos, "
                    + "vamos a comprobar si tiene permisos a nivel"
                    + "de catálogo (permisos sobre un procedimiento)");
          }
          ISecurityAPI securityAPI = context.getAPI().getSecurityAPI();
          int[] permisos = new int[1];
          permisos[0] = ISecurityAPI.PERMISSION_TYPE_EDIT;

          // Componemos la cadena de responsabilidad separada por comas
          List resp = user.getRespList();
          String cadenaResp = "";
          // Al menos esta el propio usuario
          cadenaResp = "'" + DBUtil.replaceQuotes(resp.get(0).toString()) + "'";
          for (i = 1; i < resp.size(); i++) {
            cadenaResp += " , '" + DBUtil.replaceQuotes(resp.get(i).toString()) + "'";
          }

          for (i = 0; i < listSupervisados.size(); i++) {
            cadenaResp += " , '" + DBUtil.replaceQuotes(listSupervisados.get(i).toString()) + "'";
          }
          for (i = 0; i < listSustituidos.size(); i++) {
            cadenaResp += " , '" + DBUtil.replaceQuotes(listSustituidos.get(i).toString()) + "'";
          }
          // Item puede ser IProcess ,  IStage , ITask
          if (item instanceof ITask) {
            return securityAPI.existPermissions((ITask) item, cadenaResp, permisos);

          } else if (item instanceof IStage) {

            if (IPcdElement.TYPE_SUBPROCEDURE == item.getInt("TIPO")) {
              IInvesflowAPI api = context.getAPI();
              IEntitiesAPI entitiesAPI = api.getEntitiesAPI();
              String sql = "WHERE TIPO=" + IPcdElement.TYPE_PROCEDURE + " AND";
              sql += " NUMEXP = '" + DBUtil.replaceQuotes(item.getString("NUMEXP")) + "'";
              IItemCollection col = entitiesAPI.queryEntities(SpacEntities.SPAC_FASES, sql);
              if (col.next()) {
                IItem fasePadre = col.value();
                int id = fasePadre.getKeyInt();
                IStage stage = api.getStage(id);
                return securityAPI.existPermissions(stage, cadenaResp, permisos);
              }
            }
            return securityAPI.existPermissions((IStage) item, cadenaResp, permisos);
          } else if (item instanceof IProcess) {
            return securityAPI.existPermissions((IProcess) item, cadenaResp, permisos);
          }
        }
      }
    } finally {
      context.releaseConnection(cnt);
    }

    return false;
  }
  public ActionForward executeAction(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    ClientContext cct = session.getClientContext();

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_ENTITIES_EDIT});

    IInvesflowAPI invesFlowAPI = session.getAPI();
    ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

    Upload2Form upload2Form = (Upload2Form) form;
    String upload = request.getParameter("upload");

    try {

      if (upload.equals("design")) {

        FormFile formfile = upload2Form.getUploadFile();
        String htmlCode = new String(formfile.getFileData());

        if (!StringUtils.isEmpty(htmlCode)) {

          // Obtener el formulario JSP de la aplicación
          IItem application =
              catalogAPI.getCTEntity(
                  ICatalogAPI.ENTITY_CT_APP, Integer.parseInt(upload2Form.getKey()));
          if (application != null) {

            List entities = new ArrayList();

            // Entidad principal
            entities.add(application.getString("ENT_PRINCIPAL_NOMBRE"));

            // Entidades de composición y de relación múltiple
            String parameters = application.getString("PARAMETROS");
            if (!StringUtils.isEmpty(parameters)) {

              ParametersDef xmlParameters = ParametersDef.parseParametersDef(parameters);
              List compositeEntities = xmlParameters.getCompositeMultipleRelationEntities();
              Iterator it = compositeEntities.iterator();
              while (it.hasNext()) {

                EntityParameterDef entityParameterDef = (EntityParameterDef) it.next();
                entities.add(entityParameterDef.getTable());
              }
            }

            String frm_jsp = application.getString("FRM_JSP");
            String jspCode = HTMLBuilder.updateHTML(htmlCode, frm_jsp, entities);
            if (jspCode != null) {

              application.set("FRM_JSP", jspCode);

              // Incrementar la versión del formulario
              int version = 1;
              String sVersion = application.getString("FRM_VERSION");
              if (!StringUtils.isEmpty(sVersion)) {
                version += Integer.parseInt(sVersion);
              }
              application.set("FRM_VERSION", version);

              application.store(cct);
            }
          }
        } else {
          throw new ISPACInfo("exception.uploadfile.empty");
        }
      } else if (upload.equals("code")) {

        FormFile formfile2 = upload2Form.getUploadFile2();
        String jspCode = new String(formfile2.getFileData());

        if (!StringUtils.isEmpty(jspCode)) {

          // Obtener la aplicación
          IItemCollection itemcol =
              catalogAPI.queryCTEntities(
                  ICatalogAPI.ENTITY_CT_APP, "where ID =" + upload2Form.getKey());
          if (itemcol.next()) {

            IItem application = itemcol.value();
            application.set("FRM_JSP", jspCode);

            // Incrementar la versión del formulario
            int version = 1;
            String sVersion = application.getString("FRM_VERSION");
            if (!StringUtils.isEmpty(sVersion)) {
              version += Integer.parseInt(sVersion);
            }
            application.set("FRM_VERSION", version);

            application.store(cct);
          }
        } else {
          throw new ISPACInfo("exception.uploadfile.empty");
        }
      }
    } catch (IOException e) {
      throw new ISPACInfo("exception.uploadfile.error");
    }

    return mapping.findForward("success");

    /*
    request.setAttribute("refresh", "true");
    return mapping.findForward("success_upload");
    */
  }
  public ActionForward saveholydays(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    ClientContext cct = session.getClientContext();
    CalendarForm defaultForm = (CalendarForm) form;
    // Validar el formulario
    defaultForm.setEntityAppName("SaveHolydaysCalendar");
    ActionMessages errors = defaultForm.validate(mapping, request);

    String entityId = defaultForm.getEntity();
    String regId = defaultForm.getKey();
    String nombre = request.getParameter("nombre");
    String dias = request.getParameter("weekDaysSelect");

    // Ejecución en un contexto transaccional
    boolean bCommit = false;

    try {
      // Abrir transacción
      cct.beginTX();

      if (errors.isEmpty()) {

        IInvesflowAPI invesFlowAPI = session.getAPI();
        ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

        // Bloqueo
        catalogAPI.queryCTEntities(ICatalogAPI.ENTITY_SPAC_CALENDARIOS, "");

        IItem item = (IItem) request.getSession().getAttribute("CALENDAR");
        // deberia ir abajo
        String calendarioXML = (String) item.getString("CALENDARIO");
        validateHolyday(item, defaultForm.getProperty("HOLYDAY_DATE"), session, errors);

        if (!errors.isEmpty()) {

          saveErrors(request, errors);
          return mapping.findForward("success_holydays");
        }

        CalendarDef calendarDef = new CalendarDef(calendarioXML);
        calendarDef.addHolyday(
            defaultForm.getProperty("HOLYDAY_NAME"), defaultForm.getProperty("HOLYDAY_DATE"));
        item.set("CALENDARIO", calendarDef.getXmlValues());
        item.store(session.getClientContext());

        // Si todo ha sido correcto se hace commit de la transacción
        bCommit = true;

        // Para que vaya a la direccion donde yo quiero
        String url =
            "?method=show&entityId="
                + entityId
                + "&regId="
                + regId
                + "&save=true&nombre="
                + nombre
                + "&weekDaysSelect="
                + dias;

        request.setAttribute("target", "top");
        request.setAttribute("url", url);

        return mapping.findForward("loadOnTarget");
      } else {
        saveErrors(request, errors);
        return getActionForwardHolydays();
      }
    } catch (ISPACException e) {

      throw new ISPACInfo(e.getMessage());
    } finally {
      cct.endTX(bCommit);
    }
  }
  public ActionForward show(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request,
        session.getClientContext(),
        new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_READ, ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    CalendarForm defaultForm = (CalendarForm) form;

    String parameter = request.getParameter("entityId");
    if (parameter == null) {
      parameter = defaultForm.getEntity();
    }
    int entityId = Integer.parseInt(parameter);

    parameter = request.getParameter("regId");
    if (parameter == null) {
      parameter = defaultForm.getKey();
    }
    int keyId = Integer.parseInt(parameter);

    // Indica si se viene de añadir un nuevo dia festivo o no
    Boolean save = new Boolean(request.getParameter("save"));

    IInvesflowAPI invesFlowAPI = session.getAPI();
    ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

    String strURL = null;
    EntityApp entityapp = catalogAPI.getCTDefaultEntityApp(entityId, keyId, getRealPath(""));

    try {
      if (entityapp == null) throw new ISPACNullObject();
      // Si se debe crear una entrada cuando se guarden los datos del registro,
      // se marca debidamente el campo clave del registro como nulo.
      if (keyId == ISPACEntities.ENTITY_NULLREGKEYID) {
        entityapp.getItem().setKey(ISPACEntities.ENTITY_NULLREGKEYID);
      }
    } catch (ISPACNullObject e) {
      ISPACRewrite ispacPath = new ISPACRewrite(getServlet().getServletContext());
      strURL = ispacPath.rewriteRelativePath("common/missingapp.jsp");
    } catch (ISPACException eie) {
      throw new ISPACInfo(eie.getMessage());
    }

    if (strURL == null) {
      strURL = entityapp.getURL();
    }

    // Visualiza los datos de la entidad
    // Si hay errores no se recargan los datos de la entidad
    // manteniéndose los datos introducidos que generan los errores
    if (((defaultForm.getActions() == null) || (defaultForm.getActions().equals("success")))
        && (request.getAttribute(Globals.ERROR_KEY) == null)) {

      defaultForm.setEntity(Integer.toString(entityId));
      defaultForm.setKey(Integer.toString(keyId));
      defaultForm.setReadonly("false");

      defaultForm.setEntityApp(entityapp);
    } else {
      // Establecer la aplicación para acceder a los valores extra en el formulario
      defaultForm.setValuesExtra(entityapp);
    }

    if (save.booleanValue()) defaultForm.setProperty("NOMBRE", request.getParameter("nombre"));

    // Lista de festivos y fin de semana
    List holydaysList = null;
    List allDayList = null;

    IItem item = defaultForm.getEntityApp().getItem();
    if (keyId > 0) {
      CalendarDef caldef = new CalendarDef(item.getString("CALENDARIO"));
      // Dias festivos
      holydaysList = caldef.getHolydays();
      // Dias de la semana
      allDayList = caldef.getAllWeekDays();
      // Dias de la semana
      if (save.booleanValue()) {
        String dias = request.getParameter("weekDaysSelect");
        String[] diasSeleccionados = new String[dias.length()];
        if (!dias.equals("")) diasSeleccionados = dias.split(",");
        caldef.addWeekEnd(diasSeleccionados);
      }

      defaultForm.setWeekDaysSelect(caldef.getWeekEndDays());

    } else {
      item.set("CALENDARIO", (new CalendarDef()).getXmlValues());
    }

    request.setAttribute("HOLYDAYS_LIST", holydaysList);
    request.setAttribute("WEEKDAYS_LIST", allDayList);

    // Página jsp asociada a la presentación de la entidad
    request.setAttribute("application", strURL);
    request.setAttribute("EntityId", Integer.toString(entityId));
    request.setAttribute("KeyId", Integer.toString(keyId));

    // Generamos la ruta de navegación hasta la pantalla actual.
    BreadCrumbsContainer bcm = BreadCrumbsManager.getInstance(catalogAPI).getBreadCrumbs(request);
    request.setAttribute("BreadCrumbs", bcm.getList());

    // poner el item en session
    request.getSession().setAttribute("CALENDAR", entityapp.getItem());

    return mapping.findForward("success_show");
  }
Example #21
0
  public void run(ClientContext cs, TXTransactionDataContainer dtc, ITXTransaction itx)
      throws ISPACException {

    EventManager eventmgr = new EventManager(cs, mparams);
    TXDAOGen genDAO = new TXDAOGen(cs, eventmgr);

    TXFaseDAO stage = dtc.getStage(mnIdStage);
    int nIdProc = stage.getInt("ID_EXP");
    int nIdPCDStage = stage.getInt("ID_FASE");

    TXProcesoDAO process = dtc.getProcess(nIdProc);
    TXProcedure procedure = TXProcedureMgr.getInstance().getProcedure(cs, process.getIdProcedure());

    PTramiteDAO pcdtask = procedure.getTaskDAO(mnIdTaskPCD);

    if (process.getInt("ESTADO") == TXConstants.STATUS_CLOSED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusClosed",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    } else if (process.getInt("ESTADO") == TXConstants.STATUS_CANCELED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusCanceled",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    } else if (process.getInt("ESTADO") == TXConstants.STATUS_ARCHIVED) {
      throw new ISPACInfo(
          "exception.expedients.createTask.statusArchived",
          new String[] {pcdtask.getString("NOMBRE"), process.getString("NUMEXP")});
    }

    // -----
    // BPM
    // ----
    IBPMAPI bpmAPI = dtc.getBPMAPI();
    IInvesflowAPI invesFlowAPI = cs.getAPI();
    IRespManagerAPI respManagerAPI = invesFlowAPI.getRespManagerAPI();
    // Se calcula el responsable del trámite
    String taskRespId = ResponsibleHelper.calculateTaskResp(eventmgr, pcdtask, stage, process, cs);

    String nombreRespId = ((Responsible) respManagerAPI.getResp(taskRespId)).getName();
    String taskActivityRespId = null;

    // boolean isSubProcess = false;
    boolean isSubProcess = mnIdProcedure != 0;
    int taskType = ITask.SIMPLE_TASK_TYPE;
    String idSubPcdBPM = null;
    // Si el tramite es complejo se calcula el responsable a asignar a la actividad inicial del
    // subproceso
    // if (StringUtils.isNotEmpty(pcdtask.getString("ID_PCD_SUB")) &&
    // !StringUtils.equals(pcdtask.getString("ID_PCD_SUB"), "0")){
    if (isSubProcess) {
      taskType = ITask.COMPLEX_TASK_TYPE;

      TXProcedure subProcess = TXProcedureMgr.getInstance().getProcedure(cs, mnIdProcedure);
      Iterator it = subProcess.getStateTable().getStartStages().iterator();

      if (!it.hasNext())
        throw new ISPACException(
            "No se han encontrado actividades para el subproceso '"
                + pcdtask.getString("ID_PCD_SUB")
                + "'");
      int activityId = ((Integer) it.next()).intValue();
      PFaseDAO pActivity = subProcess.getStageDAO(activityId);
      taskActivityRespId =
          ResponsibleHelper.calculateTaskActivityResp(
              eventmgr, pActivity, pcdtask, process, cs, taskRespId);

      IItem itemSubprocedure = invesFlowAPI.getProcedure(pcdtask.getInt("ID_PCD_SUB"));
      idSubPcdBPM = itemSubprocedure.getString("ID_PCD_BPM");
    }

    // BpmUIDs bpmUIDs = bpmAPI.instanceTask(pcdtask.getString("ID_TRAMITE_BPM"),
    // pcdtask.getString("ID_PCD_SUB"), taskRespId,
    // taskActivityRespId,String.valueOf(stage.getKeyInt()));
    BpmUIDs bpmUIDs =
        bpmAPI.instanceTask(
            pcdtask.getString("ID_TRAMITE_BPM"),
            idSubPcdBPM,
            taskRespId,
            taskActivityRespId,
            stage.getString("ID_FASE_BPM"));

    // Identificador de tramite creado
    String taskUID = bpmUIDs.getTaskUID();
    // Identificador de subproceso instanciado
    String subProcessUID = bpmUIDs.getSubProcessUID();
    // Identificador de actividad creada
    String activityUID = bpmUIDs.getActivityUID();

    TXTramiteDAO task = dtc.newTask();
    genDAO.instance(pcdtask, task, stage, process);

    // Establecemos el UID del tramite instanciado retornado por el BPM
    if (taskUID == null) taskUID = "" + task.getKeyInt();
    task.set("ID_TRAMITE_BPM", taskUID);
    task.set("ID_RESP", taskRespId);
    task.set("RESP", nombreRespId);
    task.set("TIPO", taskType);
    // Si es un tramite complejo (subproceso) habrá que instanciar el subproceso
    if (isSubProcess) {
      int[] ids =
          itx.createSubProcess(
              pcdtask.getInt("ID_PCD_SUB"),
              mnumexp,
              subProcessUID,
              activityUID,
              taskRespId,
              taskActivityRespId);
      task.set("ID_SUBPROCESO", (int) ids[0]);
      mnIdActivity = (int) ids[1];
      //			//Obtenemos la actividad inicia
      //			Iterator it =dtc.getStages();
      //			while (it.hasNext()){
      //				TXFaseDAO _stage = (TXFaseDAO)((Map.Entry)it.next()).getValue();
      //				if (_stage.getInt("ID_EXP") == idSubProcess){
      //					mnIdActivity = _stage.getKeyInt();
      //					break;
      //				}

      eventmgr.getRuleContextBuilder().addContext(RuleProperties.RCTX_SUBPROCESS, "" + ids[0]);
    }

    // Guardar la información del trámite
    task.store(cs);

    dtc.createTaskEntity(task);

    mnIdTask = task.getKeyInt();

    // Insertar el hito
    TXHitoDAO hito =
        dtc.newMilestone(
            process.getKeyInt(), nIdPCDStage, mnIdTaskPCD, TXConstants.MILESTONE_TASK_START);
    hito.set("INFO", composeInfo());

    // Se construye el contexto de ejecución de scripts.
    eventmgr.getRuleContextBuilder().addContext(process);
    eventmgr.getRuleContextBuilder().addContext(task);

    // Ejecutar eventos de sistema de creación de trámite.
    eventmgr.processSystemEvents(EventsDefines.EVENT_OBJ_TASK, EventsDefines.EVENT_EXEC_START);

    // Ejecutar evento al cancelar trámite.
    eventmgr.processEvents(
        EventsDefines.EVENT_OBJ_TASK, mnIdTaskPCD, EventsDefines.EVENT_EXEC_START);
  }
  // Esta función guarda en la base de datos correspondiente los dias seleccionados en la página.
  public ActionForward saveFixedHolidays(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response,
      SessionAPI session)
      throws Exception {

    // Comprobar si el usuario tiene asignadas las funciones adecuadas
    FunctionHelper.checkFunctions(
        request, session.getClientContext(), new int[] {ISecurityAPI.FUNC_COMP_CALENDARS_EDIT});

    ClientContext cct = session.getClientContext();
    CalendarForm defaultForm = (CalendarForm) form;
    String[] selectFixedHolidays = (String[]) defaultForm.getSelectFixedHolidays();
    String year = (String) defaultForm.getProperty("YEAR");

    // Validación
    ActionMessages errors = new ActionMessages();
    defaultForm.setEntityAppName("EditCTCalendar");
    errors = defaultForm.validate(mapping, request);

    if (errors.isEmpty()) {

      String entityId = defaultForm.getEntity();
      String regId = defaultForm.getKey();
      String nombre = request.getParameter("nombre");
      String dias = request.getParameter("weekDaysSelect");

      // Ejecución en un contexto transaccional
      boolean bCommit = false;

      try {
        // Abrir transacción
        cct.beginTX();

        IInvesflowAPI invesFlowAPI = session.getAPI();
        ICatalogAPI catalogAPI = invesFlowAPI.getCatalogAPI();

        // Bloquear
        catalogAPI.queryCTEntities(ICatalogAPI.ENTITY_SPAC_CALENDARIOS, "");
        IItem item = (IItem) request.getSession().getAttribute("CALENDAR");

        String calendarioXML = (String) item.getString("CALENDARIO");
        CalendarDef calendarDef = new CalendarDef(calendarioXML);

        for (int i = 0; i < selectFixedHolidays.length; i++) {
          String[] date = selectFixedHolidays[i].split("---");
          ActionMessages errorsFixedHolidays = new ActionMessages();
          validateHolyday(item, date[0] + "/" + year, session, errorsFixedHolidays);

          if (errorsFixedHolidays.isEmpty()) {
            calendarDef.addHolyday(date[1], date[0] + "/" + year);
          }
        }

        item.set("CALENDARIO", calendarDef.getXmlValues());
        item.store(session.getClientContext());

        // Si todo ha sido correcto se hace commit de la transacción
        bCommit = true;

        String url =
            "?method=show&entityId="
                + entityId
                + "&regId="
                + regId
                + "&save=true&nombre="
                + nombre
                + "&weekDaysSelect="
                + dias;

        request.setAttribute("target", "top");
        request.setAttribute("url", url);

        return mapping.findForward("loadOnTarget");
      } catch (ISPACException e) {

        throw new ISPACInfo(e.getMessage());
      } finally {
        cct.endTX(bCommit);
      }
    }

    saveErrors(request, errors);
    request.setAttribute(DAYS_LIST, request.getAttribute(DAYS_LIST));

    return mapping.findForward("errorYear");
  }