/**
* 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;
}
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();
}
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;
}
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;
}
/**
* 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"));
}
}
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);
}
}
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");
}
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 + "®Id=" + newCalendar.getKeyInteger().toString());
return mapping.findForward("loadOnTarget");
}
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
+ "®Id="
+ 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");
}
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
+ "®Id="
+ 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");
}