From f1e05fe10f86cb23a84c67d3d4e1b66a8c74c1b9 Mon Sep 17 00:00:00 2001 From: Marco Alderighi Date: Wed, 13 Sep 2023 15:25:50 +0200 Subject: [PATCH] fix generazione documenti pratica ospedaliera --- .../bo/service/IntPraticaLocalService.java | 8 + .../bo/service/IntPraticaLocalServiceClp.java | 522 +++--- .../service/IntPraticaLocalServiceUtil.java | 11 + .../IntPraticaLocalServiceWrapper.java | 11 + ...enzionataExportActionableDynamicQuery.java | 85 + .../liferay/portos/bo/util/AvvisoUtil.java | 12 +- .../WEB-INF/src/content/Language.properties | 5 +- .../WEB-INF/src/content/Portal.properties | 3 + .../bo/scheduler/SchedulerPratiche.java | 29 +- .../IntPraticaLocalServiceClpInvoker.java | 517 +++--- .../service/impl/AvvisoLocalServiceImpl.java | 23 +- .../impl/IntPraticaLocalServiceImpl.java | 14 +- .../WEB-INF/lib/portos-bo-portlet-service.jar | Bin 1578347 -> 1582909 bytes .../lib/portos-mail-manager-shared.jar | Bin 16836 -> 16836 bytes .../WEB-INF/lib/portos-report-shared.jar | Bin 17909 -> 17909 bytes .../portos/fe/portlet/FascicoloFePortlet.java | 1543 +++++++++-------- .../domanda/page_dettagli_principali.jsp | 15 +- .../org.eclipse.wst.common.component | 3 + 18 files changed, 1540 insertions(+), 1261 deletions(-) create mode 100644 liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/persistence/PraticaAttenzionataExportActionableDynamicQuery.java diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalService.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalService.java index dcba1c08..f59fa701 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalService.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalService.java @@ -341,6 +341,14 @@ public interface IntPraticaLocalService extends BaseLocalService, throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException; + @com.liferay.portal.kernel.search.Indexable(type = IndexableType.REINDEX) + public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( + long territorioId, java.lang.String tipoProcedura, + boolean isOspedaliera, + com.liferay.portal.service.ServiceContext serviceContext) + throws com.liferay.portal.kernel.exception.PortalException, + com.liferay.portal.kernel.exception.SystemException; + @com.liferay.portal.kernel.search.Indexable(type = IndexableType.REINDEX) public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( long territorioId, java.lang.String tipoProcedura, diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceClp.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceClp.java index 8fcb7d8b..7e5267fd 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceClp.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceClp.java @@ -146,308 +146,315 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { _methodName26 = "addIntPratica"; _methodParameterTypes26 = new String[] { - "long", "java.lang.String", + "long", "java.lang.String", "boolean", "com.liferay.portal.service.ServiceContext" }; _methodName27 = "addIntPratica"; _methodParameterTypes27 = new String[] { + "long", "java.lang.String", + "com.liferay.portal.service.ServiceContext" + }; + + _methodName28 = "addIntPratica"; + + _methodParameterTypes28 = new String[] { "long", "java.lang.String", "java.lang.String", "long", "java.lang.String", "java.util.Date", "java.lang.String", "java.lang.String", "boolean", "int", "java.util.Date", "com.liferay.portal.service.ServiceContext" }; - _methodName28 = "deleteIntPratica"; + _methodName29 = "deleteIntPratica"; - _methodParameterTypes28 = new String[] { + _methodParameterTypes29 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "boolean" }; - _methodName29 = "cloneIntPratica"; + _methodName30 = "cloneIntPratica"; - _methodParameterTypes29 = new String[] { + _methodParameterTypes30 = new String[] { "long", "com.liferay.portal.service.ServiceContext" }; - _methodName30 = "updateDelegati"; + _methodName31 = "updateDelegati"; - _methodParameterTypes30 = new String[] { + _methodParameterTypes31 = new String[] { "long", "java.lang.String", "java.lang.String", "boolean" }; - _methodName31 = "findFascicoliNotProgetto"; + _methodName32 = "findFascicoliNotProgetto"; - _methodParameterTypes31 = new String[] { "int", "int" }; + _methodParameterTypes32 = new String[] { "int", "int" }; - _methodName32 = "countFascicoliNotProgetto"; + _methodName33 = "countFascicoliNotProgetto"; - _methodParameterTypes32 = new String[] { }; + _methodParameterTypes33 = new String[] { }; - _methodName33 = "addNumeroProgetto"; + _methodName34 = "addNumeroProgetto"; - _methodParameterTypes33 = new String[] { "long" }; + _methodParameterTypes34 = new String[] { "long" }; - _methodName34 = "sospendiPratica"; + _methodName35 = "sospendiPratica"; - _methodParameterTypes34 = new String[] { "long", "boolean" }; + _methodParameterTypes35 = new String[] { "long", "boolean" }; - _methodName35 = "cambiaTitolare"; + _methodName36 = "cambiaTitolare"; - _methodParameterTypes35 = new String[] { + _methodParameterTypes36 = new String[] { "long", "long", "com.liferay.portal.service.ServiceContext" }; - _methodName36 = "updateStatoPratica"; + _methodName37 = "updateStatoPratica"; - _methodParameterTypes36 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes37 = new String[] { "long", "java.lang.String" }; - _methodName37 = "updateIntPraticaSorteggio"; + _methodName38 = "updateIntPraticaSorteggio"; - _methodParameterTypes37 = new String[] { "long", "java.util.Date" }; + _methodParameterTypes38 = new String[] { "long", "java.util.Date" }; - _methodName38 = "updateIntPraticaSorteggio"; + _methodName39 = "updateIntPraticaSorteggio"; - _methodParameterTypes38 = new String[] { + _methodParameterTypes39 = new String[] { "long", "java.util.Date", "java.lang.String" }; - _methodName39 = "findByC_UserId"; + _methodName40 = "findByC_UserId"; - _methodParameterTypes39 = new String[] { "long", "long", "int", "int" }; + _methodParameterTypes40 = new String[] { "long", "long", "int", "int" }; - _methodName40 = "countByC_UserId"; + _methodName41 = "countByC_UserId"; - _methodParameterTypes40 = new String[] { "long", "long" }; + _methodParameterTypes41 = new String[] { "long", "long" }; - _methodName41 = "updateStatus"; + _methodName42 = "updateStatus"; - _methodParameterTypes41 = new String[] { "long", "int" }; + _methodParameterTypes42 = new String[] { "long", "int" }; - _methodName42 = "findByCompanyIdSoggettoProgetti"; - - _methodParameterTypes42 = new String[] { "long", "long" }; - - _methodName43 = "countByCompanyIdSoggettoProgetti"; + _methodName43 = "findByCompanyIdSoggettoProgetti"; _methodParameterTypes43 = new String[] { "long", "long" }; - _methodName44 = "findByCompanyIdSoggettoArchivio"; + _methodName44 = "countByCompanyIdSoggettoProgetti"; _methodParameterTypes44 = new String[] { "long", "long" }; - _methodName45 = "countByCompanyIdSoggettoArchivio"; + _methodName45 = "findByCompanyIdSoggettoArchivio"; _methodParameterTypes45 = new String[] { "long", "long" }; - _methodName46 = "findByCompanyIdSoggettoAltriProgetti"; + _methodName46 = "countByCompanyIdSoggettoArchivio"; + + _methodParameterTypes46 = new String[] { "long", "long" }; + + _methodName47 = "findByCompanyIdSoggettoAltriProgetti"; - _methodParameterTypes46 = new String[] { "long", "long", "int", "int" }; + _methodParameterTypes47 = new String[] { "long", "long", "int", "int" }; - _methodName47 = "countByCompanyIdSoggettoAltriProgetti"; + _methodName48 = "countByCompanyIdSoggettoAltriProgetti"; - _methodParameterTypes47 = new String[] { "long", "long" }; + _methodParameterTypes48 = new String[] { "long", "long" }; - _methodName48 = "findByCanAddFineLavori"; + _methodName49 = "findByCanAddFineLavori"; - _methodParameterTypes48 = new String[] { + _methodParameterTypes49 = new String[] { "long", "java.lang.String", "int", "int" }; - _methodName49 = "countByCanAddFineLavori"; + _methodName50 = "countByCanAddFineLavori"; - _methodParameterTypes49 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes50 = new String[] { "long", "java.lang.String" }; - _methodName50 = "findByCanAddCollaudo"; + _methodName51 = "findByCanAddCollaudo"; - _methodParameterTypes50 = new String[] { + _methodParameterTypes51 = new String[] { "long", "java.lang.String", "int", "int" }; - _methodName51 = "countByCanAddCollaudo"; + _methodName52 = "countByCanAddCollaudo"; - _methodParameterTypes51 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes52 = new String[] { "long", "java.lang.String" }; - _methodName52 = "search"; + _methodName53 = "search"; - _methodParameterTypes52 = new String[] { "java.util.List", "int", "int" }; + _methodParameterTypes53 = new String[] { "java.util.List", "int", "int" }; - _methodName53 = "countSearch"; + _methodName54 = "countSearch"; - _methodParameterTypes53 = new String[] { "java.util.List" }; + _methodParameterTypes54 = new String[] { "java.util.List" }; - _methodName54 = "searchWithIntPraticaId"; + _methodName55 = "searchWithIntPraticaId"; - _methodParameterTypes54 = new String[] { + _methodParameterTypes55 = new String[] { "java.util.List", "long", "int", "int" }; - _methodName55 = "countSearchWithIntPraticaId"; + _methodName56 = "countSearchWithIntPraticaId"; - _methodParameterTypes55 = new String[] { "java.util.List", "long" }; + _methodParameterTypes56 = new String[] { "java.util.List", "long" }; - _methodName56 = "allegaFileAnnullamento"; + _methodName57 = "allegaFileAnnullamento"; - _methodParameterTypes56 = new String[] { + _methodParameterTypes57 = new String[] { "long", "byte[][]", "java.lang.String", "java.lang.String", "com.liferay.portal.service.ServiceContext" }; - _methodName57 = "generateFileAnnullamento"; + _methodName58 = "generateFileAnnullamento"; - _methodParameterTypes57 = new String[] { + _methodParameterTypes58 = new String[] { "long", "com.liferay.portal.service.ServiceContext" }; - _methodName58 = "deleteFileAnnullamento"; + _methodName59 = "deleteFileAnnullamento"; - _methodParameterTypes58 = new String[] { "long" }; + _methodParameterTypes59 = new String[] { "long" }; - _methodName59 = "completeAnnullamento"; + _methodName60 = "completeAnnullamento"; - _methodParameterTypes59 = new String[] { "long" }; + _methodParameterTypes60 = new String[] { "long" }; - _methodName60 = "cambiaIstruttore"; + _methodName61 = "cambiaIstruttore"; - _methodParameterTypes60 = new String[] { "long", "long", "long" }; + _methodParameterTypes61 = new String[] { "long", "long", "long" }; - _methodName61 = "countCaricoLavoroCF"; + _methodName62 = "countCaricoLavoroCF"; - _methodParameterTypes61 = new String[] { + _methodParameterTypes62 = new String[] { "long", "java.lang.String", "java.lang.Boolean", "java.lang.Long[][]" }; - _methodName62 = "countCaricoLavoroIstruttore"; + _methodName63 = "countCaricoLavoroIstruttore"; - _methodParameterTypes62 = new String[] { + _methodParameterTypes63 = new String[] { "long", "java.lang.String", "java.lang.Boolean" }; - _methodName63 = "generateReportPratica"; + _methodName64 = "generateReportPratica"; - _methodParameterTypes63 = new String[] { + _methodParameterTypes64 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "long" }; - _methodName64 = "updateModifiedDate"; + _methodName65 = "updateModifiedDate"; - _methodParameterTypes64 = new String[] { "long", "java.util.Date" }; + _methodParameterTypes65 = new String[] { "long", "java.util.Date" }; - _methodName65 = "countAutorizzazione"; + _methodName66 = "countAutorizzazione"; - _methodParameterTypes65 = new String[] { + _methodParameterTypes66 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName66 = "countSanatorie"; + _methodName67 = "countSanatorie"; - _methodParameterTypes66 = new String[] { + _methodParameterTypes67 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName67 = "countOpereMinoreImportanza"; + _methodName68 = "countOpereMinoreImportanza"; - _methodParameterTypes67 = new String[] { + _methodParameterTypes68 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName68 = "countDeposito"; + _methodName69 = "countDeposito"; - _methodParameterTypes68 = new String[] { + _methodParameterTypes69 = new String[] { "java.util.Date", "java.util.Date", "long", "boolean" }; - _methodName69 = "countVidimate"; + _methodName70 = "countVidimate"; - _methodParameterTypes69 = new String[] { + _methodParameterTypes70 = new String[] { "java.util.Date", "java.util.Date", "long", "java.lang.String", "boolean" }; - _methodName70 = "countControllo"; + _methodName71 = "countControllo"; - _methodParameterTypes70 = new String[] { + _methodParameterTypes71 = new String[] { "java.util.Date", "java.util.Date", "long", "java.lang.String", "boolean" }; - _methodName71 = "findIntPraticaNotExist"; + _methodName72 = "findIntPraticaNotExist"; - _methodParameterTypes71 = new String[] { }; + _methodParameterTypes72 = new String[] { }; - _methodName72 = "riparaWorkflow"; + _methodName73 = "riparaWorkflow"; - _methodParameterTypes72 = new String[] { }; + _methodParameterTypes73 = new String[] { }; - _methodName73 = "reIndexFascicolo"; + _methodName74 = "reIndexFascicolo"; - _methodParameterTypes73 = new String[] { + _methodParameterTypes74 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "long" }; - _methodName74 = "reIndexFasciolo"; - - _methodParameterTypes74 = new String[] { "java.lang.String", "long" }; - _methodName75 = "reIndexFasciolo"; - _methodParameterTypes75 = new String[] { "long", "long" }; + _methodParameterTypes75 = new String[] { "java.lang.String", "long" }; - _methodName76 = "trovaDoppioni"; + _methodName76 = "reIndexFasciolo"; - _methodParameterTypes76 = new String[] { }; + _methodParameterTypes76 = new String[] { "long", "long" }; - _methodName77 = "findByNumeroProgetto"; + _methodName77 = "trovaDoppioni"; - _methodParameterTypes77 = new String[] { "java.lang.String" }; + _methodParameterTypes77 = new String[] { }; - _methodName78 = "findByTerritorioId"; + _methodName78 = "findByNumeroProgetto"; - _methodParameterTypes78 = new String[] { "long" }; + _methodParameterTypes78 = new String[] { "java.lang.String" }; - _methodName79 = "reportTempisticheIstruttorieAvvisiAutorizzazioni"; + _methodName79 = "findByTerritorioId"; - _methodParameterTypes79 = new String[] { - "java.util.Date", "java.util.Date", "long", "java.lang.String" - }; + _methodParameterTypes79 = new String[] { "long" }; - _methodName80 = "reportTempisticheIstruttorieCalcolaDataSorteggio"; + _methodName80 = "reportTempisticheIstruttorieAvvisiAutorizzazioni"; _methodParameterTypes80 = new String[] { - "java.util.Date", "java.util.Date", "long" + "java.util.Date", "java.util.Date", "long", "java.lang.String" }; - _methodName81 = "reportPraticheVidimate"; + _methodName81 = "reportTempisticheIstruttorieCalcolaDataSorteggio"; _methodParameterTypes81 = new String[] { - "java.util.Date", "java.util.Date", "long", "java.lang.String" + "java.util.Date", "java.util.Date", "long" }; - _methodName82 = "reportPraticheVidimateCalcolaDataSorteggio"; + _methodName82 = "reportPraticheVidimate"; _methodParameterTypes82 = new String[] { - "java.util.Date", "java.util.Date", "long" + "java.util.Date", "java.util.Date", "long", "java.lang.String" }; - _methodName83 = "countIngressiAutorizzazioni"; + _methodName83 = "reportPraticheVidimateCalcolaDataSorteggio"; _methodParameterTypes83 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName84 = "countIngressiDepositi"; + _methodName84 = "countIngressiAutorizzazioni"; _methodParameterTypes84 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName85 = "countIngressiCO"; + _methodName85 = "countIngressiDepositi"; _methodParameterTypes85 = new String[] { "java.util.Date", "java.util.Date", "long" }; + + _methodName86 = "countIngressiCO"; + + _methodParameterTypes86 = new String[] { + "java.util.Date", "java.util.Date", "long" + }; } @Override @@ -1254,6 +1261,7 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { @Override public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( long territorioId, java.lang.String tipoProcedura, + boolean isOspedaliera, com.liferay.portal.service.ServiceContext serviceContext) throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { @@ -1267,6 +1275,50 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { ClpSerializer.translateInput(tipoProcedura), + isOspedaliera, + + ClpSerializer.translateInput(serviceContext) + }); + } + catch (Throwable t) { + t = ClpSerializer.translateThrowable(t); + + if (t instanceof com.liferay.portal.kernel.exception.PortalException) { + throw (com.liferay.portal.kernel.exception.PortalException)t; + } + + if (t instanceof com.liferay.portal.kernel.exception.SystemException) { + throw (com.liferay.portal.kernel.exception.SystemException)t; + } + + if (t instanceof RuntimeException) { + throw (RuntimeException)t; + } + else { + throw new RuntimeException(t.getClass().getName() + + " is not a valid exception"); + } + } + + return (it.tref.liferay.portos.bo.model.IntPratica)ClpSerializer.translateOutput(returnObj); + } + + @Override + public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( + long territorioId, java.lang.String tipoProcedura, + com.liferay.portal.service.ServiceContext serviceContext) + throws com.liferay.portal.kernel.exception.PortalException, + com.liferay.portal.kernel.exception.SystemException { + Object returnObj = null; + + try { + returnObj = _invokableLocalService.invokeMethod(_methodName27, + _methodParameterTypes27, + new Object[] { + territorioId, + + ClpSerializer.translateInput(tipoProcedura), + ClpSerializer.translateInput(serviceContext) }); } @@ -1306,8 +1358,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName27, - _methodParameterTypes27, + returnObj = _invokableLocalService.invokeMethod(_methodName28, + _methodParameterTypes28, new Object[] { userId, @@ -1365,8 +1417,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName28, - _methodParameterTypes28, + returnObj = _invokableLocalService.invokeMethod(_methodName29, + _methodParameterTypes29, new Object[] { ClpSerializer.translateInput(intPratica), @@ -1405,8 +1457,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName29, - _methodParameterTypes29, + returnObj = _invokableLocalService.invokeMethod(_methodName30, + _methodParameterTypes30, new Object[] { intPraticaId, @@ -1446,8 +1498,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName30, - _methodParameterTypes30, + returnObj = _invokableLocalService.invokeMethod(_methodName31, + _methodParameterTypes31, new Object[] { intPraticaId, @@ -1489,8 +1541,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName31, - _methodParameterTypes31, new Object[] { start, end }); + returnObj = _invokableLocalService.invokeMethod(_methodName32, + _methodParameterTypes32, new Object[] { start, end }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -1517,8 +1569,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName32, - _methodParameterTypes32, new Object[] { }); + returnObj = _invokableLocalService.invokeMethod(_methodName33, + _methodParameterTypes33, new Object[] { }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -1547,8 +1599,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName33, - _methodParameterTypes33, new Object[] { intPraticaId }); + returnObj = _invokableLocalService.invokeMethod(_methodName34, + _methodParameterTypes34, new Object[] { intPraticaId }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -1581,8 +1633,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName34, - _methodParameterTypes34, + returnObj = _invokableLocalService.invokeMethod(_methodName35, + _methodParameterTypes35, new Object[] { intPraticaId, sospesa }); } catch (Throwable t) { @@ -1617,8 +1669,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName35, - _methodParameterTypes35, + returnObj = _invokableLocalService.invokeMethod(_methodName36, + _methodParameterTypes36, new Object[] { intPraticaId, @@ -1658,8 +1710,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName36, - _methodParameterTypes36, + returnObj = _invokableLocalService.invokeMethod(_methodName37, + _methodParameterTypes37, new Object[] { intPraticaId, @@ -1696,8 +1748,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName37, - _methodParameterTypes37, + returnObj = _invokableLocalService.invokeMethod(_methodName38, + _methodParameterTypes38, new Object[] { intPraticaId, @@ -1731,8 +1783,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName38, - _methodParameterTypes38, + returnObj = _invokableLocalService.invokeMethod(_methodName39, + _methodParameterTypes39, new Object[] { intPraticaId, @@ -1767,8 +1819,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName39, - _methodParameterTypes39, + returnObj = _invokableLocalService.invokeMethod(_methodName40, + _methodParameterTypes40, new Object[] { companyId, userId, start, end }); } catch (Throwable t) { @@ -1796,8 +1848,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName40, - _methodParameterTypes40, new Object[] { companyId, userId }); + returnObj = _invokableLocalService.invokeMethod(_methodName41, + _methodParameterTypes41, new Object[] { companyId, userId }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -1823,8 +1875,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName41, - _methodParameterTypes41, new Object[] { intPraticaId, status }); + _invokableLocalService.invokeMethod(_methodName42, + _methodParameterTypes42, new Object[] { intPraticaId, status }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -1855,8 +1907,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName42, - _methodParameterTypes42, + returnObj = _invokableLocalService.invokeMethod(_methodName43, + _methodParameterTypes43, new Object[] { companyId, soggettoId }); } catch (Throwable t) { @@ -1889,8 +1941,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName43, - _methodParameterTypes43, + returnObj = _invokableLocalService.invokeMethod(_methodName44, + _methodParameterTypes44, new Object[] { companyId, soggettoId }); } catch (Throwable t) { @@ -1924,8 +1976,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName44, - _methodParameterTypes44, + returnObj = _invokableLocalService.invokeMethod(_methodName45, + _methodParameterTypes45, new Object[] { companyId, soggettoId }); } catch (Throwable t) { @@ -1958,8 +2010,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName45, - _methodParameterTypes45, + returnObj = _invokableLocalService.invokeMethod(_methodName46, + _methodParameterTypes46, new Object[] { companyId, soggettoId }); } catch (Throwable t) { @@ -1993,8 +2045,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName46, - _methodParameterTypes46, + returnObj = _invokableLocalService.invokeMethod(_methodName47, + _methodParameterTypes47, new Object[] { companyId, soggettoId, start, end }); } catch (Throwable t) { @@ -2028,8 +2080,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName47, - _methodParameterTypes47, + returnObj = _invokableLocalService.invokeMethod(_methodName48, + _methodParameterTypes48, new Object[] { companyId, soggettoId }); } catch (Throwable t) { @@ -2063,8 +2115,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName48, - _methodParameterTypes48, + returnObj = _invokableLocalService.invokeMethod(_methodName49, + _methodParameterTypes49, new Object[] { companyId, @@ -2106,8 +2158,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName49, - _methodParameterTypes49, + returnObj = _invokableLocalService.invokeMethod(_methodName50, + _methodParameterTypes50, new Object[] { companyId, @@ -2145,8 +2197,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName50, - _methodParameterTypes50, + returnObj = _invokableLocalService.invokeMethod(_methodName51, + _methodParameterTypes51, new Object[] { companyId, @@ -2188,8 +2240,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName51, - _methodParameterTypes51, + returnObj = _invokableLocalService.invokeMethod(_methodName52, + _methodParameterTypes52, new Object[] { companyId, @@ -2226,8 +2278,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName52, - _methodParameterTypes52, + returnObj = _invokableLocalService.invokeMethod(_methodName53, + _methodParameterTypes53, new Object[] { ClpSerializer.translateInput(groupIds), @@ -2261,8 +2313,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName53, - _methodParameterTypes53, + returnObj = _invokableLocalService.invokeMethod(_methodName54, + _methodParameterTypes54, new Object[] { ClpSerializer.translateInput(groupIds) }); } catch (Throwable t) { @@ -2291,8 +2343,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName54, - _methodParameterTypes54, + returnObj = _invokableLocalService.invokeMethod(_methodName55, + _methodParameterTypes55, new Object[] { ClpSerializer.translateInput(groupIds), @@ -2329,8 +2381,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName55, - _methodParameterTypes55, + returnObj = _invokableLocalService.invokeMethod(_methodName56, + _methodParameterTypes56, new Object[] { ClpSerializer.translateInput(groupIds), @@ -2367,8 +2419,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName56, - _methodParameterTypes56, + returnObj = _invokableLocalService.invokeMethod(_methodName57, + _methodParameterTypes57, new Object[] { intPraticaId, @@ -2418,8 +2470,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName57, - _methodParameterTypes57, + returnObj = _invokableLocalService.invokeMethod(_methodName58, + _methodParameterTypes58, new Object[] { intPraticaId, @@ -2458,8 +2510,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName58, - _methodParameterTypes58, + _invokableLocalService.invokeMethod(_methodName59, + _methodParameterTypes59, new Object[] { docPraticaAnnullamentoId }); } catch (Throwable t) { @@ -2488,8 +2540,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName59, - _methodParameterTypes59, new Object[] { intPraticaId }); + _invokableLocalService.invokeMethod(_methodName60, + _methodParameterTypes60, new Object[] { intPraticaId }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -2518,8 +2570,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName60, - _methodParameterTypes60, + _invokableLocalService.invokeMethod(_methodName61, + _methodParameterTypes61, new Object[] { intPraticaId, controlloPraticaId, istruttoreId }); } catch (Throwable t) { @@ -2552,8 +2604,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName61, - _methodParameterTypes61, + returnObj = _invokableLocalService.invokeMethod(_methodName62, + _methodParameterTypes62, new Object[] { ispettoreId, @@ -2594,8 +2646,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName62, - _methodParameterTypes62, + returnObj = _invokableLocalService.invokeMethod(_methodName63, + _methodParameterTypes63, new Object[] { ispettoreId, @@ -2631,8 +2683,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName63, - _methodParameterTypes63, + returnObj = _invokableLocalService.invokeMethod(_methodName64, + _methodParameterTypes64, new Object[] { ClpSerializer.translateInput(intPratica), @@ -2670,8 +2722,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName64, - _methodParameterTypes64, + returnObj = _invokableLocalService.invokeMethod(_methodName65, + _methodParameterTypes65, new Object[] { intPraticaId, @@ -2708,8 +2760,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName65, - _methodParameterTypes65, + returnObj = _invokableLocalService.invokeMethod(_methodName66, + _methodParameterTypes66, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2744,8 +2796,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName66, - _methodParameterTypes66, + returnObj = _invokableLocalService.invokeMethod(_methodName67, + _methodParameterTypes67, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2780,8 +2832,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName67, - _methodParameterTypes67, + returnObj = _invokableLocalService.invokeMethod(_methodName68, + _methodParameterTypes68, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2816,8 +2868,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName68, - _methodParameterTypes68, + returnObj = _invokableLocalService.invokeMethod(_methodName69, + _methodParameterTypes69, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2854,8 +2906,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName69, - _methodParameterTypes69, + returnObj = _invokableLocalService.invokeMethod(_methodName70, + _methodParameterTypes70, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2895,8 +2947,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName70, - _methodParameterTypes70, + returnObj = _invokableLocalService.invokeMethod(_methodName71, + _methodParameterTypes71, new Object[] { ClpSerializer.translateInput(dtMin), @@ -2934,8 +2986,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName71, - _methodParameterTypes71, new Object[] { }); + returnObj = _invokableLocalService.invokeMethod(_methodName72, + _methodParameterTypes72, new Object[] { }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -2962,8 +3014,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName72, - _methodParameterTypes72, new Object[] { }); + returnObj = _invokableLocalService.invokeMethod(_methodName73, + _methodParameterTypes73, new Object[] { }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -2988,8 +3040,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { public void reIndexFascicolo( it.tref.liferay.portos.bo.model.IntPratica intPratica, long companyId) { try { - _invokableLocalService.invokeMethod(_methodName73, - _methodParameterTypes73, + _invokableLocalService.invokeMethod(_methodName74, + _methodParameterTypes74, new Object[] { ClpSerializer.translateInput(intPratica), companyId }); } catch (Throwable t) { @@ -3009,8 +3061,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { public void reIndexFasciolo(java.lang.String numeroProgetto, long companyId) throws com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName74, - _methodParameterTypes74, + _invokableLocalService.invokeMethod(_methodName75, + _methodParameterTypes75, new Object[] { ClpSerializer.translateInput(numeroProgetto), @@ -3039,8 +3091,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { throws com.liferay.portal.kernel.exception.PortalException, com.liferay.portal.kernel.exception.SystemException { try { - _invokableLocalService.invokeMethod(_methodName75, - _methodParameterTypes75, + _invokableLocalService.invokeMethod(_methodName76, + _methodParameterTypes76, new Object[] { intPraticaId, companyId }); } catch (Throwable t) { @@ -3070,8 +3122,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName76, - _methodParameterTypes76, new Object[] { }); + returnObj = _invokableLocalService.invokeMethod(_methodName77, + _methodParameterTypes77, new Object[] { }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -3099,8 +3151,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName77, - _methodParameterTypes77, + returnObj = _invokableLocalService.invokeMethod(_methodName78, + _methodParameterTypes78, new Object[] { ClpSerializer.translateInput(numeroProgetto) }); } catch (Throwable t) { @@ -3129,8 +3181,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName78, - _methodParameterTypes78, new Object[] { territorioId }); + returnObj = _invokableLocalService.invokeMethod(_methodName79, + _methodParameterTypes79, new Object[] { territorioId }); } catch (Throwable t) { t = ClpSerializer.translateThrowable(t); @@ -3159,8 +3211,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName79, - _methodParameterTypes79, + returnObj = _invokableLocalService.invokeMethod(_methodName80, + _methodParameterTypes80, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3197,8 +3249,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName80, - _methodParameterTypes80, + returnObj = _invokableLocalService.invokeMethod(_methodName81, + _methodParameterTypes81, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3234,8 +3286,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName81, - _methodParameterTypes81, + returnObj = _invokableLocalService.invokeMethod(_methodName82, + _methodParameterTypes82, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3272,8 +3324,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName82, - _methodParameterTypes82, + returnObj = _invokableLocalService.invokeMethod(_methodName83, + _methodParameterTypes83, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3308,8 +3360,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName83, - _methodParameterTypes83, + returnObj = _invokableLocalService.invokeMethod(_methodName84, + _methodParameterTypes84, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3344,8 +3396,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName84, - _methodParameterTypes84, + returnObj = _invokableLocalService.invokeMethod(_methodName85, + _methodParameterTypes85, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3380,8 +3432,8 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { Object returnObj = null; try { - returnObj = _invokableLocalService.invokeMethod(_methodName85, - _methodParameterTypes85, + returnObj = _invokableLocalService.invokeMethod(_methodName86, + _methodParameterTypes86, new Object[] { ClpSerializer.translateInput(dtMin), @@ -3580,4 +3632,6 @@ public class IntPraticaLocalServiceClp implements IntPraticaLocalService { private String[] _methodParameterTypes84; private String _methodName85; private String[] _methodParameterTypes85; + private String _methodName86; + private String[] _methodParameterTypes86; } \ No newline at end of file diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceUtil.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceUtil.java index f4d400b7..cbfeabab 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceUtil.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceUtil.java @@ -371,6 +371,17 @@ public class IntPraticaLocalServiceUtil { return getService().findSorteggiabili(companyId, dtSorteggio); } + public static it.tref.liferay.portos.bo.model.IntPratica addIntPratica( + long territorioId, java.lang.String tipoProcedura, + boolean isOspedaliera, + com.liferay.portal.service.ServiceContext serviceContext) + throws com.liferay.portal.kernel.exception.PortalException, + com.liferay.portal.kernel.exception.SystemException { + return getService() + .addIntPratica(territorioId, tipoProcedura, isOspedaliera, + serviceContext); + } + public static it.tref.liferay.portos.bo.model.IntPratica addIntPratica( long territorioId, java.lang.String tipoProcedura, com.liferay.portal.service.ServiceContext serviceContext) diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceWrapper.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceWrapper.java index eb9ec52a..b0c1b718 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceWrapper.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/IntPraticaLocalServiceWrapper.java @@ -395,6 +395,17 @@ public class IntPraticaLocalServiceWrapper implements IntPraticaLocalService, return _intPraticaLocalService.findSorteggiabili(companyId, dtSorteggio); } + @Override + public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( + long territorioId, java.lang.String tipoProcedura, + boolean isOspedaliera, + com.liferay.portal.service.ServiceContext serviceContext) + throws com.liferay.portal.kernel.exception.PortalException, + com.liferay.portal.kernel.exception.SystemException { + return _intPraticaLocalService.addIntPratica(territorioId, + tipoProcedura, isOspedaliera, serviceContext); + } + @Override public it.tref.liferay.portos.bo.model.IntPratica addIntPratica( long territorioId, java.lang.String tipoProcedura, diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/persistence/PraticaAttenzionataExportActionableDynamicQuery.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/persistence/PraticaAttenzionataExportActionableDynamicQuery.java new file mode 100644 index 00000000..2b29c751 --- /dev/null +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/service/persistence/PraticaAttenzionataExportActionableDynamicQuery.java @@ -0,0 +1,85 @@ +/** + * Copyright (c) 2000-present Liferay, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + */ + +package it.tref.liferay.portos.bo.service.persistence; + +import com.liferay.portal.kernel.dao.orm.DynamicQuery; +import com.liferay.portal.kernel.exception.PortalException; +import com.liferay.portal.kernel.exception.SystemException; +import com.liferay.portal.kernel.lar.ExportImportHelperUtil; +import com.liferay.portal.kernel.lar.ManifestSummary; +import com.liferay.portal.kernel.lar.PortletDataContext; +import com.liferay.portal.kernel.lar.StagedModelDataHandlerUtil; +import com.liferay.portal.kernel.lar.StagedModelType; +import com.liferay.portal.util.PortalUtil; + +import it.tref.liferay.portos.bo.model.PraticaAttenzionata; + +/** + * @author Davide Barbagallo, 3F Consulting + Manifattura Web Group s.r.l. + * @generated + */ +public class PraticaAttenzionataExportActionableDynamicQuery + extends PraticaAttenzionataActionableDynamicQuery { + public PraticaAttenzionataExportActionableDynamicQuery( + PortletDataContext portletDataContext) throws SystemException { + _portletDataContext = portletDataContext; + + setCompanyId(_portletDataContext.getCompanyId()); + + setGroupId(_portletDataContext.getScopeGroupId()); + } + + @Override + public long performCount() throws PortalException, SystemException { + ManifestSummary manifestSummary = _portletDataContext.getManifestSummary(); + + StagedModelType stagedModelType = getStagedModelType(); + + long modelAdditionCount = super.performCount(); + + manifestSummary.addModelAdditionCount(stagedModelType.toString(), + modelAdditionCount); + + long modelDeletionCount = ExportImportHelperUtil.getModelDeletionCount(_portletDataContext, + stagedModelType); + + manifestSummary.addModelDeletionCount(stagedModelType.toString(), + modelDeletionCount); + + return modelAdditionCount; + } + + @Override + protected void addCriteria(DynamicQuery dynamicQuery) { + _portletDataContext.addDateRangeCriteria(dynamicQuery, "modifiedDate"); + } + + protected StagedModelType getStagedModelType() { + return new StagedModelType(PortalUtil.getClassNameId( + PraticaAttenzionata.class.getName())); + } + + @Override + @SuppressWarnings("unused") + protected void performAction(Object object) + throws PortalException, SystemException { + PraticaAttenzionata stagedModel = (PraticaAttenzionata)object; + + StagedModelDataHandlerUtil.exportStagedModel(_portletDataContext, + stagedModel); + } + + private PortletDataContext _portletDataContext; +} \ No newline at end of file diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/util/AvvisoUtil.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/util/AvvisoUtil.java index b5d52818..2861c353 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/util/AvvisoUtil.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/service/it/tref/liferay/portos/bo/util/AvvisoUtil.java @@ -32,7 +32,8 @@ public class AvvisoUtil { public final static String FINE_LAVORI_AVVISO_FINE_LAVORI = "FL2"; /* Pratiche Ospedaliere */ - public static final String PRATICA_OSPEDALIERA = "PO"; + public static final String PRATICA_OSPEDALIERA_DEPOSITO = "PO_DEPO"; + public static final String PRATICA_OSPEDALIERA_CONFORMITA = "PO_CONF"; @SuppressWarnings("serial") private final static Map allTipoAvviso = new LinkedHashMap(2) { @@ -63,7 +64,8 @@ public class AvvisoUtil { put(StatoPraticaConstants.CAMBIO_ISTRUTTORE, "label.admingeniocivile.avviso.tipoDocumento.cambioistruttore"); put(FINE_LAVORI_AVVISO_INIZIO_LAVORI, "label.admingeniocivile.avviso.tipoDocumento.avvisoInizioLavori"); put(FINE_LAVORI_AVVISO_FINE_LAVORI, "label.admingeniocivile.avviso.tipoDocumento.avvisoFineLavori"); - put(PRATICA_OSPEDALIERA, "label.admingeniocivile.avviso.tipoDocumento.praticaOspedaliera"); + put(PRATICA_OSPEDALIERA_DEPOSITO, "label.admingeniocivile.avviso.tipoDocumento.praticaospedaliera.deposito"); + put(PRATICA_OSPEDALIERA_CONFORMITA, "label.admingeniocivile.avviso.tipoDocumento.praticaospedaliera.conformita"); } }; @@ -89,7 +91,8 @@ public class AvvisoUtil { put("DOM", "conf.geniocivile.avviso.folder.id.domanda_pdf"); put(FINE_LAVORI_AVVISO_INIZIO_LAVORI, "conf.geniocivile.avviso.folder.id.finelavori.FL1"); put(FINE_LAVORI_AVVISO_FINE_LAVORI, "conf.geniocivile.avviso.folder.id.finelavori.FL2"); - put(PRATICA_OSPEDALIERA, "conf.geniocivile.avviso.folder.id.praticaospedaliera"); + put(PRATICA_OSPEDALIERA_DEPOSITO, "conf.geniocivile.avviso.folder.id.praticaospedaliera.deposito"); + put(PRATICA_OSPEDALIERA_CONFORMITA, "conf.geniocivile.avviso.folder.id.praticaospedaliera.conformita"); } }; @@ -129,7 +132,8 @@ public class AvvisoUtil { put(FINE_LAVORI_AVVISO_INIZIO_LAVORI, "conf.geniocivile.avviso.template.id.finelavori.FL1"); put(FINE_LAVORI_AVVISO_FINE_LAVORI, "conf.geniocivile.avviso.template.id.finelavori.FL2"); - put(PRATICA_OSPEDALIERA, "conf.geniocivile.avviso.template.id.praticaospedaliera"); + put(PRATICA_OSPEDALIERA_DEPOSITO, "conf.geniocivile.avviso.template.id.praticaospedaliera.deposito"); + put(PRATICA_OSPEDALIERA_CONFORMITA, "conf.geniocivile.avviso.template.id.praticaospedaliera.conformita"); } }; diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Language.properties b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Language.properties index fcf20718..159a3f0c 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Language.properties +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Language.properties @@ -152,6 +152,8 @@ conf.geniocivile.avviso.folder.id.manuale = Cartella Avvisi Manuali conf.geniocivile.avviso.folder.id.doc_annullamento = Cartella File Annullamento Fascicolo conf.geniocivile.avviso.folder.id.doc_pagamento = Cartella File Allegati MDB conf.geniocivile.avviso.folder.id.domanda_pdf = Cartella Template Domanda +conf.geniocivile.avviso.folder.id.praticaospedaliera.deposito = Cartella Deposito Pratica Ospedaliera +conf.geniocivile.avviso.folder.id.praticaospedaliera.conformita = Cartella Conformità Pratica Ospedaliera #Configurazione Templates conf.geniocivile.template.folder.id = Cartella Template @@ -186,7 +188,8 @@ conf.geniocivile.avviso.template.id.deposito.PS = Template Avvisio avvio di proc conf.geniocivile.avviso.template.id.deposito.S = Template Avviso di sorteggio conf.geniocivile.avviso.template.id.finelavori.FL1 = Template Avviso di Inizio Lavori conf.geniocivile.avviso.template.id.finelavori.FL2 = Template Avviso di Fine Lavori -conf.geniocivile.avviso.template.id.praticaospedaliera = Template Avviso Pratica Ospedaliera +conf.geniocivile.avviso.template.id.praticaospedaliera.deposito = Template Deposito Pratica Ospedaliera +conf.geniocivile.avviso.template.id.praticaospedaliera.conformita = Template Conformità  Pratica Ospedaliera #Configurazione Allegati conf.geniocivile.attachment.folder.id = Folder Allegati diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Portal.properties b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Portal.properties index 8fdedc2d..370e4e16 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Portal.properties +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/content/Portal.properties @@ -1060,6 +1060,9 @@ label.admingeniocivile.statopratica.approvazione = Approvazione label.admingeniocivile.statopratica.finelavorianomalia = Anomalia Fine Lavori label.admingeniocivile.statopratica.variante = Variante label.admingeniocivile.statopratica.sospesa = Sospesa +label.admingeniocivile.avviso.tipoDocumento.praticaospedaliera.deposito = Avviso di deposito Pratica Ospedaliera +label.admingeniocivile.avviso.tipoDocumento.praticaospedaliera.conformita = Avviso di conformità Pratica Ospedaliera + label.firma-doc = Dichiaro di aver preso visione del documento, e di sottoscriverne il contenuto ai sensi del D.Lgs. 82/2005 label.cambio-soggetti-ok = Cambio Soggetti #{0} completato con successo diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/scheduler/SchedulerPratiche.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/scheduler/SchedulerPratiche.java index 4d0d8f03..3e082fa2 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/scheduler/SchedulerPratiche.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/scheduler/SchedulerPratiche.java @@ -265,19 +265,23 @@ public class SchedulerPratiche implements MessageListener { String propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(propertiesTemplateType); long fileEntryIdTemplate = ConfigurazioneLocalServiceUtil.findByC_ChiaveLong(companyId, propertiesTemplate); long controlloPraticaId = 0L; + _log.debug("creaAvvisoVidimazione: Pratica.isPraticaOspedaliera() ? " + IntPraticaLocalServiceUtil.getIntPratica(intPraticaId).isPraticaOspedaliera()); +// if(IntPraticaLocalServiceUtil.getIntPratica(intPraticaId).isPraticaOspedaliera()){ +// _log.debug("creaAvvisoVidimazione: Pratica is Ospedaliera - Creating PRATICA_OSPEDALIERA_DEPOSITO"); +// tipoDocumento = AvvisoUtil.PRATICA_OSPEDALIERA_DEPOSITO; +// propertiesTemplateType = AvvisoUtil.PRATICA_OSPEDALIERA_DEPOSITO; +// propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(propertiesTemplateType); +// fileEntryIdTemplate = ConfigurazioneLocalServiceUtil.findByC_ChiaveLong(companyId, propertiesTemplate); +// if(Validator.isNull(AvvisoLocalServiceUtil.getAvvisoPraticaOspedaliera(intPraticaId))){ +// AvvisoLocalServiceUtil.addAvviso(intPraticaId, descLong, +// dtAvviso, tipoAvviso, tipoDocumento, fileEntryIdTemplate, classPk, +// className, controlloPraticaId, serviceContext); +// } +// return; +// } + _log.debug("creaAvvisoVidimazione: tipoDocumento -> "+tipoDocumento); AvvisoLocalServiceUtil.addAvviso(intPraticaId, descLong, dtAvviso, tipoAvviso, tipoDocumento, fileEntryIdTemplate, classPk, className, controlloPraticaId, serviceContext); - if(IntPraticaLocalServiceUtil.getIntPratica(intPraticaId).isPraticaOspedaliera()){ - tipoDocumento = AvvisoUtil.PRATICA_OSPEDALIERA; - propertiesTemplateType = AvvisoUtil.PRATICA_OSPEDALIERA; - propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(propertiesTemplateType); - fileEntryIdTemplate = ConfigurazioneLocalServiceUtil.findByC_ChiaveLong(companyId, propertiesTemplate); - if(Validator.isNull(AvvisoLocalServiceUtil.getAvvisoPraticaOspedaliera(intPraticaId))){ - AvvisoLocalServiceUtil.addAvviso(intPraticaId, descLong, - dtAvviso, tipoAvviso, tipoDocumento, fileEntryIdTemplate, classPk, - className, controlloPraticaId, serviceContext); - } - } } private IntPratica assegnaNumeroProgetto(IntPratica intPratica) throws PortalException, SystemException { @@ -307,6 +311,7 @@ public class SchedulerPratiche implements MessageListener { if (TipoIntegrazioneUtil.RICHIESTA_INTEGRAZIONE.equals(tipoIntegrazione)) { // avviso pilotato per integrazioni String stato = StatoPraticaConstants.INTEGRAZIONE_ACCETTATA; + _log.debug("gestionePratica: Integrazione -> "+tipoIntegrazione+" | stato -> "+stato); AvvisoLocalServiceUtil.createStandardAvvisoPratica(dettPratica.getIntPraticaId(), stato, dettPratica.getDettPraticaId(), DettPratica.class.getName(), serviceContext, AvvisoUtil.TIPO_AVVISO_DIRETTO, StringPool.BLANK, 0L); @@ -318,6 +323,7 @@ public class SchedulerPratiche implements MessageListener { } else { stato = intPratica.getStatoPratica(); } + _log.debug("gestionePratica: Integrazione -> "+tipoIntegrazione+" | stato -> "+stato); AvvisoLocalServiceUtil.createStandardAvvisoPratica(dettPratica.getIntPraticaId(), stato, dettPratica.getDettPraticaId(), DettPratica.class.getName(), serviceContext, AvvisoUtil.TIPO_AVVISO_DIRETTO, StringPool.BLANK, 0L); @@ -327,6 +333,7 @@ public class SchedulerPratiche implements MessageListener { propertiesTemplateType); long fileEntryIdTemplate = ConfigurazioneLocalServiceUtil.findByC_ChiaveLong( serviceContext.getCompanyId(), propertiesTemplate); + _log.debug("gestionePratica: Integrazione -> "+tipoIntegrazione+" | propertiesTemplate -> "+propertiesTemplate); AvvisoLocalServiceUtil.addAvviso(dettPratica.getIntPraticaId(), StringPool.BLANK, new Date(), AvvisoUtil.TIPO_AVVISO_DIRETTO, StatoPraticaConstants.VIDIMATA, fileEntryIdTemplate, dettPratica.getDettPraticaId(), DettPratica.class.getName(), 0L, serviceContext); diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/base/IntPraticaLocalServiceClpInvoker.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/base/IntPraticaLocalServiceClpInvoker.java index 04bcb0c8..1bb785ee 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/base/IntPraticaLocalServiceClpInvoker.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/base/IntPraticaLocalServiceClpInvoker.java @@ -145,318 +145,325 @@ public class IntPraticaLocalServiceClpInvoker { _methodName196 = "addIntPratica"; _methodParameterTypes196 = new String[] { - "long", "java.lang.String", + "long", "java.lang.String", "boolean", "com.liferay.portal.service.ServiceContext" }; _methodName197 = "addIntPratica"; _methodParameterTypes197 = new String[] { + "long", "java.lang.String", + "com.liferay.portal.service.ServiceContext" + }; + + _methodName198 = "addIntPratica"; + + _methodParameterTypes198 = new String[] { "long", "java.lang.String", "java.lang.String", "long", "java.lang.String", "java.util.Date", "java.lang.String", "java.lang.String", "boolean", "int", "java.util.Date", "com.liferay.portal.service.ServiceContext" }; - _methodName198 = "deleteIntPratica"; + _methodName199 = "deleteIntPratica"; - _methodParameterTypes198 = new String[] { + _methodParameterTypes199 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "boolean" }; - _methodName199 = "deleteIntPratica"; + _methodName200 = "deleteIntPratica"; - _methodParameterTypes199 = new String[] { + _methodParameterTypes200 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica" }; - _methodName200 = "cloneIntPratica"; + _methodName201 = "cloneIntPratica"; - _methodParameterTypes200 = new String[] { + _methodParameterTypes201 = new String[] { "long", "com.liferay.portal.service.ServiceContext" }; - _methodName202 = "updateDelegati"; + _methodName203 = "updateDelegati"; - _methodParameterTypes202 = new String[] { + _methodParameterTypes203 = new String[] { "long", "java.lang.String", "java.lang.String", "boolean" }; - _methodName203 = "fetchIntPratica"; + _methodName204 = "fetchIntPratica"; - _methodParameterTypes203 = new String[] { "long" }; + _methodParameterTypes204 = new String[] { "long" }; - _methodName204 = "findFascicoliNotProgetto"; + _methodName205 = "findFascicoliNotProgetto"; - _methodParameterTypes204 = new String[] { "int", "int" }; + _methodParameterTypes205 = new String[] { "int", "int" }; - _methodName205 = "countFascicoliNotProgetto"; + _methodName206 = "countFascicoliNotProgetto"; - _methodParameterTypes205 = new String[] { }; + _methodParameterTypes206 = new String[] { }; - _methodName207 = "addNumeroProgetto"; + _methodName208 = "addNumeroProgetto"; - _methodParameterTypes207 = new String[] { "long" }; + _methodParameterTypes208 = new String[] { "long" }; - _methodName208 = "sospendiPratica"; + _methodName209 = "sospendiPratica"; - _methodParameterTypes208 = new String[] { "long", "boolean" }; + _methodParameterTypes209 = new String[] { "long", "boolean" }; - _methodName209 = "cambiaTitolare"; + _methodName210 = "cambiaTitolare"; - _methodParameterTypes209 = new String[] { + _methodParameterTypes210 = new String[] { "long", "long", "com.liferay.portal.service.ServiceContext" }; - _methodName210 = "updateStatoPratica"; + _methodName211 = "updateStatoPratica"; - _methodParameterTypes210 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes211 = new String[] { "long", "java.lang.String" }; - _methodName211 = "updateIntPraticaSorteggio"; + _methodName212 = "updateIntPraticaSorteggio"; - _methodParameterTypes211 = new String[] { "long", "java.util.Date" }; + _methodParameterTypes212 = new String[] { "long", "java.util.Date" }; - _methodName212 = "updateIntPraticaSorteggio"; + _methodName213 = "updateIntPraticaSorteggio"; - _methodParameterTypes212 = new String[] { + _methodParameterTypes213 = new String[] { "long", "java.util.Date", "java.lang.String" }; - _methodName213 = "findByC_UserId"; - - _methodParameterTypes213 = new String[] { "long", "long", "int", "int" }; + _methodName214 = "findByC_UserId"; - _methodName214 = "countByC_UserId"; + _methodParameterTypes214 = new String[] { "long", "long", "int", "int" }; - _methodParameterTypes214 = new String[] { "long", "long" }; + _methodName215 = "countByC_UserId"; - _methodName215 = "updateStatus"; + _methodParameterTypes215 = new String[] { "long", "long" }; - _methodParameterTypes215 = new String[] { "long", "int" }; + _methodName216 = "updateStatus"; - _methodName216 = "findByCompanyIdSoggettoProgetti"; + _methodParameterTypes216 = new String[] { "long", "int" }; - _methodParameterTypes216 = new String[] { "long", "long" }; - - _methodName217 = "countByCompanyIdSoggettoProgetti"; + _methodName217 = "findByCompanyIdSoggettoProgetti"; _methodParameterTypes217 = new String[] { "long", "long" }; - _methodName219 = "findByCompanyIdSoggettoArchivio"; + _methodName218 = "countByCompanyIdSoggettoProgetti"; - _methodParameterTypes219 = new String[] { "long", "long" }; + _methodParameterTypes218 = new String[] { "long", "long" }; - _methodName220 = "countByCompanyIdSoggettoArchivio"; + _methodName220 = "findByCompanyIdSoggettoArchivio"; _methodParameterTypes220 = new String[] { "long", "long" }; - _methodName222 = "findByCompanyIdSoggettoAltriProgetti"; + _methodName221 = "countByCompanyIdSoggettoArchivio"; + + _methodParameterTypes221 = new String[] { "long", "long" }; + + _methodName223 = "findByCompanyIdSoggettoAltriProgetti"; - _methodParameterTypes222 = new String[] { "long", "long", "int", "int" }; + _methodParameterTypes223 = new String[] { "long", "long", "int", "int" }; - _methodName223 = "countByCompanyIdSoggettoAltriProgetti"; + _methodName224 = "countByCompanyIdSoggettoAltriProgetti"; - _methodParameterTypes223 = new String[] { "long", "long" }; + _methodParameterTypes224 = new String[] { "long", "long" }; - _methodName225 = "findByCanAddFineLavori"; + _methodName226 = "findByCanAddFineLavori"; - _methodParameterTypes225 = new String[] { + _methodParameterTypes226 = new String[] { "long", "java.lang.String", "int", "int" }; - _methodName226 = "countByCanAddFineLavori"; + _methodName227 = "countByCanAddFineLavori"; - _methodParameterTypes226 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes227 = new String[] { "long", "java.lang.String" }; - _methodName228 = "findByCanAddCollaudo"; + _methodName229 = "findByCanAddCollaudo"; - _methodParameterTypes228 = new String[] { + _methodParameterTypes229 = new String[] { "long", "java.lang.String", "int", "int" }; - _methodName229 = "countByCanAddCollaudo"; + _methodName230 = "countByCanAddCollaudo"; - _methodParameterTypes229 = new String[] { "long", "java.lang.String" }; + _methodParameterTypes230 = new String[] { "long", "java.lang.String" }; - _methodName230 = "search"; + _methodName231 = "search"; - _methodParameterTypes230 = new String[] { "java.util.List", "int", "int" }; + _methodParameterTypes231 = new String[] { "java.util.List", "int", "int" }; - _methodName231 = "countSearch"; + _methodName232 = "countSearch"; - _methodParameterTypes231 = new String[] { "java.util.List" }; + _methodParameterTypes232 = new String[] { "java.util.List" }; - _methodName232 = "searchWithIntPraticaId"; + _methodName233 = "searchWithIntPraticaId"; - _methodParameterTypes232 = new String[] { + _methodParameterTypes233 = new String[] { "java.util.List", "long", "int", "int" }; - _methodName233 = "countSearchWithIntPraticaId"; + _methodName234 = "countSearchWithIntPraticaId"; - _methodParameterTypes233 = new String[] { "java.util.List", "long" }; + _methodParameterTypes234 = new String[] { "java.util.List", "long" }; - _methodName234 = "allegaFileAnnullamento"; + _methodName235 = "allegaFileAnnullamento"; - _methodParameterTypes234 = new String[] { + _methodParameterTypes235 = new String[] { "long", "byte[][]", "java.lang.String", "java.lang.String", "com.liferay.portal.service.ServiceContext" }; - _methodName235 = "generateFileAnnullamento"; + _methodName236 = "generateFileAnnullamento"; - _methodParameterTypes235 = new String[] { + _methodParameterTypes236 = new String[] { "long", "com.liferay.portal.service.ServiceContext" }; - _methodName236 = "deleteFileAnnullamento"; + _methodName237 = "deleteFileAnnullamento"; - _methodParameterTypes236 = new String[] { "long" }; + _methodParameterTypes237 = new String[] { "long" }; - _methodName237 = "completeAnnullamento"; + _methodName238 = "completeAnnullamento"; - _methodParameterTypes237 = new String[] { "long" }; + _methodParameterTypes238 = new String[] { "long" }; - _methodName238 = "cambiaIstruttore"; + _methodName239 = "cambiaIstruttore"; - _methodParameterTypes238 = new String[] { "long", "long", "long" }; + _methodParameterTypes239 = new String[] { "long", "long", "long" }; - _methodName239 = "countCaricoLavoroCF"; + _methodName240 = "countCaricoLavoroCF"; - _methodParameterTypes239 = new String[] { + _methodParameterTypes240 = new String[] { "long", "java.lang.String", "java.lang.Boolean", "java.lang.Long[][]" }; - _methodName240 = "countCaricoLavoroIstruttore"; + _methodName241 = "countCaricoLavoroIstruttore"; - _methodParameterTypes240 = new String[] { + _methodParameterTypes241 = new String[] { "long", "java.lang.String", "java.lang.Boolean" }; - _methodName241 = "generateReportPratica"; + _methodName242 = "generateReportPratica"; - _methodParameterTypes241 = new String[] { + _methodParameterTypes242 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "long" }; - _methodName242 = "updateModifiedDate"; + _methodName243 = "updateModifiedDate"; - _methodParameterTypes242 = new String[] { "long", "java.util.Date" }; + _methodParameterTypes243 = new String[] { "long", "java.util.Date" }; - _methodName243 = "countAutorizzazione"; + _methodName244 = "countAutorizzazione"; - _methodParameterTypes243 = new String[] { + _methodParameterTypes244 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName244 = "countSanatorie"; + _methodName245 = "countSanatorie"; - _methodParameterTypes244 = new String[] { + _methodParameterTypes245 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName245 = "countOpereMinoreImportanza"; + _methodName246 = "countOpereMinoreImportanza"; - _methodParameterTypes245 = new String[] { + _methodParameterTypes246 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName246 = "countDeposito"; + _methodName247 = "countDeposito"; - _methodParameterTypes246 = new String[] { + _methodParameterTypes247 = new String[] { "java.util.Date", "java.util.Date", "long", "boolean" }; - _methodName247 = "countVidimate"; + _methodName248 = "countVidimate"; - _methodParameterTypes247 = new String[] { + _methodParameterTypes248 = new String[] { "java.util.Date", "java.util.Date", "long", "java.lang.String", "boolean" }; - _methodName248 = "countControllo"; + _methodName249 = "countControllo"; - _methodParameterTypes248 = new String[] { + _methodParameterTypes249 = new String[] { "java.util.Date", "java.util.Date", "long", "java.lang.String", "boolean" }; - _methodName249 = "findIntPraticaNotExist"; + _methodName250 = "findIntPraticaNotExist"; - _methodParameterTypes249 = new String[] { }; + _methodParameterTypes250 = new String[] { }; - _methodName250 = "riparaWorkflow"; + _methodName251 = "riparaWorkflow"; - _methodParameterTypes250 = new String[] { }; + _methodParameterTypes251 = new String[] { }; - _methodName251 = "reIndexFascicolo"; + _methodName252 = "reIndexFascicolo"; - _methodParameterTypes251 = new String[] { + _methodParameterTypes252 = new String[] { "it.tref.liferay.portos.bo.model.IntPratica", "long" }; - _methodName252 = "reIndexFasciolo"; - - _methodParameterTypes252 = new String[] { "java.lang.String", "long" }; - _methodName253 = "reIndexFasciolo"; - _methodParameterTypes253 = new String[] { "long", "long" }; + _methodParameterTypes253 = new String[] { "java.lang.String", "long" }; - _methodName254 = "trovaDoppioni"; + _methodName254 = "reIndexFasciolo"; - _methodParameterTypes254 = new String[] { }; + _methodParameterTypes254 = new String[] { "long", "long" }; - _methodName255 = "findByNumeroProgetto"; + _methodName255 = "trovaDoppioni"; - _methodParameterTypes255 = new String[] { "java.lang.String" }; + _methodParameterTypes255 = new String[] { }; - _methodName256 = "findByTerritorioId"; + _methodName256 = "findByNumeroProgetto"; - _methodParameterTypes256 = new String[] { "long" }; + _methodParameterTypes256 = new String[] { "java.lang.String" }; - _methodName257 = "reportTempisticheIstruttorieAvvisiAutorizzazioni"; + _methodName257 = "findByTerritorioId"; - _methodParameterTypes257 = new String[] { - "java.util.Date", "java.util.Date", "long", "java.lang.String" - }; + _methodParameterTypes257 = new String[] { "long" }; - _methodName258 = "reportTempisticheIstruttorieCalcolaDataSorteggio"; + _methodName258 = "reportTempisticheIstruttorieAvvisiAutorizzazioni"; _methodParameterTypes258 = new String[] { - "java.util.Date", "java.util.Date", "long" + "java.util.Date", "java.util.Date", "long", "java.lang.String" }; - _methodName259 = "reportPraticheVidimate"; + _methodName259 = "reportTempisticheIstruttorieCalcolaDataSorteggio"; _methodParameterTypes259 = new String[] { - "java.util.Date", "java.util.Date", "long", "java.lang.String" + "java.util.Date", "java.util.Date", "long" }; - _methodName260 = "reportPraticheVidimateCalcolaDataSorteggio"; + _methodName260 = "reportPraticheVidimate"; _methodParameterTypes260 = new String[] { - "java.util.Date", "java.util.Date", "long" + "java.util.Date", "java.util.Date", "long", "java.lang.String" }; - _methodName261 = "countIngressiAutorizzazioni"; + _methodName261 = "reportPraticheVidimateCalcolaDataSorteggio"; _methodParameterTypes261 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName262 = "countIngressiDepositi"; + _methodName262 = "countIngressiAutorizzazioni"; _methodParameterTypes262 = new String[] { "java.util.Date", "java.util.Date", "long" }; - _methodName263 = "countIngressiCO"; + _methodName263 = "countIngressiDepositi"; _methodParameterTypes263 = new String[] { "java.util.Date", "java.util.Date", "long" }; + + _methodName264 = "countIngressiCO"; + + _methodParameterTypes264 = new String[] { + "java.util.Date", "java.util.Date", "long" + }; } public Object invokeMethod(String name, String[] parameterTypes, @@ -605,11 +612,19 @@ public class IntPraticaLocalServiceClpInvoker { Arrays.deepEquals(_methodParameterTypes196, parameterTypes)) { return IntPraticaLocalServiceUtil.addIntPratica(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], - (com.liferay.portal.service.ServiceContext)arguments[2]); + ((Boolean)arguments[2]).booleanValue(), + (com.liferay.portal.service.ServiceContext)arguments[3]); } if (_methodName197.equals(name) && Arrays.deepEquals(_methodParameterTypes197, parameterTypes)) { + return IntPraticaLocalServiceUtil.addIntPratica(((Long)arguments[0]).longValue(), + (java.lang.String)arguments[1], + (com.liferay.portal.service.ServiceContext)arguments[2]); + } + + if (_methodName198.equals(name) && + Arrays.deepEquals(_methodParameterTypes198, parameterTypes)) { return IntPraticaLocalServiceUtil.addIntPratica(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], (java.lang.String)arguments[2], ((Long)arguments[3]).longValue(), @@ -621,226 +636,226 @@ public class IntPraticaLocalServiceClpInvoker { (com.liferay.portal.service.ServiceContext)arguments[11]); } - if (_methodName198.equals(name) && - Arrays.deepEquals(_methodParameterTypes198, parameterTypes)) { + if (_methodName199.equals(name) && + Arrays.deepEquals(_methodParameterTypes199, parameterTypes)) { return IntPraticaLocalServiceUtil.deleteIntPratica((it.tref.liferay.portos.bo.model.IntPratica)arguments[0], ((Boolean)arguments[1]).booleanValue()); } - if (_methodName199.equals(name) && - Arrays.deepEquals(_methodParameterTypes199, parameterTypes)) { + if (_methodName200.equals(name) && + Arrays.deepEquals(_methodParameterTypes200, parameterTypes)) { return IntPraticaLocalServiceUtil.deleteIntPratica((it.tref.liferay.portos.bo.model.IntPratica)arguments[0]); } - if (_methodName200.equals(name) && - Arrays.deepEquals(_methodParameterTypes200, parameterTypes)) { + if (_methodName201.equals(name) && + Arrays.deepEquals(_methodParameterTypes201, parameterTypes)) { return IntPraticaLocalServiceUtil.cloneIntPratica(((Long)arguments[0]).longValue(), (com.liferay.portal.service.ServiceContext)arguments[1]); } - if (_methodName202.equals(name) && - Arrays.deepEquals(_methodParameterTypes202, parameterTypes)) { + if (_methodName203.equals(name) && + Arrays.deepEquals(_methodParameterTypes203, parameterTypes)) { return IntPraticaLocalServiceUtil.updateDelegati(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], (java.lang.String)arguments[2], ((Boolean)arguments[3]).booleanValue()); } - if (_methodName203.equals(name) && - Arrays.deepEquals(_methodParameterTypes203, parameterTypes)) { + if (_methodName204.equals(name) && + Arrays.deepEquals(_methodParameterTypes204, parameterTypes)) { return IntPraticaLocalServiceUtil.fetchIntPratica(((Long)arguments[0]).longValue()); } - if (_methodName204.equals(name) && - Arrays.deepEquals(_methodParameterTypes204, parameterTypes)) { + if (_methodName205.equals(name) && + Arrays.deepEquals(_methodParameterTypes205, parameterTypes)) { return IntPraticaLocalServiceUtil.findFascicoliNotProgetto(((Integer)arguments[0]).intValue(), ((Integer)arguments[1]).intValue()); } - if (_methodName205.equals(name) && - Arrays.deepEquals(_methodParameterTypes205, parameterTypes)) { + if (_methodName206.equals(name) && + Arrays.deepEquals(_methodParameterTypes206, parameterTypes)) { return IntPraticaLocalServiceUtil.countFascicoliNotProgetto(); } - if (_methodName207.equals(name) && - Arrays.deepEquals(_methodParameterTypes207, parameterTypes)) { + if (_methodName208.equals(name) && + Arrays.deepEquals(_methodParameterTypes208, parameterTypes)) { return IntPraticaLocalServiceUtil.addNumeroProgetto(((Long)arguments[0]).longValue()); } - if (_methodName208.equals(name) && - Arrays.deepEquals(_methodParameterTypes208, parameterTypes)) { + if (_methodName209.equals(name) && + Arrays.deepEquals(_methodParameterTypes209, parameterTypes)) { return IntPraticaLocalServiceUtil.sospendiPratica(((Long)arguments[0]).longValue(), ((Boolean)arguments[1]).booleanValue()); } - if (_methodName209.equals(name) && - Arrays.deepEquals(_methodParameterTypes209, parameterTypes)) { + if (_methodName210.equals(name) && + Arrays.deepEquals(_methodParameterTypes210, parameterTypes)) { return IntPraticaLocalServiceUtil.cambiaTitolare(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue(), (com.liferay.portal.service.ServiceContext)arguments[2]); } - if (_methodName210.equals(name) && - Arrays.deepEquals(_methodParameterTypes210, parameterTypes)) { + if (_methodName211.equals(name) && + Arrays.deepEquals(_methodParameterTypes211, parameterTypes)) { return IntPraticaLocalServiceUtil.updateStatoPratica(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1]); } - if (_methodName211.equals(name) && - Arrays.deepEquals(_methodParameterTypes211, parameterTypes)) { + if (_methodName212.equals(name) && + Arrays.deepEquals(_methodParameterTypes212, parameterTypes)) { return IntPraticaLocalServiceUtil.updateIntPraticaSorteggio(((Long)arguments[0]).longValue(), (java.util.Date)arguments[1]); } - if (_methodName212.equals(name) && - Arrays.deepEquals(_methodParameterTypes212, parameterTypes)) { + if (_methodName213.equals(name) && + Arrays.deepEquals(_methodParameterTypes213, parameterTypes)) { return IntPraticaLocalServiceUtil.updateIntPraticaSorteggio(((Long)arguments[0]).longValue(), (java.util.Date)arguments[1], (java.lang.String)arguments[2]); } - if (_methodName213.equals(name) && - Arrays.deepEquals(_methodParameterTypes213, parameterTypes)) { + if (_methodName214.equals(name) && + Arrays.deepEquals(_methodParameterTypes214, parameterTypes)) { return IntPraticaLocalServiceUtil.findByC_UserId(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue(), ((Integer)arguments[2]).intValue(), ((Integer)arguments[3]).intValue()); } - if (_methodName214.equals(name) && - Arrays.deepEquals(_methodParameterTypes214, parameterTypes)) { + if (_methodName215.equals(name) && + Arrays.deepEquals(_methodParameterTypes215, parameterTypes)) { return IntPraticaLocalServiceUtil.countByC_UserId(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName215.equals(name) && - Arrays.deepEquals(_methodParameterTypes215, parameterTypes)) { + if (_methodName216.equals(name) && + Arrays.deepEquals(_methodParameterTypes216, parameterTypes)) { IntPraticaLocalServiceUtil.updateStatus(((Long)arguments[0]).longValue(), ((Integer)arguments[1]).intValue()); return null; } - if (_methodName216.equals(name) && - Arrays.deepEquals(_methodParameterTypes216, parameterTypes)) { + if (_methodName217.equals(name) && + Arrays.deepEquals(_methodParameterTypes217, parameterTypes)) { return IntPraticaLocalServiceUtil.findByCompanyIdSoggettoProgetti(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName217.equals(name) && - Arrays.deepEquals(_methodParameterTypes217, parameterTypes)) { + if (_methodName218.equals(name) && + Arrays.deepEquals(_methodParameterTypes218, parameterTypes)) { return IntPraticaLocalServiceUtil.countByCompanyIdSoggettoProgetti(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName219.equals(name) && - Arrays.deepEquals(_methodParameterTypes219, parameterTypes)) { + if (_methodName220.equals(name) && + Arrays.deepEquals(_methodParameterTypes220, parameterTypes)) { return IntPraticaLocalServiceUtil.findByCompanyIdSoggettoArchivio(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName220.equals(name) && - Arrays.deepEquals(_methodParameterTypes220, parameterTypes)) { + if (_methodName221.equals(name) && + Arrays.deepEquals(_methodParameterTypes221, parameterTypes)) { return IntPraticaLocalServiceUtil.countByCompanyIdSoggettoArchivio(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName222.equals(name) && - Arrays.deepEquals(_methodParameterTypes222, parameterTypes)) { + if (_methodName223.equals(name) && + Arrays.deepEquals(_methodParameterTypes223, parameterTypes)) { return IntPraticaLocalServiceUtil.findByCompanyIdSoggettoAltriProgetti(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue(), ((Integer)arguments[2]).intValue(), ((Integer)arguments[3]).intValue()); } - if (_methodName223.equals(name) && - Arrays.deepEquals(_methodParameterTypes223, parameterTypes)) { + if (_methodName224.equals(name) && + Arrays.deepEquals(_methodParameterTypes224, parameterTypes)) { return IntPraticaLocalServiceUtil.countByCompanyIdSoggettoAltriProgetti(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue()); } - if (_methodName225.equals(name) && - Arrays.deepEquals(_methodParameterTypes225, parameterTypes)) { + if (_methodName226.equals(name) && + Arrays.deepEquals(_methodParameterTypes226, parameterTypes)) { return IntPraticaLocalServiceUtil.findByCanAddFineLavori(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], ((Integer)arguments[2]).intValue(), ((Integer)arguments[3]).intValue()); } - if (_methodName226.equals(name) && - Arrays.deepEquals(_methodParameterTypes226, parameterTypes)) { + if (_methodName227.equals(name) && + Arrays.deepEquals(_methodParameterTypes227, parameterTypes)) { return IntPraticaLocalServiceUtil.countByCanAddFineLavori(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1]); } - if (_methodName228.equals(name) && - Arrays.deepEquals(_methodParameterTypes228, parameterTypes)) { + if (_methodName229.equals(name) && + Arrays.deepEquals(_methodParameterTypes229, parameterTypes)) { return IntPraticaLocalServiceUtil.findByCanAddCollaudo(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], ((Integer)arguments[2]).intValue(), ((Integer)arguments[3]).intValue()); } - if (_methodName229.equals(name) && - Arrays.deepEquals(_methodParameterTypes229, parameterTypes)) { + if (_methodName230.equals(name) && + Arrays.deepEquals(_methodParameterTypes230, parameterTypes)) { return IntPraticaLocalServiceUtil.countByCanAddCollaudo(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1]); } - if (_methodName230.equals(name) && - Arrays.deepEquals(_methodParameterTypes230, parameterTypes)) { + if (_methodName231.equals(name) && + Arrays.deepEquals(_methodParameterTypes231, parameterTypes)) { return IntPraticaLocalServiceUtil.search((java.util.List)arguments[0], ((Integer)arguments[1]).intValue(), ((Integer)arguments[2]).intValue()); } - if (_methodName231.equals(name) && - Arrays.deepEquals(_methodParameterTypes231, parameterTypes)) { + if (_methodName232.equals(name) && + Arrays.deepEquals(_methodParameterTypes232, parameterTypes)) { return IntPraticaLocalServiceUtil.countSearch((java.util.List)arguments[0]); } - if (_methodName232.equals(name) && - Arrays.deepEquals(_methodParameterTypes232, parameterTypes)) { + if (_methodName233.equals(name) && + Arrays.deepEquals(_methodParameterTypes233, parameterTypes)) { return IntPraticaLocalServiceUtil.searchWithIntPraticaId((java.util.List)arguments[0], ((Long)arguments[1]).longValue(), ((Integer)arguments[2]).intValue(), ((Integer)arguments[3]).intValue()); } - if (_methodName233.equals(name) && - Arrays.deepEquals(_methodParameterTypes233, parameterTypes)) { + if (_methodName234.equals(name) && + Arrays.deepEquals(_methodParameterTypes234, parameterTypes)) { return IntPraticaLocalServiceUtil.countSearchWithIntPraticaId((java.util.List)arguments[0], ((Long)arguments[1]).longValue()); } - if (_methodName234.equals(name) && - Arrays.deepEquals(_methodParameterTypes234, parameterTypes)) { + if (_methodName235.equals(name) && + Arrays.deepEquals(_methodParameterTypes235, parameterTypes)) { return IntPraticaLocalServiceUtil.allegaFileAnnullamento(((Long)arguments[0]).longValue(), (byte[])arguments[1], (java.lang.String)arguments[2], (java.lang.String)arguments[3], (com.liferay.portal.service.ServiceContext)arguments[4]); } - if (_methodName235.equals(name) && - Arrays.deepEquals(_methodParameterTypes235, parameterTypes)) { + if (_methodName236.equals(name) && + Arrays.deepEquals(_methodParameterTypes236, parameterTypes)) { return IntPraticaLocalServiceUtil.generateFileAnnullamento(((Long)arguments[0]).longValue(), (com.liferay.portal.service.ServiceContext)arguments[1]); } - if (_methodName236.equals(name) && - Arrays.deepEquals(_methodParameterTypes236, parameterTypes)) { + if (_methodName237.equals(name) && + Arrays.deepEquals(_methodParameterTypes237, parameterTypes)) { IntPraticaLocalServiceUtil.deleteFileAnnullamento(((Long)arguments[0]).longValue()); return null; } - if (_methodName237.equals(name) && - Arrays.deepEquals(_methodParameterTypes237, parameterTypes)) { + if (_methodName238.equals(name) && + Arrays.deepEquals(_methodParameterTypes238, parameterTypes)) { IntPraticaLocalServiceUtil.completeAnnullamento(((Long)arguments[0]).longValue()); return null; } - if (_methodName238.equals(name) && - Arrays.deepEquals(_methodParameterTypes238, parameterTypes)) { + if (_methodName239.equals(name) && + Arrays.deepEquals(_methodParameterTypes239, parameterTypes)) { IntPraticaLocalServiceUtil.cambiaIstruttore(((Long)arguments[0]).longValue(), ((Long)arguments[1]).longValue(), ((Long)arguments[2]).longValue()); @@ -848,67 +863,59 @@ public class IntPraticaLocalServiceClpInvoker { return null; } - if (_methodName239.equals(name) && - Arrays.deepEquals(_methodParameterTypes239, parameterTypes)) { + if (_methodName240.equals(name) && + Arrays.deepEquals(_methodParameterTypes240, parameterTypes)) { return IntPraticaLocalServiceUtil.countCaricoLavoroCF(((Long)arguments[0]).longValue(), (java.lang.String)arguments[1], (java.lang.Boolean)arguments[2], (java.lang.Long[])arguments[3]); } - if (_methodName240.equals(name) && - Arrays.deepEquals(_methodParameterTypes240, parameterTypes)) { - return IntPraticaLocalServiceUtil.countCaricoLavoroIstruttore(((Long)arguments[0]).longValue(), - (java.lang.String)arguments[1], (java.lang.Boolean)arguments[2]); - } - if (_methodName241.equals(name) && Arrays.deepEquals(_methodParameterTypes241, parameterTypes)) { - return IntPraticaLocalServiceUtil.generateReportPratica((it.tref.liferay.portos.bo.model.IntPratica)arguments[0], - ((Long)arguments[1]).longValue()); + return IntPraticaLocalServiceUtil.countCaricoLavoroIstruttore(((Long)arguments[0]).longValue(), + (java.lang.String)arguments[1], (java.lang.Boolean)arguments[2]); } if (_methodName242.equals(name) && Arrays.deepEquals(_methodParameterTypes242, parameterTypes)) { - return IntPraticaLocalServiceUtil.updateModifiedDate(((Long)arguments[0]).longValue(), - (java.util.Date)arguments[1]); + return IntPraticaLocalServiceUtil.generateReportPratica((it.tref.liferay.portos.bo.model.IntPratica)arguments[0], + ((Long)arguments[1]).longValue()); } if (_methodName243.equals(name) && Arrays.deepEquals(_methodParameterTypes243, parameterTypes)) { - return IntPraticaLocalServiceUtil.countAutorizzazione((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); + return IntPraticaLocalServiceUtil.updateModifiedDate(((Long)arguments[0]).longValue(), + (java.util.Date)arguments[1]); } if (_methodName244.equals(name) && Arrays.deepEquals(_methodParameterTypes244, parameterTypes)) { - return IntPraticaLocalServiceUtil.countSanatorie((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.countAutorizzazione((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName245.equals(name) && Arrays.deepEquals(_methodParameterTypes245, parameterTypes)) { - return IntPraticaLocalServiceUtil.countOpereMinoreImportanza((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.countSanatorie((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName246.equals(name) && Arrays.deepEquals(_methodParameterTypes246, parameterTypes)) { - return IntPraticaLocalServiceUtil.countDeposito((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), - ((Boolean)arguments[3]).booleanValue()); + return IntPraticaLocalServiceUtil.countOpereMinoreImportanza((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName247.equals(name) && Arrays.deepEquals(_methodParameterTypes247, parameterTypes)) { - return IntPraticaLocalServiceUtil.countVidimate((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.countDeposito((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), - (java.lang.String)arguments[3], - ((Boolean)arguments[4]).booleanValue()); + ((Boolean)arguments[3]).booleanValue()); } if (_methodName248.equals(name) && Arrays.deepEquals(_methodParameterTypes248, parameterTypes)) { - return IntPraticaLocalServiceUtil.countControllo((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.countVidimate((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), (java.lang.String)arguments[3], ((Boolean)arguments[4]).booleanValue()); @@ -916,25 +923,25 @@ public class IntPraticaLocalServiceClpInvoker { if (_methodName249.equals(name) && Arrays.deepEquals(_methodParameterTypes249, parameterTypes)) { - return IntPraticaLocalServiceUtil.findIntPraticaNotExist(); + return IntPraticaLocalServiceUtil.countControllo((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), + (java.lang.String)arguments[3], + ((Boolean)arguments[4]).booleanValue()); } if (_methodName250.equals(name) && Arrays.deepEquals(_methodParameterTypes250, parameterTypes)) { - return IntPraticaLocalServiceUtil.riparaWorkflow(); + return IntPraticaLocalServiceUtil.findIntPraticaNotExist(); } if (_methodName251.equals(name) && Arrays.deepEquals(_methodParameterTypes251, parameterTypes)) { - IntPraticaLocalServiceUtil.reIndexFascicolo((it.tref.liferay.portos.bo.model.IntPratica)arguments[0], - ((Long)arguments[1]).longValue()); - - return null; + return IntPraticaLocalServiceUtil.riparaWorkflow(); } if (_methodName252.equals(name) && Arrays.deepEquals(_methodParameterTypes252, parameterTypes)) { - IntPraticaLocalServiceUtil.reIndexFasciolo((java.lang.String)arguments[0], + IntPraticaLocalServiceUtil.reIndexFascicolo((it.tref.liferay.portos.bo.model.IntPratica)arguments[0], ((Long)arguments[1]).longValue()); return null; @@ -942,7 +949,7 @@ public class IntPraticaLocalServiceClpInvoker { if (_methodName253.equals(name) && Arrays.deepEquals(_methodParameterTypes253, parameterTypes)) { - IntPraticaLocalServiceUtil.reIndexFasciolo(((Long)arguments[0]).longValue(), + IntPraticaLocalServiceUtil.reIndexFasciolo((java.lang.String)arguments[0], ((Long)arguments[1]).longValue()); return null; @@ -950,59 +957,67 @@ public class IntPraticaLocalServiceClpInvoker { if (_methodName254.equals(name) && Arrays.deepEquals(_methodParameterTypes254, parameterTypes)) { - return IntPraticaLocalServiceUtil.trovaDoppioni(); + IntPraticaLocalServiceUtil.reIndexFasciolo(((Long)arguments[0]).longValue(), + ((Long)arguments[1]).longValue()); + + return null; } if (_methodName255.equals(name) && Arrays.deepEquals(_methodParameterTypes255, parameterTypes)) { - return IntPraticaLocalServiceUtil.findByNumeroProgetto((java.lang.String)arguments[0]); + return IntPraticaLocalServiceUtil.trovaDoppioni(); } if (_methodName256.equals(name) && Arrays.deepEquals(_methodParameterTypes256, parameterTypes)) { - return IntPraticaLocalServiceUtil.findByTerritorioId(((Long)arguments[0]).longValue()); + return IntPraticaLocalServiceUtil.findByNumeroProgetto((java.lang.String)arguments[0]); } if (_methodName257.equals(name) && Arrays.deepEquals(_methodParameterTypes257, parameterTypes)) { - return IntPraticaLocalServiceUtil.reportTempisticheIstruttorieAvvisiAutorizzazioni((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), - (java.lang.String)arguments[3]); + return IntPraticaLocalServiceUtil.findByTerritorioId(((Long)arguments[0]).longValue()); } if (_methodName258.equals(name) && Arrays.deepEquals(_methodParameterTypes258, parameterTypes)) { - return IntPraticaLocalServiceUtil.reportTempisticheIstruttorieCalcolaDataSorteggio((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); + return IntPraticaLocalServiceUtil.reportTempisticheIstruttorieAvvisiAutorizzazioni((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), + (java.lang.String)arguments[3]); } if (_methodName259.equals(name) && Arrays.deepEquals(_methodParameterTypes259, parameterTypes)) { - return IntPraticaLocalServiceUtil.reportPraticheVidimate((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), - (java.lang.String)arguments[3]); + return IntPraticaLocalServiceUtil.reportTempisticheIstruttorieCalcolaDataSorteggio((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName260.equals(name) && Arrays.deepEquals(_methodParameterTypes260, parameterTypes)) { - return IntPraticaLocalServiceUtil.reportPraticheVidimateCalcolaDataSorteggio((java.util.Date)arguments[0], - (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); + return IntPraticaLocalServiceUtil.reportPraticheVidimate((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue(), + (java.lang.String)arguments[3]); } if (_methodName261.equals(name) && Arrays.deepEquals(_methodParameterTypes261, parameterTypes)) { - return IntPraticaLocalServiceUtil.countIngressiAutorizzazioni((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.reportPraticheVidimateCalcolaDataSorteggio((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName262.equals(name) && Arrays.deepEquals(_methodParameterTypes262, parameterTypes)) { - return IntPraticaLocalServiceUtil.countIngressiDepositi((java.util.Date)arguments[0], + return IntPraticaLocalServiceUtil.countIngressiAutorizzazioni((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } if (_methodName263.equals(name) && Arrays.deepEquals(_methodParameterTypes263, parameterTypes)) { + return IntPraticaLocalServiceUtil.countIngressiDepositi((java.util.Date)arguments[0], + (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); + } + + if (_methodName264.equals(name) && + Arrays.deepEquals(_methodParameterTypes264, parameterTypes)) { return IntPraticaLocalServiceUtil.countIngressiCO((java.util.Date)arguments[0], (java.util.Date)arguments[1], ((Long)arguments[2]).longValue()); } @@ -1070,16 +1085,16 @@ public class IntPraticaLocalServiceClpInvoker { private String[] _methodParameterTypes199; private String _methodName200; private String[] _methodParameterTypes200; - private String _methodName202; - private String[] _methodParameterTypes202; + private String _methodName201; + private String[] _methodParameterTypes201; private String _methodName203; private String[] _methodParameterTypes203; private String _methodName204; private String[] _methodParameterTypes204; private String _methodName205; private String[] _methodParameterTypes205; - private String _methodName207; - private String[] _methodParameterTypes207; + private String _methodName206; + private String[] _methodParameterTypes206; private String _methodName208; private String[] _methodParameterTypes208; private String _methodName209; @@ -1100,20 +1115,20 @@ public class IntPraticaLocalServiceClpInvoker { private String[] _methodParameterTypes216; private String _methodName217; private String[] _methodParameterTypes217; - private String _methodName219; - private String[] _methodParameterTypes219; + private String _methodName218; + private String[] _methodParameterTypes218; private String _methodName220; private String[] _methodParameterTypes220; - private String _methodName222; - private String[] _methodParameterTypes222; + private String _methodName221; + private String[] _methodParameterTypes221; private String _methodName223; private String[] _methodParameterTypes223; - private String _methodName225; - private String[] _methodParameterTypes225; + private String _methodName224; + private String[] _methodParameterTypes224; private String _methodName226; private String[] _methodParameterTypes226; - private String _methodName228; - private String[] _methodParameterTypes228; + private String _methodName227; + private String[] _methodParameterTypes227; private String _methodName229; private String[] _methodParameterTypes229; private String _methodName230; @@ -1184,4 +1199,6 @@ public class IntPraticaLocalServiceClpInvoker { private String[] _methodParameterTypes262; private String _methodName263; private String[] _methodParameterTypes263; + private String _methodName264; + private String[] _methodParameterTypes264; } \ No newline at end of file diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/AvvisoLocalServiceImpl.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/AvvisoLocalServiceImpl.java index fe4ef877..702d9590 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/AvvisoLocalServiceImpl.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/AvvisoLocalServiceImpl.java @@ -115,6 +115,8 @@ public class AvvisoLocalServiceImpl extends AvvisoLocalServiceBaseImpl { if (Validator.isNull(tipoProcedura) || tipoProcedura.equalsIgnoreCase(Constants.PROCEDURA_A) || Validator.isNull(sorteggio)) { propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(statoPratica); + } else if (intPratica.isPraticaOspedaliera()){ + propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(AvvisoUtil.PRATICA_OSPEDALIERA_DEPOSITO); } else { propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get("DPPS"); } @@ -122,13 +124,23 @@ public class AvvisoLocalServiceImpl extends AvvisoLocalServiceBaseImpl { case StatoPraticaConstants.VIDIMATA: if (null == tipoProcedura) tipoProcedura = Constants.PROCEDURA_A; - propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get("DP" + tipoProcedura); + if(intPratica.isPraticaOspedaliera()){ + propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(AvvisoUtil.PRATICA_OSPEDALIERA_DEPOSITO); + } else { + propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get("DP" + tipoProcedura); + } break; default: - propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(statoPratica); +// if(StatoPraticaConstants.AUTORIZZATA.equals(statoPratica) && intPratica.isPraticaOspedaliera()){ +// propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(AvvisoUtil.PRATICA_OSPEDALIERA_CONFORMITA); +// } else { + propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(statoPratica); +// } } long fileEntryIdTemplate = configurazioneLocalService.findByC_ChiaveLong(serviceContext.getCompanyId(), propertiesTemplate); + _log.debug("Creating avviso: propertiesTemplate -> "+propertiesTemplate + +" | statoPratica -> "+statoPratica+" | className -> "+className); return addAvviso(intPratica.getIntPraticaId(), StringPool.BLANK, new Date(), tipoAvviso, statoPratica, fileEntryIdTemplate, classPk, className, userCodiceFiscalePrimaFirma, jsonParameters, controlloPraticaId, serviceContext); @@ -149,9 +161,14 @@ public class AvvisoLocalServiceImpl extends AvvisoLocalServiceBaseImpl { && !dettPratica.getVarianteSostanziale() && !stato.equalsIgnoreCase(StatoPraticaConstants.INTEGRAZIONE); } String statoPraticaCode = varianteNonSostanziale ? "DPVNS" : PraticaUtil.getStatoPraticaCode(stato, intPratica); + if(intPratica.isPraticaOspedaliera()){ + statoPraticaCode = AvvisoUtil.PRATICA_OSPEDALIERA_CONFORMITA; + } String propertiesTemplate = AvvisoUtil.getAllTipoDocumentoFileTemplateProps().get(statoPraticaCode); long fileEntryIdTemplate = configurazioneLocalService.findByC_ChiaveLong(serviceContext.getCompanyId(), propertiesTemplate); + _log.debug("Creating avviso: propertiesTemplate -> "+propertiesTemplate + +" | statoPraticaCode -> "+statoPraticaCode+" | className -> "+className); return addAvviso(intPraticaId, StringPool.BLANK, new Date(), tipoAvviso, stato, fileEntryIdTemplate, classPk, className, userCodiceFiscalePrimaFirma, jsonParameters, controlloPraticaId, serviceContext); } @@ -1291,7 +1308,7 @@ public class AvvisoLocalServiceImpl extends AvvisoLocalServiceBaseImpl { DynamicQuery dynamicQuery = avvisoLocalService.dynamicQuery(); dynamicQuery.add(PropertyFactoryUtil.forName("tipoDocumento").in( - new String[] { AvvisoUtil.PRATICA_OSPEDALIERA })); + new String[] { AvvisoUtil.PRATICA_OSPEDALIERA_CONFORMITA, AvvisoUtil.PRATICA_OSPEDALIERA_DEPOSITO })); dynamicQuery.add(PropertyFactoryUtil.forName("fileEntryIdProtocollo").ne(0L)); dynamicQuery.add(PropertyFactoryUtil.forName("errore").eq(false)); dynamicQuery.add(PropertyFactoryUtil.forName("annullato").eq(false)); diff --git a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/IntPraticaLocalServiceImpl.java b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/IntPraticaLocalServiceImpl.java index c06f83ca..4ac9c746 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/IntPraticaLocalServiceImpl.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-bo-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/bo/service/impl/IntPraticaLocalServiceImpl.java @@ -231,7 +231,19 @@ public class IntPraticaLocalServiceImpl extends IntPraticaLocalServiceBaseImpl { } return ret; } + + @Override + @Indexable(type = IndexableType.REINDEX) + public IntPratica addIntPratica(long territorioId, String tipoProcedura, boolean isOspedaliera, + ServiceContext serviceContext) throws SystemException, PortalException { + if(isOspedaliera){ + tipoProcedura = Constants.PROCEDURA_H; + } + + return addIntPratica(territorioId, tipoProcedura, serviceContext); + } + @Override @Indexable(type = IndexableType.REINDEX) public IntPratica addIntPratica(long territorioId, String tipoProcedura, ServiceContext serviceContext) @@ -398,7 +410,7 @@ public class IntPraticaLocalServiceImpl extends IntPraticaLocalServiceBaseImpl { IntPratica intPraticaToClone = intPraticaLocalService.getIntPratica(intPraticaId); IntPratica intPraticaCloned = addIntPratica(intPraticaToClone.getTerritorioId(), - intPraticaToClone.getTipoProcedura(), serviceContext); + intPraticaToClone.getTipoProcedura(), intPraticaCloned.isPraticaOspedaliera(), serviceContext); intPraticaCloned = cloneData(intPraticaCloned, intPraticaToClone); DettPratica dettPraticaToClone = dettPraticaLocalService.getLastCompletedByIntPratica(intPraticaId); DettPratica dettPraticaCloned = dettPraticaLocalService.addDettPraticaClonedToIntPratica( diff --git a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-bo-portlet-service.jar b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-bo-portlet-service.jar index 188cb9e41a4f362fa467b8ce6a05c67726f4d8a9..d11688cbc7b7acb7b4e1936e2368bbdd42471699 100644 GIT binary patch delta 61108 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�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 delta 56779 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 diff --git a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-mail-manager-shared.jar b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-mail-manager-shared.jar index 20883a9c6cbffc049b3ac1506ee13e9311c50dce..6e60096df6c0a699b20e22c65a93f8d328abb1d4 100644 GIT binary patch delta 433 zcmX@o%y^`kkvG7bnT3mifrEj;Bk|ZoUJYhF{_+LF--Oy@D$f$8;(u3-8*qd%DTWC{k;^O-`x^fxANFzv$Z1)?`kWY%Q{ zGY+yHgD|?dgqgr13wUPpf*E#Fn(SakmSO@6m~mFs45EfjV-p8hWVgW*Mld7Ehyx;( zYof=(4D{gSc@`ERA5Ok$VGmLnRS`L zjDu{)AdD_9VJ5K10-o8tV1}KPCOepsrI^41W}H|8QV7kfD8cZLsbOO_?R(@bQ%qkR2ud|8= z(*oAXV7kmY1x(+yjt0}#Hc?=DhD{Ba7PqYc)01qgz%;*IC7ABE%Lmhc?OMTft9=QW W{$rm3rqdm=!Sq#!EHLfl*aQGQ0)C7D diff --git a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-report-shared.jar b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/lib/portos-report-shared.jar index 5302f8973a6c73193503a3f5f16ff4a01fabacf4..e79e6878e6c18d3bafabcfe18fd3541a4b20c692 100644 GIT binary patch delta 442 zcmey`&G@yOkvG7bnT3mifrEj;Bk|ZoUJYhF{_+LF--Oy@CLg6UO^4q&>G$!zik2d>GwOk7~T6_X28+zU*fV{!%2o5h&V zFo79QSx-Y4n>m=6!6G}jEg_6Ad?y&eBKrl(*}x1-@y8G;d1)Jnt~gnLRFZFwi9;xu-{a5-rUe{pz;wT36`1C6$_LYRPGw;FyHhflj&;ri b(#27Zx&-d z!vtnLWjzgHZ02BM28-HGgeH55(unz&#*P(n9hfpxT$Dt8S3pmz*>3+v5FwNtX52ov!%E0t@r(`f4 g>zoOuPdZnEX;&ABy6rAWARkPYaZLq_x40Gp0Qp>ossI20 diff --git a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/fe/portlet/FascicoloFePortlet.java b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/fe/portlet/FascicoloFePortlet.java index cd254514..b6397b9a 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/fe/portlet/FascicoloFePortlet.java +++ b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/WEB-INF/src/it/tref/liferay/portos/fe/portlet/FascicoloFePortlet.java @@ -722,8 +722,47 @@ public class FascicoloFePortlet extends MVCPortlet { } } + public void salvaFirstStepFineLavori(ActionRequest request, ActionResponse response) throws Exception { + long fineLavoriId = ParamUtil.getLong(request, "fineLavoriId"); + boolean parziale = ParamUtil.getBoolean(request, "tipoFineLavori"); + Date dataFineLavori = ParamUtil.getDate(request, "dataFineLavori", + DateFormatFactoryUtil.getDate(request.getLocale()), null); + long userId = PortalUtil.getUserId(request); + + try { + FineLavori fineLavori = FineLavoriServiceUtil.getFineLavori(fineLavoriId); + if (!fineLavori.isCompletata() && Validator.isNotNull(dataFineLavori)) { + fineLavori.setParziale(parziale); + fineLavori.setDataFineLavori(dataFineLavori); + FineLavoriServiceUtil.updateFineLavori(fineLavori); + } + String redirect = ParamUtil.getString(request, "redirect"); + if (Validator.isNull(redirect)) { + String successURL = ParamUtil.getString(request, "successURL"); + if (Validator.isNotNull(successURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "fineLavoriId"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "fineLavoriId", + String.valueOf(fineLavoriId)); + response.sendRedirect(successURL); + } + } + } catch (PortalException e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fine-lavori.jsp"); + response.setRenderParameter("fineLavoriId", String.valueOf(fineLavoriId)); + throw e; + } catch (Exception e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fine-lavori.jsp"); + response.setRenderParameter("fineLavoriId", String.valueOf(fineLavoriId)); + throw e; + } + } + public void salvaInizioLavori(ActionRequest request, ActionResponse response) throws IOException, PortalException, - SystemException { + SystemException { long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); Date dataInizioLavoriOpera = ParamUtil.getDate(request, "dataInizioLavoriOpera", @@ -776,9 +815,6 @@ public class FascicoloFePortlet extends MVCPortlet { long fineLavoriId = ParamUtil.getLong(request, "fineLavoriId"); boolean bozza = ParamUtil.getBoolean(request, "bozza"); - boolean parziale = ParamUtil.getBoolean(request, "tipoFineLavori"); - Date dataFineLavori = ParamUtil.getDate(request, "dataFineLavori", - DateFormatFactoryUtil.getDate(request.getLocale()), null); String codiceFiscaleDelegato = ParamUtil.getString(request, "direttoreLavori"); boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); boolean normEsenteSpese = ParamUtil.getBoolean(request, "normEsenteSpese"); @@ -790,6 +826,9 @@ public class FascicoloFePortlet extends MVCPortlet { long userId = PortalUtil.getUserId(request); try { FineLavori fineLavori = FineLavoriServiceUtil.getFineLavori(fineLavoriId); + boolean parziale = ParamUtil.getBoolean(request, "tipoFineLavori", fineLavori.getParziale()); + Date dataFineLavori = ParamUtil.getDate(request, "dataFineLavori", + DateFormatFactoryUtil.getDate(request.getLocale()), fineLavori.getDataFineLavori()); if (!fineLavori.isCompletata()) { FineLavoriServiceUtil.updateFineLavori(userId, fineLavori.getFineLavoriId(), fineLavori.getIntPraticaId(), parziale, false, dataFineLavori, codiceFiscaleDelegato, @@ -978,346 +1017,346 @@ public class FascicoloFePortlet extends MVCPortlet { "codiceFiscaleDelegatoFineLavoriEnabled"); String codiceFiscaleDelegatoFineLavori = isCodiceFiscaleDelegatoFineLavoriAuthorized ? ParamUtil.getString( request, "codiceFiscaleDelegatoFineLavori") : StringPool.BLANK; - boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, - "codiceFiscaleDelegatoCollaudoEnabled"); - String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, - "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; - String codiceRuoloDelegato = ParamUtil.getString(request, "codiceRuoloDelegato"); - boolean inizioLavoriContestualeOpera = ParamUtil.getBoolean(request, "inizioLavoriContestualeOpera"); - long pagamentoId = ParamUtil.getLong(request, "pagamentoId"); - Date dataEffettuazione = ParamUtil.getDate(request, "dataEffettuazione", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataInizioLavoriOpera = ParamUtil.getDate(request, "dataInizioLavoriOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataInizioEsecuzioneOpera = ParamUtil.getDate(request, "dataInizioEsecuzioneOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataFineEsecuzioneOpera = ParamUtil.getDate(request, "dataFineEsecuzioneOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - String note = ParamUtil.getString(request, "note"); - String noteUfficio = ParamUtil.getString(request, "noteUfficio"); - // PAGAMENTI - String codicePagamento = ParamUtil.getString(request, "codicePagamento"); - String causalePagamento = ParamUtil.getString(request, "causalePagamento"); - String mezzoPagamento = ParamUtil.getString(request, "mezzoPagamento"); - String importoBolli = ParamUtil.getString(request, "importoBolli"); - String importoSpeseIstruttoria = ParamUtil.getString(request, "importoSpeseIstruttoria"); - boolean pagNuoveCostruzioni = ParamUtil.getBoolean(request, "pagNuoveCostruzioni"); - int pagAdeguamentoSismico = ParamUtil.getInteger(request, "pagAdeguamentoSismico"); - int pagMiglioramentoSismico = ParamUtil.getInteger(request, "pagMiglioramentoSismico"); - boolean pagRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "pagRiparazioneInterventoLocale"); - int pagNuovaCostruzione = ParamUtil.getInteger(request, "pagNuovaCostruzione"); - boolean pagVarianti = ParamUtil.getBoolean(request, "pagVarianti"); - int pagAltro = ParamUtil.getInteger(request, "pagAltro"); - boolean pagMiglioramentoSismicoSicilia = ParamUtil.getBoolean(request, "pagMiglioramentoSismicoSicilia"); - String pagCalcolatoAdeguamentoSismico = ParamUtil.getString(request, "pagCalcolatoAdeguamentoSismico"); - String pagCalcolatoMiglioramentoSismico = ParamUtil.getString(request, "pagCalcolatoMiglioramentoSismico"); - String pagCalcolatoRiparazioneInterventoLocale = ParamUtil.getString(request, - "pagCalcolatoRiparazioneInterventoLocale"); - String pagCalcolatoOperaNonQuantificabile = ParamUtil.getString(request, "pagCalcolatoOperaNonQuantificabile"); - String pagEffettivoAdeguamentoSismico = ParamUtil.getString(request, "pagEffettivoAdeguamentoSismico"); - String pagEffettivoMiglioramentoSismico = ParamUtil.getString(request, "pagEffettivoMiglioramentoSismico"); - String pagEffettivoRiparazioneInterventoLocale = ParamUtil.getString(request, - "pagEffettivoRiparazioneInterventoLocale"); - String pagEffettivoOperaNonQuantificabile = ParamUtil.getString(request, "pagEffettivoOperaNonQuantificabile"); - String pagNoteUtente = ParamUtil.getString(request, "pagNoteUtente"); - // SEZIONE DETTAGLI PRINCIPALI - boolean collaudoStatico = ParamUtil.getBoolean(request, "collaudoStatico"); - boolean lavoriInEconomiaCommittente = ParamUtil.getBoolean(request, "lavoriInEconomiaCommittente"); - String destinazione = ParamUtil.getString(request, "destinazione"); - String ag = ParamUtil.getString(request, "ag"); - String descLongIntervento = ParamUtil.getString(request, "descLongIntervento"); - String via = ParamUtil.getString(request, "via"); - String localita = ParamUtil.getString(request, "localita"); - String estremiCatastali = ParamUtil.getString(request, "estremiCatastali"); - String estremiPratCom = ParamUtil.getString(request, "estremiPratCom"); - String metratura = ParamUtil.getString(request, "metratura"); - boolean lavoriPubblici = ParamUtil.getBoolean(request, "lavoriPubblici"); - int lavoriPubbliciPercentuale = ParamUtil.getInteger(request, "lavoriPubbliciPercentuale"); - String numeroCivico = ParamUtil.getString(request, "numeroCivico"); - String dcFoglio = ParamUtil.getString(request, "dcFoglio"); - String dcAllegato = ParamUtil.getString(request, "dcAllegato"); - String particella1 = ParamUtil.getString(request, "particella1", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella2 = ParamUtil.getString(request, "particella2", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella3 = ParamUtil.getString(request, "particella3", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella4 = ParamUtil.getString(request, "particella4", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String dcParticelle = particella1 + StringPool.PIPE + particella2 + StringPool.PIPE + particella3 - + StringPool.PIPE + particella4; - String localizzazioneGeografica = ParamUtil.getString(request, "localizzazioneGeografica"); - boolean tcNuovaCostruzione = ParamUtil.getBoolean(request, "tcNuovaCostruzione"); - boolean tcAdeguamentoSismico = ParamUtil.getBoolean(request, "tcAdeguamentoSismico"); - boolean tcMiglioramentoSismico = ParamUtil.getBoolean(request, "tcMiglioramentoSismico"); - boolean tcRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "tcRiparazioneInterventoLocale"); - boolean tcNuovaCostruzioneComplessa = ParamUtil.getBoolean(request, "tcNuovaCostruzioneComplessa"); - boolean tcInCA = ParamUtil.getBoolean(request, "tcInCA"); - boolean tcInOpera = ParamUtil.getBoolean(request, "tcInOpera"); - boolean tcPrefabbricato = ParamUtil.getBoolean(request, "tcPrefabbricato"); - boolean tcInAcciaio = ParamUtil.getBoolean(request, "tcInAcciaio"); - boolean tcMista = ParamUtil.getBoolean(request, "tcMista"); - boolean tcInMuratura = ParamUtil.getBoolean(request, "tcInMuratura"); - boolean tcInMuraturaOrdinaria = ParamUtil.getBoolean(request, "tcInMuraturaOrdinaria"); - boolean tcInMuraturaArmata = ParamUtil.getBoolean(request, "tcInMuraturaArmata"); - boolean tcInMuraturaMista = ParamUtil.getBoolean(request, "tcInMuraturaMista"); - boolean tcInLegno = ParamUtil.getBoolean(request, "tcInLegno"); - boolean tcAltro = ParamUtil.getBoolean(request, "tcAltro"); - String tcAltroDescrizione = ParamUtil.getString(request, "tcAltroDescrizione"); - boolean tcConDispositivi = ParamUtil.getBoolean(request, "tcConDispositivi"); - // Descrizione edificio - String dePiani = ParamUtil.getString(request, "dePiani"); - String deAltezza = ParamUtil.getString(request, "deAltezza"); - String deInterrati = ParamUtil.getString(request, "deInterrati"); - String deSuperficie = ParamUtil.getString(request, "deSuperficie"); - String deCostruzione = ParamUtil.getString(request, "deCostruzione"); - String deRistrutturazione = ParamUtil.getString(request, "deRistrutturazione"); - String deUso = ParamUtil.getString(request, "deUso"); - String dePrivata = ParamUtil.getString(request, "dePrivata"); - String dePubblica = ParamUtil.getString(request, "dePubblica"); - String deUtilizzazione = ParamUtil.getString(request, "deUtilizzazione"); - String dePosizioneEdificio = ParamUtil.getString(request, "dePosizioneEdificio"); - boolean deInfStradalePonte = ParamUtil.getBoolean(request, "deInfStradalePonte"); - boolean deInfStradaleStrada = ParamUtil.getBoolean(request, "deInfStradaleStrada"); - boolean deInfStradaleAltro = ParamUtil.getBoolean(request, "deInfStradaleAltro"); - boolean deInfIdraulicaLong = ParamUtil.getBoolean(request, "deInfIdraulicaLong"); - boolean deInfIdraulicaTrasv = ParamUtil.getBoolean(request, "deInfIdraulicaTrasv"); - boolean deInfIdraulicaAltro = ParamUtil.getBoolean(request, "deInfIdraulicaAltro"); - boolean deInfOperaAccStradale = ParamUtil.getBoolean(request, "deInfOperaAccStradale"); - boolean deInfOperaAccIdraulica = ParamUtil.getBoolean(request, "deInfOperaAccIdraulica"); - boolean deInfOperaAccAltro = ParamUtil.getBoolean(request, "deInfOperaAccAltro"); - boolean deInfAltraInfrastruttura = ParamUtil.getBoolean(request, "deInfAltraInfrastruttura"); - boolean deInfAltro = ParamUtil.getBoolean(request, "deInfAltro"); - String deInfAltroDesc = ParamUtil.getString(request, "deInfAltroDesc"); - String dccFondazioni = ParamUtil.getString(request, "dccFondazioni"); - boolean dccStruttureEleMuraturePietrame = ParamUtil.getBoolean(request, "dccStruttureEleMuraturePietrame"); - boolean dccStruttureEleMuratureLaterizio = ParamUtil.getBoolean(request, "dccStruttureEleMuratureLaterizio"); - boolean dccStruttureEleMuratureMisto = ParamUtil.getBoolean(request, "dccStruttureEleMuratureMisto"); - boolean dccStruttureEleMuratureStoriche = ParamUtil.getBoolean(request, "dccStruttureEleMuratureStoriche"); - String dccStruttureEleAcciaio = ParamUtil.getString(request, "dccStruttureEleAcciaio"); - String dccStruttureEleCA = ParamUtil.getString(request, "dccStruttureEleCA"); - String dccStruttureEleLegno = ParamUtil.getString(request, "dccStruttureEleLegno"); - boolean dccStruttureEleMistoCA = ParamUtil.getBoolean(request, "dccStruttureEleMistoCA"); - boolean dccStruttureEleMistoAcciaio = ParamUtil.getBoolean(request, "dccStruttureEleMistoAcciaio"); - boolean dccStruttureEleMistoMuratura = ParamUtil.getBoolean(request, "dccStruttureEleMistoMuratura"); - boolean dccStruttureEleMistoLegno = ParamUtil.getBoolean(request, "dccStruttureEleMistoLegno"); - boolean dccStruttureElePrefabbricato = ParamUtil.getBoolean(request, "dccStruttureElePrefabbricato"); - boolean dccStruttureEleAltro = ParamUtil.getBoolean(request, "dccStruttureEleAltro"); - String dccStruttureEleAltroDescrizione = ParamUtil.getString(request, "dccStruttureEleAltroDescrizione"); - boolean dccOrizzontamentiCAAcciaio = ParamUtil.getBoolean(request, "dccOrizzontamentiCAAcciaio"); - boolean dccOrizzontamentiLegno = ParamUtil.getBoolean(request, "dccOrizzontamentiLegno"); - boolean dccOrizzontamentiLegnoCA = ParamUtil.getBoolean(request, "dccOrizzontamentiLegnoCA"); - boolean dccOrizzontamentiLamieraGrecata = ParamUtil.getBoolean(request, "dccOrizzontamentiLamieraGrecata"); - boolean dccOrizzontamentiVolte = ParamUtil.getBoolean(request, "dccOrizzontamentiVolte"); - boolean dccOrizzontamentiAltro = ParamUtil.getBoolean(request, "dccOrizzontamentiAltro"); - String dccOrizzontamentiAltroDescrizione = ParamUtil.getString(request, "dccOrizzontamentiAltroDescrizione"); - String dccCopertura = ParamUtil.getString(request, "dccCopertura"); - boolean dccCoperturaCAAcciaio = ParamUtil.getBoolean(request, "dccCoperturaCAAcciaio"); - boolean dccCoperturaLegno = ParamUtil.getBoolean(request, "dccCoperturaLegno"); - boolean dccCoperturaLegnoCA = ParamUtil.getBoolean(request, "dccCoperturaLegnoCA"); - boolean dccCoperturaLamieraGrecata = ParamUtil.getBoolean(request, "dccCoperturaLamieraGrecata"); - boolean dccCoperturaPannelli = ParamUtil.getBoolean(request, "dccCoperturaPannelli"); - boolean dccCoperturaPVCTelonati = ParamUtil.getBoolean(request, "dccCoperturaPVCTelonati"); - boolean dccCoperturaLeggere = ParamUtil.getBoolean(request, "dccCoperturaLeggere"); - boolean dccCoperturaAltro = ParamUtil.getBoolean(request, "dccCoperturaAltro"); - String dccCoperturaAltroDesrizione = ParamUtil.getString(request, "dccCoperturaAltroDesrizione"); - boolean dccElemNonStrutLaterizio = ParamUtil.getBoolean(request, "dccElemNonStrutLaterizio"); - boolean dccElemNonStrutCartongesso = ParamUtil.getBoolean(request, "dccElemNonStrutCartongesso"); - boolean dccElemNonStrutCalcestruzzo = ParamUtil.getBoolean(request, "dccElemNonStrutCalcestruzzo"); - boolean dccElemNonStrutLegno = ParamUtil.getBoolean(request, "dccElemNonStrutLegno"); - boolean dccElemNonStrutAltro = ParamUtil.getBoolean(request, "dccElemNonStrutAltro"); - String dccElemNonStrutAltroDescrizione = ParamUtil.getString(request, "dccElemNonStrutAltroDescrizione"); - boolean dccOpereDiRinforzoInsCatene = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCatene"); - boolean dccOpereDiRinforzoInsCordoli = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCordoli"); - boolean dccOpereDiRinforzoIniArmate = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIniArmate"); - boolean dccOpereDiRinforzoPlaccaggi = ParamUtil.getBoolean(request, "dccOpereDiRinforzoPlaccaggi"); - boolean dccOpereDiRinforzoIrrSolai = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIrrSolai"); - boolean dccOpereDiRinforzoRinforziFRP = ParamUtil.getBoolean(request, "dccOpereDiRinforzoRinforziFRP"); - boolean dccOpereDiRinforzoTelaiECerchiature = ParamUtil.getBoolean(request, - "dccOpereDiRinforzoTelaiECerchiature"); - boolean dccOpereDiRinforzoInsRompitratta = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsRompitratta"); - boolean dccOpereDiRinforzoAltro = ParamUtil.getBoolean(request, "dccOpereDiRinforzoAltro"); - String dccOpereDiRinforzoAltroDescrizione = ParamUtil.getString(request, "dccOpereDiRinforzoAltroDescrizione"); - // DATI geologici - String geoClasseIndagine = getNotNullString(request, "geoClasseIndagine", dettPratica.getGeoClasseIndagine()); - String geoCategoriaSottosuolo = getNotNullString(request, "geoCategoriaSottosuolo", - dettPratica.getGeoCategoriaSottosuolo()); - String geoCategoriaTopografica = getNotNullString(request, "geoCategoriaTopografica", - dettPratica.getGeoCategoriaTopografica()); - String geoConsolidamento = getNotNullString(request, "geoConsolidamento", dettPratica.getGeoConsolidamento()); - String geoPericolositaGeologica = getNotNullString(request, "geoPericolositaGeologica", - dettPratica.getGeoPericolositaGeologica()); - String geoRischioGeomorfologicoPai = getNotNullString(request, "geoRischioGeomorfologicoPai", - dettPratica.getGeoRischioGeomorfologicoPai()); - String geoPericolositaIdraulicaPai = getNotNullString(request, "geoPericolositaIdraulicaPai", - dettPratica.getGeoPericolositaIdraulicaPai()); - String geoRischioIdraulicoPai = getNotNullString(request, "geoRischioIdraulicoPai", - dettPratica.getGeoRischioIdraulicoPai()); - String geoPericolositaSismica = getNotNullString(request, "geoPericolositaSismica", - dettPratica.getGeoPericolositaSismica()); - String geoPericolositaIdraulica = getNotNullString(request, "geoPericolositaIdraulica", - dettPratica.getGeoPericolositaIdraulica()); - String geoPericolositaGeomorfica = getNotNullString(request, "geoPericolositaGeomorfica", - dettPratica.getGeoPericolositaGeomorfica()); - String geoFattibilitaGeologica = getNotNullString(request, "geoFattibilitaGeologica", - dettPratica.getGeoFattibilitaGeologica()); - String geoFattibilitaSismica = getNotNullString(request, "geoFattibilitaSismica", - dettPratica.getGeoFattibilitaSismica()); - String geoFattibilitaIdraulica = getNotNullString(request, "geoFattibilitaIdraulica", - dettPratica.getGeoFattibilitaIdraulica()); - String geoOperaRilevante = getNotNullString(request, "geoOperaRilevante", dettPratica.getGeoOperaRilevante()); - String geoOpereDiSostegno = getNotNullString(request, "geoOpereDiSostegno", dettPratica.getGeoOpereDiSostegno()); - String geoOpereInSotterranea = getNotNullString(request, "geoOpereInSotterranea", - dettPratica.getGeoOpereInSotterranea()); - String geoPresenzaPrescrizioni = getNotNullString(request, "geoPresenzaPrescrizioni", - dettPratica.getGeoPresenzaPrescrizioni()); - String geoNotePrescrizioni = getNotNullString(request, "geoNotePrescrizioni", - dettPratica.getGeoNotePrescrizioni()); - String geoNoteIndagini = getNotNullString(request, "geoNoteIndagini", dettPratica.getGeoNoteIndagini()); - String geoEvidenzeGeomorfiche = getNotNullString(request, "geoEvidenzeGeomorfiche", - dettPratica.getGeoEvidenzeGeomorfiche()); - String geoEvidenzeGeologiche = getNotNullString(request, "geoEvidenzeGeologiche", - dettPratica.getGeoEvidenzeGeologiche()); - Date geoDtRelazione = getNotNullDate(request, "geoDtRelazione", dettPratica.getGeoDtRelazione()); - // normative - boolean normLavoriInProprio = ParamUtil.getBoolean(request, "normLavoriInProprio"); - boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); - boolean normEsenteSpese = ParamUtil.getBoolean(request, "normEsenteSpese"); - boolean normDpr01Dep = ParamUtil.getBoolean(request, "normDpr01Dep"); - boolean normDpr02Dep = ParamUtil.getBoolean(request, "normDpr02Dep"); - boolean normDpr01Aut = ParamUtil.getBoolean(request, "normDpr01Aut"); - boolean normDpr02Aut = ParamUtil.getBoolean(request, "normDpr02Aut"); - boolean normDm01 = ParamUtil.getBoolean(request, "normDm01"); - boolean normDm02 = ParamUtil.getBoolean(request, "normDm02"); - boolean normDm03 = ParamUtil.getBoolean(request, "normDm03"); - boolean normDm2018 = ParamUtil.getBoolean(request, "normDm2018"); - boolean normDprg01 = ParamUtil.getBoolean(request, "normDprg01"); - boolean normDprg02 = ParamUtil.getBoolean(request, "normDprg02"); - boolean normAnr = ParamUtil.getBoolean(request, "normAnr"); - boolean normArt3com3 = ParamUtil.getBoolean(request, "normArt3com3"); - boolean normArt3com4 = ParamUtil.getBoolean(request, "normArt3com4"); - boolean normOrd01 = ParamUtil.getBoolean(request, "normOrd01"); - boolean normDm04 = ParamUtil.getBoolean(request, "normDm04"); - boolean normDm05 = ParamUtil.getBoolean(request, "normDm05"); - boolean normCI01 = ParamUtil.getBoolean(request, "normCI01"); - boolean normLTC01 = ParamUtil.getBoolean(request, "normLTC01"); - boolean suap = ParamUtil.getBoolean(request, "suap"); - boolean normSismaBonus = ParamUtil.getBoolean(request, "normSismaBonus"); - String clRischioPreInt = ParamUtil.getString(request, "clRischioPreInt"); - String clRischioPostInt = ParamUtil.getString(request, "clRischioPostInt"); - boolean intervFinPub = ParamUtil.getBoolean(request, "intervFinPub"); - String intervFinPubDesc = ParamUtil.getString(request, "intervFinPubDesc"); - String contestoPaesaggistico = ParamUtil.getString(request, "contestoPaesaggistico"); - String livelloDiTutela = ParamUtil.getString(request, "livelloDiTutela"); - String vincoli = ParamUtil.getString(request, "vincoli"); - - long userId = PortalUtil.getUserId(request); - - IntPratica intPratica = IntPraticaLocalServiceUtil.getIntPratica(dettPratica.getIntPraticaId()); - if(intPratica.isPraticaOspedaliera()){ - destinazione = dettPratica.getDestinazione(); - normEsenteBollo = dettPratica.getNormEsenteBollo(); - normEsenteSpese = dettPratica.getNormEsenteSpese(); - lavoriPubblici = dettPratica.getLavoriPubblici(); - } - try { - DettPraticaServiceUtil.updateDettPratica(userId, dettPratica.getDettPraticaId(), - dettPratica.getIntPraticaId(), integrazione, protocollo, tipoIntegrazione, completa, gestita, - codicePagamento, causalePagamento, mezzoPagamento, importoBolli, importoSpeseIstruttoria, - dataEffettuazione, statusTask, workflowForzato, soggettoSostituitoId, destinazione, ag, - descLongIntervento, via, localita, estremiCatastali, estremiPratCom, variataDa, varianteNumero, - varianteSostanziale, operaConforme, collaudoStatico, codiceFiscaleDelegatoCommittente, - codiceFiscaleDelegatoFineLavori, codiceFiscaleDelegatoCollaudo, codiceRuoloDelegato, - lavoriInEconomiaCommittente, inizioLavoriContestualeOpera, dataInizioLavoriOpera, - dataInizioEsecuzioneOpera, dataFineEsecuzioneOpera, metratura, lavoriPubblici, pagamentoId, - lavoriPubbliciPercentuale, numeroCivico, dcParticelle, dcFoglio, dcAllegato, dePiani, deAltezza, - deInterrati, deSuperficie, deCostruzione, deRistrutturazione, deUso, dePubblica, dePrivata, - deUtilizzazione, dePosizioneEdificio, deInfStradalePonte, deInfStradaleStrada, deInfStradaleAltro, - deInfIdraulicaLong, deInfIdraulicaTrasv, deInfIdraulicaAltro, deInfOperaAccStradale, - deInfOperaAccIdraulica, deInfOperaAccAltro, deInfAltraInfrastruttura, deInfAltro, deInfAltroDesc, - dccFondazioni, dccStruttureEleMuraturePietrame, dccStruttureEleMuratureLaterizio, - dccStruttureEleMuratureMisto, dccStruttureEleMuratureStoriche, dccStruttureEleAcciaio, - dccStruttureEleCA, dccStruttureEleLegno, dccStruttureEleMistoCA, dccStruttureEleMistoAcciaio, - dccStruttureEleMistoMuratura, dccStruttureEleMistoLegno, dccStruttureElePrefabbricato, - dccStruttureEleAltro, dccStruttureEleAltroDescrizione, dccOrizzontamentiCAAcciaio, - dccOrizzontamentiLegno, dccOrizzontamentiLegnoCA, dccOrizzontamentiLamieraGrecata, - dccOrizzontamentiVolte, dccOrizzontamentiAltro, dccOrizzontamentiAltroDescrizione, dccCopertura, - dccCoperturaCAAcciaio, dccCoperturaLegno, dccCoperturaLegnoCA, dccCoperturaLamieraGrecata, - dccCoperturaPannelli, dccCoperturaPVCTelonati, dccCoperturaLeggere, dccCoperturaAltro, - dccCoperturaAltroDesrizione, dccElemNonStrutLaterizio, dccElemNonStrutCartongesso, - dccElemNonStrutCalcestruzzo, dccElemNonStrutLegno, dccElemNonStrutAltro, - dccElemNonStrutAltroDescrizione, dccOpereDiRinforzoInsCatene, dccOpereDiRinforzoInsCordoli, - dccOpereDiRinforzoIniArmate, dccOpereDiRinforzoPlaccaggi, dccOpereDiRinforzoIrrSolai, - dccOpereDiRinforzoRinforziFRP, dccOpereDiRinforzoTelaiECerchiature, - dccOpereDiRinforzoInsRompitratta, dccOpereDiRinforzoAltro, dccOpereDiRinforzoAltroDescrizione, - geoClasseIndagine, geoCategoriaSottosuolo, geoCategoriaTopografica, geoConsolidamento, - geoPericolositaGeologica, geoRischioGeomorfologicoPai, geoPericolositaIdraulicaPai, - geoRischioIdraulicoPai, geoPericolositaSismica, geoPericolositaIdraulica, - geoPericolositaGeomorfica, geoFattibilitaGeologica, geoFattibilitaSismica, geoFattibilitaIdraulica, - geoOperaRilevante, geoOpereDiSostegno, geoOpereInSotterranea, geoPresenzaPrescrizioni, - geoNotePrescrizioni, geoNoteIndagini, geoEvidenzeGeomorfiche, geoEvidenzeGeologiche, - geoDtRelazione, pagNuoveCostruzioni, pagAdeguamentoSismico, pagMiglioramentoSismico, - pagRiparazioneInterventoLocale, pagNuovaCostruzione, pagVarianti, pagAltro, - pagMiglioramentoSismicoSicilia, pagCalcolatoAdeguamentoSismico, pagCalcolatoMiglioramentoSismico, - pagCalcolatoRiparazioneInterventoLocale, pagCalcolatoOperaNonQuantificabile, - pagEffettivoAdeguamentoSismico, pagEffettivoMiglioramentoSismico, - pagEffettivoRiparazioneInterventoLocale, pagEffettivoOperaNonQuantificabile, pagNoteUtente, note, - noteUfficio, localizzazioneGeografica, tcNuovaCostruzione, tcAdeguamentoSismico, - tcMiglioramentoSismico, tcRiparazioneInterventoLocale, tcInCA, tcInOpera, tcPrefabbricato, - tcInAcciaio, tcMista, tcInMuratura, tcInMuraturaOrdinaria, tcInMuraturaArmata, tcInMuraturaMista, - tcInLegno, tcAltro, tcAltroDescrizione, tcConDispositivi, normLavoriInProprio, normEsenteBollo, - normEsenteSpese, normDpr01Dep, normDpr02Dep, normDpr01Aut, normDpr02Aut, normDm01, normDm02, - normDm03, normDm2018, normDprg01, normDprg02, normAnr, normArt3com3, normArt3com4, normOrd01, - normDm04, normDm05, normCI01, normLTC01, suap, normSismaBonus, clRischioPreInt, clRischioPostInt, - intervFinPub, intervFinPubDesc, tcNuovaCostruzioneComplessa, contestoPaesaggistico, - livelloDiTutela, vincoli, serviceContext, bozza, disabledSubmit, geoDisabledSubmit); - String redirect = ParamUtil.getString(request, "redirect"); - if (Validator.isNull(redirect)) { - String successURL = ParamUtil.getString(request, "successURL"); - if (Validator.isNotNull(successURL)) { - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", - String.valueOf(!bozza)); - String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", - String.valueOf(verifyArea)); - String fragmentURL = ParamUtil.getString(request, "current_tab"); - if (Validator.isNotNull(fragmentURL)) { - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "current_tab"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "current_tab", - fragmentURL); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "historyKey"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "historyKey", - "_1_WAR_portosfeportlet_tab=" + fragmentURL); - if (successURL.contains(StringPool.POUND)) { - successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, + "codiceFiscaleDelegatoCollaudoEnabled"); + String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, + "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; + String codiceRuoloDelegato = ParamUtil.getString(request, "codiceRuoloDelegato"); + boolean inizioLavoriContestualeOpera = ParamUtil.getBoolean(request, "inizioLavoriContestualeOpera"); + long pagamentoId = ParamUtil.getLong(request, "pagamentoId"); + Date dataEffettuazione = ParamUtil.getDate(request, "dataEffettuazione", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataInizioLavoriOpera = ParamUtil.getDate(request, "dataInizioLavoriOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataInizioEsecuzioneOpera = ParamUtil.getDate(request, "dataInizioEsecuzioneOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataFineEsecuzioneOpera = ParamUtil.getDate(request, "dataFineEsecuzioneOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + String note = ParamUtil.getString(request, "note"); + String noteUfficio = ParamUtil.getString(request, "noteUfficio"); + // PAGAMENTI + String codicePagamento = ParamUtil.getString(request, "codicePagamento"); + String causalePagamento = ParamUtil.getString(request, "causalePagamento"); + String mezzoPagamento = ParamUtil.getString(request, "mezzoPagamento"); + String importoBolli = ParamUtil.getString(request, "importoBolli"); + String importoSpeseIstruttoria = ParamUtil.getString(request, "importoSpeseIstruttoria"); + boolean pagNuoveCostruzioni = ParamUtil.getBoolean(request, "pagNuoveCostruzioni"); + int pagAdeguamentoSismico = ParamUtil.getInteger(request, "pagAdeguamentoSismico"); + int pagMiglioramentoSismico = ParamUtil.getInteger(request, "pagMiglioramentoSismico"); + boolean pagRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "pagRiparazioneInterventoLocale"); + int pagNuovaCostruzione = ParamUtil.getInteger(request, "pagNuovaCostruzione"); + boolean pagVarianti = ParamUtil.getBoolean(request, "pagVarianti"); + int pagAltro = ParamUtil.getInteger(request, "pagAltro"); + boolean pagMiglioramentoSismicoSicilia = ParamUtil.getBoolean(request, "pagMiglioramentoSismicoSicilia"); + String pagCalcolatoAdeguamentoSismico = ParamUtil.getString(request, "pagCalcolatoAdeguamentoSismico"); + String pagCalcolatoMiglioramentoSismico = ParamUtil.getString(request, "pagCalcolatoMiglioramentoSismico"); + String pagCalcolatoRiparazioneInterventoLocale = ParamUtil.getString(request, + "pagCalcolatoRiparazioneInterventoLocale"); + String pagCalcolatoOperaNonQuantificabile = ParamUtil.getString(request, "pagCalcolatoOperaNonQuantificabile"); + String pagEffettivoAdeguamentoSismico = ParamUtil.getString(request, "pagEffettivoAdeguamentoSismico"); + String pagEffettivoMiglioramentoSismico = ParamUtil.getString(request, "pagEffettivoMiglioramentoSismico"); + String pagEffettivoRiparazioneInterventoLocale = ParamUtil.getString(request, + "pagEffettivoRiparazioneInterventoLocale"); + String pagEffettivoOperaNonQuantificabile = ParamUtil.getString(request, "pagEffettivoOperaNonQuantificabile"); + String pagNoteUtente = ParamUtil.getString(request, "pagNoteUtente"); + // SEZIONE DETTAGLI PRINCIPALI + boolean collaudoStatico = ParamUtil.getBoolean(request, "collaudoStatico"); + boolean lavoriInEconomiaCommittente = ParamUtil.getBoolean(request, "lavoriInEconomiaCommittente"); + String destinazione = ParamUtil.getString(request, "destinazione"); + String ag = ParamUtil.getString(request, "ag"); + String descLongIntervento = ParamUtil.getString(request, "descLongIntervento"); + String via = ParamUtil.getString(request, "via"); + String localita = ParamUtil.getString(request, "localita"); + String estremiCatastali = ParamUtil.getString(request, "estremiCatastali"); + String estremiPratCom = ParamUtil.getString(request, "estremiPratCom"); + String metratura = ParamUtil.getString(request, "metratura"); + boolean lavoriPubblici = ParamUtil.getBoolean(request, "lavoriPubblici"); + int lavoriPubbliciPercentuale = ParamUtil.getInteger(request, "lavoriPubbliciPercentuale"); + String numeroCivico = ParamUtil.getString(request, "numeroCivico"); + String dcFoglio = ParamUtil.getString(request, "dcFoglio"); + String dcAllegato = ParamUtil.getString(request, "dcAllegato"); + String particella1 = ParamUtil.getString(request, "particella1", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella2 = ParamUtil.getString(request, "particella2", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella3 = ParamUtil.getString(request, "particella3", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella4 = ParamUtil.getString(request, "particella4", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String dcParticelle = particella1 + StringPool.PIPE + particella2 + StringPool.PIPE + particella3 + + StringPool.PIPE + particella4; + String localizzazioneGeografica = ParamUtil.getString(request, "localizzazioneGeografica"); + boolean tcNuovaCostruzione = ParamUtil.getBoolean(request, "tcNuovaCostruzione"); + boolean tcAdeguamentoSismico = ParamUtil.getBoolean(request, "tcAdeguamentoSismico"); + boolean tcMiglioramentoSismico = ParamUtil.getBoolean(request, "tcMiglioramentoSismico"); + boolean tcRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "tcRiparazioneInterventoLocale"); + boolean tcNuovaCostruzioneComplessa = ParamUtil.getBoolean(request, "tcNuovaCostruzioneComplessa"); + boolean tcInCA = ParamUtil.getBoolean(request, "tcInCA"); + boolean tcInOpera = ParamUtil.getBoolean(request, "tcInOpera"); + boolean tcPrefabbricato = ParamUtil.getBoolean(request, "tcPrefabbricato"); + boolean tcInAcciaio = ParamUtil.getBoolean(request, "tcInAcciaio"); + boolean tcMista = ParamUtil.getBoolean(request, "tcMista"); + boolean tcInMuratura = ParamUtil.getBoolean(request, "tcInMuratura"); + boolean tcInMuraturaOrdinaria = ParamUtil.getBoolean(request, "tcInMuraturaOrdinaria"); + boolean tcInMuraturaArmata = ParamUtil.getBoolean(request, "tcInMuraturaArmata"); + boolean tcInMuraturaMista = ParamUtil.getBoolean(request, "tcInMuraturaMista"); + boolean tcInLegno = ParamUtil.getBoolean(request, "tcInLegno"); + boolean tcAltro = ParamUtil.getBoolean(request, "tcAltro"); + String tcAltroDescrizione = ParamUtil.getString(request, "tcAltroDescrizione"); + boolean tcConDispositivi = ParamUtil.getBoolean(request, "tcConDispositivi"); + // Descrizione edificio + String dePiani = ParamUtil.getString(request, "dePiani"); + String deAltezza = ParamUtil.getString(request, "deAltezza"); + String deInterrati = ParamUtil.getString(request, "deInterrati"); + String deSuperficie = ParamUtil.getString(request, "deSuperficie"); + String deCostruzione = ParamUtil.getString(request, "deCostruzione"); + String deRistrutturazione = ParamUtil.getString(request, "deRistrutturazione"); + String deUso = ParamUtil.getString(request, "deUso"); + String dePrivata = ParamUtil.getString(request, "dePrivata"); + String dePubblica = ParamUtil.getString(request, "dePubblica"); + String deUtilizzazione = ParamUtil.getString(request, "deUtilizzazione"); + String dePosizioneEdificio = ParamUtil.getString(request, "dePosizioneEdificio"); + boolean deInfStradalePonte = ParamUtil.getBoolean(request, "deInfStradalePonte"); + boolean deInfStradaleStrada = ParamUtil.getBoolean(request, "deInfStradaleStrada"); + boolean deInfStradaleAltro = ParamUtil.getBoolean(request, "deInfStradaleAltro"); + boolean deInfIdraulicaLong = ParamUtil.getBoolean(request, "deInfIdraulicaLong"); + boolean deInfIdraulicaTrasv = ParamUtil.getBoolean(request, "deInfIdraulicaTrasv"); + boolean deInfIdraulicaAltro = ParamUtil.getBoolean(request, "deInfIdraulicaAltro"); + boolean deInfOperaAccStradale = ParamUtil.getBoolean(request, "deInfOperaAccStradale"); + boolean deInfOperaAccIdraulica = ParamUtil.getBoolean(request, "deInfOperaAccIdraulica"); + boolean deInfOperaAccAltro = ParamUtil.getBoolean(request, "deInfOperaAccAltro"); + boolean deInfAltraInfrastruttura = ParamUtil.getBoolean(request, "deInfAltraInfrastruttura"); + boolean deInfAltro = ParamUtil.getBoolean(request, "deInfAltro"); + String deInfAltroDesc = ParamUtil.getString(request, "deInfAltroDesc"); + String dccFondazioni = ParamUtil.getString(request, "dccFondazioni"); + boolean dccStruttureEleMuraturePietrame = ParamUtil.getBoolean(request, "dccStruttureEleMuraturePietrame"); + boolean dccStruttureEleMuratureLaterizio = ParamUtil.getBoolean(request, "dccStruttureEleMuratureLaterizio"); + boolean dccStruttureEleMuratureMisto = ParamUtil.getBoolean(request, "dccStruttureEleMuratureMisto"); + boolean dccStruttureEleMuratureStoriche = ParamUtil.getBoolean(request, "dccStruttureEleMuratureStoriche"); + String dccStruttureEleAcciaio = ParamUtil.getString(request, "dccStruttureEleAcciaio"); + String dccStruttureEleCA = ParamUtil.getString(request, "dccStruttureEleCA"); + String dccStruttureEleLegno = ParamUtil.getString(request, "dccStruttureEleLegno"); + boolean dccStruttureEleMistoCA = ParamUtil.getBoolean(request, "dccStruttureEleMistoCA"); + boolean dccStruttureEleMistoAcciaio = ParamUtil.getBoolean(request, "dccStruttureEleMistoAcciaio"); + boolean dccStruttureEleMistoMuratura = ParamUtil.getBoolean(request, "dccStruttureEleMistoMuratura"); + boolean dccStruttureEleMistoLegno = ParamUtil.getBoolean(request, "dccStruttureEleMistoLegno"); + boolean dccStruttureElePrefabbricato = ParamUtil.getBoolean(request, "dccStruttureElePrefabbricato"); + boolean dccStruttureEleAltro = ParamUtil.getBoolean(request, "dccStruttureEleAltro"); + String dccStruttureEleAltroDescrizione = ParamUtil.getString(request, "dccStruttureEleAltroDescrizione"); + boolean dccOrizzontamentiCAAcciaio = ParamUtil.getBoolean(request, "dccOrizzontamentiCAAcciaio"); + boolean dccOrizzontamentiLegno = ParamUtil.getBoolean(request, "dccOrizzontamentiLegno"); + boolean dccOrizzontamentiLegnoCA = ParamUtil.getBoolean(request, "dccOrizzontamentiLegnoCA"); + boolean dccOrizzontamentiLamieraGrecata = ParamUtil.getBoolean(request, "dccOrizzontamentiLamieraGrecata"); + boolean dccOrizzontamentiVolte = ParamUtil.getBoolean(request, "dccOrizzontamentiVolte"); + boolean dccOrizzontamentiAltro = ParamUtil.getBoolean(request, "dccOrizzontamentiAltro"); + String dccOrizzontamentiAltroDescrizione = ParamUtil.getString(request, "dccOrizzontamentiAltroDescrizione"); + String dccCopertura = ParamUtil.getString(request, "dccCopertura"); + boolean dccCoperturaCAAcciaio = ParamUtil.getBoolean(request, "dccCoperturaCAAcciaio"); + boolean dccCoperturaLegno = ParamUtil.getBoolean(request, "dccCoperturaLegno"); + boolean dccCoperturaLegnoCA = ParamUtil.getBoolean(request, "dccCoperturaLegnoCA"); + boolean dccCoperturaLamieraGrecata = ParamUtil.getBoolean(request, "dccCoperturaLamieraGrecata"); + boolean dccCoperturaPannelli = ParamUtil.getBoolean(request, "dccCoperturaPannelli"); + boolean dccCoperturaPVCTelonati = ParamUtil.getBoolean(request, "dccCoperturaPVCTelonati"); + boolean dccCoperturaLeggere = ParamUtil.getBoolean(request, "dccCoperturaLeggere"); + boolean dccCoperturaAltro = ParamUtil.getBoolean(request, "dccCoperturaAltro"); + String dccCoperturaAltroDesrizione = ParamUtil.getString(request, "dccCoperturaAltroDesrizione"); + boolean dccElemNonStrutLaterizio = ParamUtil.getBoolean(request, "dccElemNonStrutLaterizio"); + boolean dccElemNonStrutCartongesso = ParamUtil.getBoolean(request, "dccElemNonStrutCartongesso"); + boolean dccElemNonStrutCalcestruzzo = ParamUtil.getBoolean(request, "dccElemNonStrutCalcestruzzo"); + boolean dccElemNonStrutLegno = ParamUtil.getBoolean(request, "dccElemNonStrutLegno"); + boolean dccElemNonStrutAltro = ParamUtil.getBoolean(request, "dccElemNonStrutAltro"); + String dccElemNonStrutAltroDescrizione = ParamUtil.getString(request, "dccElemNonStrutAltroDescrizione"); + boolean dccOpereDiRinforzoInsCatene = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCatene"); + boolean dccOpereDiRinforzoInsCordoli = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCordoli"); + boolean dccOpereDiRinforzoIniArmate = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIniArmate"); + boolean dccOpereDiRinforzoPlaccaggi = ParamUtil.getBoolean(request, "dccOpereDiRinforzoPlaccaggi"); + boolean dccOpereDiRinforzoIrrSolai = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIrrSolai"); + boolean dccOpereDiRinforzoRinforziFRP = ParamUtil.getBoolean(request, "dccOpereDiRinforzoRinforziFRP"); + boolean dccOpereDiRinforzoTelaiECerchiature = ParamUtil.getBoolean(request, + "dccOpereDiRinforzoTelaiECerchiature"); + boolean dccOpereDiRinforzoInsRompitratta = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsRompitratta"); + boolean dccOpereDiRinforzoAltro = ParamUtil.getBoolean(request, "dccOpereDiRinforzoAltro"); + String dccOpereDiRinforzoAltroDescrizione = ParamUtil.getString(request, "dccOpereDiRinforzoAltroDescrizione"); + // DATI geologici + String geoClasseIndagine = getNotNullString(request, "geoClasseIndagine", dettPratica.getGeoClasseIndagine()); + String geoCategoriaSottosuolo = getNotNullString(request, "geoCategoriaSottosuolo", + dettPratica.getGeoCategoriaSottosuolo()); + String geoCategoriaTopografica = getNotNullString(request, "geoCategoriaTopografica", + dettPratica.getGeoCategoriaTopografica()); + String geoConsolidamento = getNotNullString(request, "geoConsolidamento", dettPratica.getGeoConsolidamento()); + String geoPericolositaGeologica = getNotNullString(request, "geoPericolositaGeologica", + dettPratica.getGeoPericolositaGeologica()); + String geoRischioGeomorfologicoPai = getNotNullString(request, "geoRischioGeomorfologicoPai", + dettPratica.getGeoRischioGeomorfologicoPai()); + String geoPericolositaIdraulicaPai = getNotNullString(request, "geoPericolositaIdraulicaPai", + dettPratica.getGeoPericolositaIdraulicaPai()); + String geoRischioIdraulicoPai = getNotNullString(request, "geoRischioIdraulicoPai", + dettPratica.getGeoRischioIdraulicoPai()); + String geoPericolositaSismica = getNotNullString(request, "geoPericolositaSismica", + dettPratica.getGeoPericolositaSismica()); + String geoPericolositaIdraulica = getNotNullString(request, "geoPericolositaIdraulica", + dettPratica.getGeoPericolositaIdraulica()); + String geoPericolositaGeomorfica = getNotNullString(request, "geoPericolositaGeomorfica", + dettPratica.getGeoPericolositaGeomorfica()); + String geoFattibilitaGeologica = getNotNullString(request, "geoFattibilitaGeologica", + dettPratica.getGeoFattibilitaGeologica()); + String geoFattibilitaSismica = getNotNullString(request, "geoFattibilitaSismica", + dettPratica.getGeoFattibilitaSismica()); + String geoFattibilitaIdraulica = getNotNullString(request, "geoFattibilitaIdraulica", + dettPratica.getGeoFattibilitaIdraulica()); + String geoOperaRilevante = getNotNullString(request, "geoOperaRilevante", dettPratica.getGeoOperaRilevante()); + String geoOpereDiSostegno = getNotNullString(request, "geoOpereDiSostegno", dettPratica.getGeoOpereDiSostegno()); + String geoOpereInSotterranea = getNotNullString(request, "geoOpereInSotterranea", + dettPratica.getGeoOpereInSotterranea()); + String geoPresenzaPrescrizioni = getNotNullString(request, "geoPresenzaPrescrizioni", + dettPratica.getGeoPresenzaPrescrizioni()); + String geoNotePrescrizioni = getNotNullString(request, "geoNotePrescrizioni", + dettPratica.getGeoNotePrescrizioni()); + String geoNoteIndagini = getNotNullString(request, "geoNoteIndagini", dettPratica.getGeoNoteIndagini()); + String geoEvidenzeGeomorfiche = getNotNullString(request, "geoEvidenzeGeomorfiche", + dettPratica.getGeoEvidenzeGeomorfiche()); + String geoEvidenzeGeologiche = getNotNullString(request, "geoEvidenzeGeologiche", + dettPratica.getGeoEvidenzeGeologiche()); + Date geoDtRelazione = getNotNullDate(request, "geoDtRelazione", dettPratica.getGeoDtRelazione()); + // normative + boolean normLavoriInProprio = ParamUtil.getBoolean(request, "normLavoriInProprio"); + boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); + boolean normEsenteSpese = ParamUtil.getBoolean(request, "normEsenteSpese"); + boolean normDpr01Dep = ParamUtil.getBoolean(request, "normDpr01Dep"); + boolean normDpr02Dep = ParamUtil.getBoolean(request, "normDpr02Dep"); + boolean normDpr01Aut = ParamUtil.getBoolean(request, "normDpr01Aut"); + boolean normDpr02Aut = ParamUtil.getBoolean(request, "normDpr02Aut"); + boolean normDm01 = ParamUtil.getBoolean(request, "normDm01"); + boolean normDm02 = ParamUtil.getBoolean(request, "normDm02"); + boolean normDm03 = ParamUtil.getBoolean(request, "normDm03"); + boolean normDm2018 = ParamUtil.getBoolean(request, "normDm2018"); + boolean normDprg01 = ParamUtil.getBoolean(request, "normDprg01"); + boolean normDprg02 = ParamUtil.getBoolean(request, "normDprg02"); + boolean normAnr = ParamUtil.getBoolean(request, "normAnr"); + boolean normArt3com3 = ParamUtil.getBoolean(request, "normArt3com3"); + boolean normArt3com4 = ParamUtil.getBoolean(request, "normArt3com4"); + boolean normOrd01 = ParamUtil.getBoolean(request, "normOrd01"); + boolean normDm04 = ParamUtil.getBoolean(request, "normDm04"); + boolean normDm05 = ParamUtil.getBoolean(request, "normDm05"); + boolean normCI01 = ParamUtil.getBoolean(request, "normCI01"); + boolean normLTC01 = ParamUtil.getBoolean(request, "normLTC01"); + boolean suap = ParamUtil.getBoolean(request, "suap"); + boolean normSismaBonus = ParamUtil.getBoolean(request, "normSismaBonus"); + String clRischioPreInt = ParamUtil.getString(request, "clRischioPreInt"); + String clRischioPostInt = ParamUtil.getString(request, "clRischioPostInt"); + boolean intervFinPub = ParamUtil.getBoolean(request, "intervFinPub"); + String intervFinPubDesc = ParamUtil.getString(request, "intervFinPubDesc"); + String contestoPaesaggistico = ParamUtil.getString(request, "contestoPaesaggistico"); + String livelloDiTutela = ParamUtil.getString(request, "livelloDiTutela"); + String vincoli = ParamUtil.getString(request, "vincoli"); + + long userId = PortalUtil.getUserId(request); + + IntPratica intPratica = IntPraticaLocalServiceUtil.getIntPratica(dettPratica.getIntPraticaId()); + if(intPratica.isPraticaOspedaliera()){ + destinazione = dettPratica.getDestinazione(); + normEsenteBollo = dettPratica.getNormEsenteBollo(); + normEsenteSpese = dettPratica.getNormEsenteSpese(); + lavoriPubblici = dettPratica.getLavoriPubblici(); + } + try { + DettPraticaServiceUtil.updateDettPratica(userId, dettPratica.getDettPraticaId(), + dettPratica.getIntPraticaId(), integrazione, protocollo, tipoIntegrazione, completa, gestita, + codicePagamento, causalePagamento, mezzoPagamento, importoBolli, importoSpeseIstruttoria, + dataEffettuazione, statusTask, workflowForzato, soggettoSostituitoId, destinazione, ag, + descLongIntervento, via, localita, estremiCatastali, estremiPratCom, variataDa, varianteNumero, + varianteSostanziale, operaConforme, collaudoStatico, codiceFiscaleDelegatoCommittente, + codiceFiscaleDelegatoFineLavori, codiceFiscaleDelegatoCollaudo, codiceRuoloDelegato, + lavoriInEconomiaCommittente, inizioLavoriContestualeOpera, dataInizioLavoriOpera, + dataInizioEsecuzioneOpera, dataFineEsecuzioneOpera, metratura, lavoriPubblici, pagamentoId, + lavoriPubbliciPercentuale, numeroCivico, dcParticelle, dcFoglio, dcAllegato, dePiani, deAltezza, + deInterrati, deSuperficie, deCostruzione, deRistrutturazione, deUso, dePubblica, dePrivata, + deUtilizzazione, dePosizioneEdificio, deInfStradalePonte, deInfStradaleStrada, deInfStradaleAltro, + deInfIdraulicaLong, deInfIdraulicaTrasv, deInfIdraulicaAltro, deInfOperaAccStradale, + deInfOperaAccIdraulica, deInfOperaAccAltro, deInfAltraInfrastruttura, deInfAltro, deInfAltroDesc, + dccFondazioni, dccStruttureEleMuraturePietrame, dccStruttureEleMuratureLaterizio, + dccStruttureEleMuratureMisto, dccStruttureEleMuratureStoriche, dccStruttureEleAcciaio, + dccStruttureEleCA, dccStruttureEleLegno, dccStruttureEleMistoCA, dccStruttureEleMistoAcciaio, + dccStruttureEleMistoMuratura, dccStruttureEleMistoLegno, dccStruttureElePrefabbricato, + dccStruttureEleAltro, dccStruttureEleAltroDescrizione, dccOrizzontamentiCAAcciaio, + dccOrizzontamentiLegno, dccOrizzontamentiLegnoCA, dccOrizzontamentiLamieraGrecata, + dccOrizzontamentiVolte, dccOrizzontamentiAltro, dccOrizzontamentiAltroDescrizione, dccCopertura, + dccCoperturaCAAcciaio, dccCoperturaLegno, dccCoperturaLegnoCA, dccCoperturaLamieraGrecata, + dccCoperturaPannelli, dccCoperturaPVCTelonati, dccCoperturaLeggere, dccCoperturaAltro, + dccCoperturaAltroDesrizione, dccElemNonStrutLaterizio, dccElemNonStrutCartongesso, + dccElemNonStrutCalcestruzzo, dccElemNonStrutLegno, dccElemNonStrutAltro, + dccElemNonStrutAltroDescrizione, dccOpereDiRinforzoInsCatene, dccOpereDiRinforzoInsCordoli, + dccOpereDiRinforzoIniArmate, dccOpereDiRinforzoPlaccaggi, dccOpereDiRinforzoIrrSolai, + dccOpereDiRinforzoRinforziFRP, dccOpereDiRinforzoTelaiECerchiature, + dccOpereDiRinforzoInsRompitratta, dccOpereDiRinforzoAltro, dccOpereDiRinforzoAltroDescrizione, + geoClasseIndagine, geoCategoriaSottosuolo, geoCategoriaTopografica, geoConsolidamento, + geoPericolositaGeologica, geoRischioGeomorfologicoPai, geoPericolositaIdraulicaPai, + geoRischioIdraulicoPai, geoPericolositaSismica, geoPericolositaIdraulica, + geoPericolositaGeomorfica, geoFattibilitaGeologica, geoFattibilitaSismica, geoFattibilitaIdraulica, + geoOperaRilevante, geoOpereDiSostegno, geoOpereInSotterranea, geoPresenzaPrescrizioni, + geoNotePrescrizioni, geoNoteIndagini, geoEvidenzeGeomorfiche, geoEvidenzeGeologiche, + geoDtRelazione, pagNuoveCostruzioni, pagAdeguamentoSismico, pagMiglioramentoSismico, + pagRiparazioneInterventoLocale, pagNuovaCostruzione, pagVarianti, pagAltro, + pagMiglioramentoSismicoSicilia, pagCalcolatoAdeguamentoSismico, pagCalcolatoMiglioramentoSismico, + pagCalcolatoRiparazioneInterventoLocale, pagCalcolatoOperaNonQuantificabile, + pagEffettivoAdeguamentoSismico, pagEffettivoMiglioramentoSismico, + pagEffettivoRiparazioneInterventoLocale, pagEffettivoOperaNonQuantificabile, pagNoteUtente, note, + noteUfficio, localizzazioneGeografica, tcNuovaCostruzione, tcAdeguamentoSismico, + tcMiglioramentoSismico, tcRiparazioneInterventoLocale, tcInCA, tcInOpera, tcPrefabbricato, + tcInAcciaio, tcMista, tcInMuratura, tcInMuraturaOrdinaria, tcInMuraturaArmata, tcInMuraturaMista, + tcInLegno, tcAltro, tcAltroDescrizione, tcConDispositivi, normLavoriInProprio, normEsenteBollo, + normEsenteSpese, normDpr01Dep, normDpr02Dep, normDpr01Aut, normDpr02Aut, normDm01, normDm02, + normDm03, normDm2018, normDprg01, normDprg02, normAnr, normArt3com3, normArt3com4, normOrd01, + normDm04, normDm05, normCI01, normLTC01, suap, normSismaBonus, clRischioPreInt, clRischioPostInt, + intervFinPub, intervFinPubDesc, tcNuovaCostruzioneComplessa, contestoPaesaggistico, + livelloDiTutela, vincoli, serviceContext, bozza, disabledSubmit, geoDisabledSubmit); + String redirect = ParamUtil.getString(request, "redirect"); + if (Validator.isNull(redirect)) { + String successURL = ParamUtil.getString(request, "successURL"); + if (Validator.isNotNull(successURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", + String.valueOf(!bozza)); + String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", + String.valueOf(verifyArea)); + String fragmentURL = ParamUtil.getString(request, "current_tab"); + if (Validator.isNotNull(fragmentURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "current_tab"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "current_tab", + fragmentURL); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "historyKey"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "historyKey", + "_1_WAR_portosfeportlet_tab=" + fragmentURL); + if (successURL.contains(StringPool.POUND)) { + successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + } + successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; + } + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "saveAndVerify"); + if ("saveAndVerify".equalsIgnoreCase(cmd)) + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "saveAndVerify", true); + response.sendRedirect(successURL); + } else { + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); + response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); + response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); + response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); } - successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; } - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "saveAndVerify"); - if ("saveAndVerify".equalsIgnoreCase(cmd)) - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "saveAndVerify", true); - response.sendRedirect(successURL); - } else { + } catch (PortalException e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + throw e; + } catch (Exception e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); - response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); - response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); - response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); + throw new PortalException(e); } - } - } catch (PortalException e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw e; - } catch (Exception e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw new PortalException(e); - } } private String getNotNullString(ActionRequest request, String param, String currentValue) { @@ -1349,361 +1388,361 @@ public class FascicoloFePortlet extends MVCPortlet { "codiceFiscaleDelegatoFineLavoriEnabled"); String codiceFiscaleDelegatoFineLavori = isCodiceFiscaleDelegatoFineLavoriAuthorized ? ParamUtil.getString( request, "codiceFiscaleDelegatoFineLavori") : StringPool.BLANK; - boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, - "codiceFiscaleDelegatoCollaudoEnabled"); - String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, - "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; - boolean inizioLavoriContestualeOpera = ParamUtil.getBoolean(request, "inizioLavoriContestualeOpera"); - long pagamentoId = ParamUtil.getLong(request, "pagamentoId"); - Date dataEffettuazione = ParamUtil.getDate(request, "dataEffettuazione", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataInizioLavoriOpera = ParamUtil.getDate(request, "dataInizioLavoriOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataInizioEsecuzioneOpera = ParamUtil.getDate(request, "dataInizioEsecuzioneOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - Date dataFineEsecuzioneOpera = ParamUtil.getDate(request, "dataFineEsecuzioneOpera", - DateFormatFactoryUtil.getDate(request.getLocale())); - String note = ParamUtil.getString(request, "note"); - String noteUfficio = ParamUtil.getString(request, "noteUfficio"); - // PAGAMENTI - String codicePagamento = ParamUtil.getString(request, "codicePagamento"); - String causalePagamento = ParamUtil.getString(request, "causalePagamento"); - String mezzoPagamento = ParamUtil.getString(request, "mezzoPagamento"); - String importoBolli = ParamUtil.getString(request, "importoBolli"); - String importoSpeseIstruttoria = ParamUtil.getString(request, "importoSpeseIstruttoria"); - boolean pagNuoveCostruzioni = ParamUtil.getBoolean(request, "pagNuoveCostruzioni"); - int pagAdeguamentoSismico = ParamUtil.getInteger(request, "pagAdeguamentoSismico"); - int pagMiglioramentoSismico = ParamUtil.getInteger(request, "pagMiglioramentoSismico"); - boolean pagRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "pagRiparazioneInterventoLocale"); - int pagNuovaCostruzione = ParamUtil.getInteger(request, "pagNuovaCostruzione"); - boolean pagVarianti = ParamUtil.getBoolean(request, "pagVarianti"); - int pagAltro = ParamUtil.getInteger(request, "pagAltro"); - boolean pagMiglioramentoSismicoSicilia = ParamUtil.getBoolean(request, "pagMiglioramentoSismicoSicilia"); - String pagCalcolatoAdeguamentoSismico = ParamUtil.getString(request, "pagCalcolatoAdeguamentoSismico"); - String pagCalcolatoMiglioramentoSismico = ParamUtil.getString(request, "pagCalcolatoMiglioramentoSismico"); - String pagCalcolatoRiparazioneInterventoLocale = ParamUtil.getString(request, - "pagCalcolatoRiparazioneInterventoLocale"); - String pagCalcolatoOperaNonQuantificabile = ParamUtil.getString(request, "pagCalcolatoOperaNonQuantificabile"); - String pagEffettivoAdeguamentoSismico = ParamUtil.getString(request, "pagEffettivoAdeguamentoSismico"); - String pagEffettivoMiglioramentoSismico = ParamUtil.getString(request, "pagEffettivoMiglioramentoSismico"); - String pagEffettivoRiparazioneInterventoLocale = ParamUtil.getString(request, - "pagEffettivoRiparazioneInterventoLocale"); - String pagEffettivoOperaNonQuantificabile = ParamUtil.getString(request, "pagEffettivoOperaNonQuantificabile"); - String pagNoteUtente = ParamUtil.getString(request, "pagNoteUtente"); - // SEZIONE DETTAGLI PRINCIPALI - DettPratica dettCheck = DettPraticaLocalServiceUtil.fetchDettPratica(dettPraticaId); - boolean disabledCollaudoStatico = false; - if (dettCheck != null) { - disabledCollaudoStatico = SoggettiUtil.isCommittenteAndDitta(dettCheck.getIntPraticaId()); - } - boolean collaudoStatico = ParamUtil.getBoolean(request, "collaudoStatico"); - if (disabledCollaudoStatico) { - collaudoStatico = dettCheck.getCollaudoStatico(); - } - boolean lavoriInEconomiaCommittente = ParamUtil.getBoolean(request, "lavoriInEconomiaCommittente"); - String destinazione = ParamUtil.getString(request, "destinazione"); - String ag = ParamUtil.getString(request, "ag"); - String descLongIntervento = ParamUtil.getString(request, "descLongIntervento"); - String estremiCatastali = ParamUtil.getString(request, "estremiCatastali"); - String estremiPratCom = ParamUtil.getString(request, "estremiPratCom"); - String metratura = ParamUtil.getString(request, "metratura"); - boolean lavoriPubblici = ParamUtil.getBoolean(request, "lavoriPubblici"); - int lavoriPubbliciPercentuale = ParamUtil.getInteger(request, "lavoriPubbliciPercentuale"); - String numeroCivico = ParamUtil.getString(request, "numeroCivico"); - String dcFoglio = ParamUtil.getString(request, "dcFoglio"); - String dcAllegato = ParamUtil.getString(request, "dcAllegato"); - String particella1 = ParamUtil.getString(request, "particella1", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella2 = ParamUtil.getString(request, "particella2", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella3 = ParamUtil.getString(request, "particella3", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String particella4 = ParamUtil.getString(request, "particella4", StringPool.BLANK).replaceAll( - Pattern.quote(StringPool.PIPE), StringPool.SPACE); - String dcParticelle = particella1 + StringPool.PIPE + particella2 + StringPool.PIPE + particella3 - + StringPool.PIPE + particella4; - String localizzazioneGeografica = ParamUtil.getString(request, "localizzazioneGeografica"); - boolean tcNuovaCostruzione = ParamUtil.getBoolean(request, "tcNuovaCostruzione"); - boolean tcAdeguamentoSismico = ParamUtil.getBoolean(request, "tcAdeguamentoSismico"); - boolean tcMiglioramentoSismico = ParamUtil.getBoolean(request, "tcMiglioramentoSismico"); - boolean tcRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "tcRiparazioneInterventoLocale"); - boolean tcNuovaCostruzioneComplessa = ParamUtil.getBoolean(request, "tcNuovaCostruzioneComplessa"); - boolean tcInCA = ParamUtil.getBoolean(request, "tcInCA"); - boolean tcInOpera = ParamUtil.getBoolean(request, "tcInOpera"); - boolean tcPrefabbricato = ParamUtil.getBoolean(request, "tcPrefabbricato"); - boolean tcInAcciaio = ParamUtil.getBoolean(request, "tcInAcciaio"); - boolean tcMista = ParamUtil.getBoolean(request, "tcMista"); - boolean tcInMuratura = ParamUtil.getBoolean(request, "tcInMuratura"); - boolean tcInMuraturaOrdinaria = ParamUtil.getBoolean(request, "tcInMuraturaOrdinaria"); - boolean tcInMuraturaArmata = ParamUtil.getBoolean(request, "tcInMuraturaArmata"); - boolean tcInMuraturaMista = ParamUtil.getBoolean(request, "tcInMuraturaMista"); - boolean tcInLegno = ParamUtil.getBoolean(request, "tcInLegno"); - boolean tcAltro = ParamUtil.getBoolean(request, "tcAltro"); - String tcAltroDescrizione = ParamUtil.getString(request, "tcAltroDescrizione"); - boolean tcConDispositivi = ParamUtil.getBoolean(request, "tcConDispositivi"); - // Descrizione edificio - String dePiani = ParamUtil.getString(request, "dePiani"); - String deAltezza = ParamUtil.getString(request, "deAltezza"); - String deInterrati = ParamUtil.getString(request, "deInterrati"); - String deSuperficie = ParamUtil.getString(request, "deSuperficie"); - String deCostruzione = ParamUtil.getString(request, "deCostruzione"); - String deRistrutturazione = ParamUtil.getString(request, "deRistrutturazione"); - String deUso = ParamUtil.getString(request, "deUso"); - String dePrivata = ParamUtil.getString(request, "dePrivata"); - String dePubblica = ParamUtil.getString(request, "dePubblica"); - String deUtilizzazione = ParamUtil.getString(request, "deUtilizzazione"); - String dePosizioneEdificio = ParamUtil.getString(request, "dePosizioneEdificio"); - boolean deInfStradalePonte = ParamUtil.getBoolean(request, "deInfStradalePonte"); - boolean deInfStradaleStrada = ParamUtil.getBoolean(request, "deInfStradaleStrada"); - boolean deInfStradaleAltro = ParamUtil.getBoolean(request, "deInfStradaleAltro"); - boolean deInfIdraulicaLong = ParamUtil.getBoolean(request, "deInfIdraulicaLong"); - boolean deInfIdraulicaTrasv = ParamUtil.getBoolean(request, "deInfIdraulicaTrasv"); - boolean deInfIdraulicaAltro = ParamUtil.getBoolean(request, "deInfIdraulicaAltro"); - boolean deInfOperaAccStradale = ParamUtil.getBoolean(request, "deInfOperaAccStradale"); - boolean deInfOperaAccIdraulica = ParamUtil.getBoolean(request, "deInfOperaAccIdraulica"); - boolean deInfOperaAccAltro = ParamUtil.getBoolean(request, "deInfOperaAccAltro"); - boolean deInfAltraInfrastruttura = ParamUtil.getBoolean(request, "deInfAltraInfrastruttura"); - boolean deInfAltro = ParamUtil.getBoolean(request, "deInfAltro"); - String deInfAltroDesc = ParamUtil.getString(request, "deInfAltroDesc"); - String dccFondazioni = ParamUtil.getString(request, "dccFondazioni"); - boolean dccStruttureEleMuraturePietrame = ParamUtil.getBoolean(request, "dccStruttureEleMuraturePietrame"); - boolean dccStruttureEleMuratureLaterizio = ParamUtil.getBoolean(request, "dccStruttureEleMuratureLaterizio"); - boolean dccStruttureEleMuratureMisto = ParamUtil.getBoolean(request, "dccStruttureEleMuratureMisto"); - boolean dccStruttureEleMuratureStoriche = ParamUtil.getBoolean(request, "dccStruttureEleMuratureStoriche"); - String dccStruttureEleAcciaio = ParamUtil.getString(request, "dccStruttureEleAcciaio"); - String dccStruttureEleCA = ParamUtil.getString(request, "dccStruttureEleCA"); - String dccStruttureEleLegno = ParamUtil.getString(request, "dccStruttureEleLegno"); - boolean dccStruttureEleMistoCA = ParamUtil.getBoolean(request, "dccStruttureEleMistoCA"); - boolean dccStruttureEleMistoAcciaio = ParamUtil.getBoolean(request, "dccStruttureEleMistoAcciaio"); - boolean dccStruttureEleMistoMuratura = ParamUtil.getBoolean(request, "dccStruttureEleMistoMuratura"); - boolean dccStruttureEleMistoLegno = ParamUtil.getBoolean(request, "dccStruttureEleMistoLegno"); - boolean dccStruttureElePrefabbricato = ParamUtil.getBoolean(request, "dccStruttureElePrefabbricato"); - boolean dccStruttureEleAltro = ParamUtil.getBoolean(request, "dccStruttureEleAltro"); - String dccStruttureEleAltroDescrizione = ParamUtil.getString(request, "dccStruttureEleAltroDescrizione"); - boolean dccOrizzontamentiCAAcciaio = ParamUtil.getBoolean(request, "dccOrizzontamentiCAAcciaio"); - boolean dccOrizzontamentiLegno = ParamUtil.getBoolean(request, "dccOrizzontamentiLegno"); - boolean dccOrizzontamentiLegnoCA = ParamUtil.getBoolean(request, "dccOrizzontamentiLegnoCA"); - boolean dccOrizzontamentiLamieraGrecata = ParamUtil.getBoolean(request, "dccOrizzontamentiLamieraGrecata"); - boolean dccOrizzontamentiVolte = ParamUtil.getBoolean(request, "dccOrizzontamentiVolte"); - boolean dccOrizzontamentiAltro = ParamUtil.getBoolean(request, "dccOrizzontamentiAltro"); - String dccOrizzontamentiAltroDescrizione = ParamUtil.getString(request, "dccOrizzontamentiAltroDescrizione"); - String dccCopertura = ParamUtil.getString(request, "dccCopertura"); - boolean dccCoperturaCAAcciaio = ParamUtil.getBoolean(request, "dccCoperturaCAAcciaio"); - boolean dccCoperturaLegno = ParamUtil.getBoolean(request, "dccCoperturaLegno"); - boolean dccCoperturaLegnoCA = ParamUtil.getBoolean(request, "dccCoperturaLegnoCA"); - boolean dccCoperturaLamieraGrecata = ParamUtil.getBoolean(request, "dccCoperturaLamieraGrecata"); - boolean dccCoperturaPannelli = ParamUtil.getBoolean(request, "dccCoperturaPannelli"); - boolean dccCoperturaPVCTelonati = ParamUtil.getBoolean(request, "dccCoperturaPVCTelonati"); - boolean dccCoperturaLeggere = ParamUtil.getBoolean(request, "dccCoperturaLeggere"); - boolean dccCoperturaAltro = ParamUtil.getBoolean(request, "dccCoperturaAltro"); - String dccCoperturaAltroDesrizione = ParamUtil.getString(request, "dccCoperturaAltroDesrizione"); - boolean dccElemNonStrutLaterizio = ParamUtil.getBoolean(request, "dccElemNonStrutLaterizio"); - boolean dccElemNonStrutCartongesso = ParamUtil.getBoolean(request, "dccElemNonStrutCartongesso"); - boolean dccElemNonStrutCalcestruzzo = ParamUtil.getBoolean(request, "dccElemNonStrutCalcestruzzo"); - boolean dccElemNonStrutLegno = ParamUtil.getBoolean(request, "dccElemNonStrutLegno"); - boolean dccElemNonStrutAltro = ParamUtil.getBoolean(request, "dccElemNonStrutAltro"); - String dccElemNonStrutAltroDescrizione = ParamUtil.getString(request, "dccElemNonStrutAltroDescrizione"); - boolean dccOpereDiRinforzoInsCatene = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCatene"); - boolean dccOpereDiRinforzoInsCordoli = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCordoli"); - boolean dccOpereDiRinforzoIniArmate = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIniArmate"); - boolean dccOpereDiRinforzoPlaccaggi = ParamUtil.getBoolean(request, "dccOpereDiRinforzoPlaccaggi"); - boolean dccOpereDiRinforzoIrrSolai = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIrrSolai"); - boolean dccOpereDiRinforzoRinforziFRP = ParamUtil.getBoolean(request, "dccOpereDiRinforzoRinforziFRP"); - boolean dccOpereDiRinforzoTelaiECerchiature = ParamUtil.getBoolean(request, - "dccOpereDiRinforzoTelaiECerchiature"); - boolean dccOpereDiRinforzoInsRompitratta = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsRompitratta"); - boolean dccOpereDiRinforzoAltro = ParamUtil.getBoolean(request, "dccOpereDiRinforzoAltro"); - String dccOpereDiRinforzoAltroDescrizione = ParamUtil.getString(request, "dccOpereDiRinforzoAltroDescrizione"); - // DATI geologici - String geoClasseIndagine = getNotNullString(request, "geoClasseIndagine", dettPratica.getGeoClasseIndagine()); - String geoCategoriaSottosuolo = getNotNullString(request, "geoCategoriaSottosuolo", - dettPratica.getGeoCategoriaSottosuolo()); - String geoCategoriaTopografica = getNotNullString(request, "geoCategoriaTopografica", - dettPratica.getGeoCategoriaTopografica()); - String geoConsolidamento = getNotNullString(request, "geoConsolidamento", dettPratica.getGeoConsolidamento()); - String geoPericolositaGeologica = getNotNullString(request, "geoPericolositaGeologica", - dettPratica.getGeoPericolositaGeologica()); - String geoRischioGeomorfologicoPai = getNotNullString(request, "geoRischioGeomorfologicoPai", - dettPratica.getGeoRischioGeomorfologicoPai()); - String geoPericolositaIdraulicaPai = getNotNullString(request, "geoPericolositaIdraulicaPai", - dettPratica.getGeoPericolositaIdraulicaPai()); - String geoRischioIdraulicoPai = getNotNullString(request, "geoRischioIdraulicoPai", - dettPratica.getGeoRischioIdraulicoPai()); - String geoPericolositaSismica = getNotNullString(request, "geoPericolositaSismica", - dettPratica.getGeoPericolositaSismica()); - String geoPericolositaIdraulica = getNotNullString(request, "geoPericolositaIdraulica", - dettPratica.getGeoPericolositaIdraulica()); - String geoPericolositaGeomorfica = getNotNullString(request, "geoPericolositaGeomorfica", - dettPratica.getGeoPericolositaGeomorfica()); - String geoFattibilitaGeologica = getNotNullString(request, "geoFattibilitaGeologica", - dettPratica.getGeoFattibilitaGeologica()); - String geoFattibilitaSismica = getNotNullString(request, "geoFattibilitaSismica", - dettPratica.getGeoFattibilitaSismica()); - String geoFattibilitaIdraulica = getNotNullString(request, "geoFattibilitaIdraulica", - dettPratica.getGeoFattibilitaIdraulica()); - String geoOperaRilevante = getNotNullString(request, "geoOperaRilevante", dettPratica.getGeoOperaRilevante()); - String geoOpereDiSostegno = getNotNullString(request, "geoOpereDiSostegno", dettPratica.getGeoOpereDiSostegno()); - String geoOpereInSotterranea = getNotNullString(request, "geoOpereInSotterranea", - dettPratica.getGeoOpereInSotterranea()); - String geoPresenzaPrescrizioni = getNotNullString(request, "geoPresenzaPrescrizioni", - dettPratica.getGeoPresenzaPrescrizioni()); - String geoNotePrescrizioni = getNotNullString(request, "geoNotePrescrizioni", - dettPratica.getGeoNotePrescrizioni()); - String geoNoteIndagini = getNotNullString(request, "geoNoteIndagini", dettPratica.getGeoNoteIndagini()); - String geoEvidenzeGeomorfiche = getNotNullString(request, "geoEvidenzeGeomorfiche", - dettPratica.getGeoEvidenzeGeomorfiche()); - String geoEvidenzeGeologiche = getNotNullString(request, "geoEvidenzeGeologiche", - dettPratica.getGeoEvidenzeGeologiche()); - Date geoDtRelazione = getNotNullDate(request, "geoDtRelazione", dettPratica.getGeoDtRelazione()); - // normative - boolean normLavoriInProprio = ParamUtil.getBoolean(request, "normLavoriInProprio"); - boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); - boolean normEsenteSpese = ParamUtil.getBoolean(request, "normEsenteSpese"); - boolean normDpr01Dep = ParamUtil.getBoolean(request, "normDpr01Dep"); - boolean normDpr02Dep = ParamUtil.getBoolean(request, "normDpr02Dep"); - boolean normDpr01Aut = ParamUtil.getBoolean(request, "normDpr01Aut"); - boolean normDpr02Aut = ParamUtil.getBoolean(request, "normDpr02Aut"); - boolean normDm01 = ParamUtil.getBoolean(request, "normDm01"); - boolean normDm02 = ParamUtil.getBoolean(request, "normDm02"); - boolean normDm03 = ParamUtil.getBoolean(request, "normDm03"); - boolean normDm2018 = ParamUtil.getBoolean(request, "normDm2018"); - boolean normDprg01 = ParamUtil.getBoolean(request, "normDprg01"); - boolean normDprg02 = ParamUtil.getBoolean(request, "normDprg02"); - boolean normAnr = ParamUtil.getBoolean(request, "normAnr"); - boolean normArt3com3 = ParamUtil.getBoolean(request, "normArt3com3"); - boolean normArt3com4 = ParamUtil.getBoolean(request, "normArt3com4"); - boolean normOrd01 = ParamUtil.getBoolean(request, "normOrd01"); - boolean normDm04 = ParamUtil.getBoolean(request, "normDm04"); - boolean normDm05 = ParamUtil.getBoolean(request, "normDm05"); - boolean normCI01 = ParamUtil.getBoolean(request, "normCI01"); - boolean normLTC01 = ParamUtil.getBoolean(request, "normLTC01"); - boolean suap = ParamUtil.getBoolean(request, "suap"); - boolean normSismaBonus = ParamUtil.getBoolean(request, "normSismaBonus"); - String clRischioPreInt = ParamUtil.getString(request, "clRischioPreInt"); - String clRischioPostInt = ParamUtil.getString(request, "clRischioPostInt"); - boolean intervFinPub = ParamUtil.getBoolean(request, "intervFinPub"); - String intervFinPubDesc = intervFinPub ? ParamUtil.getString(request, "intervFinPubDesc") : StringPool.BLANK; - - String contestoPaesaggistico = ParamUtil.getString(request, "contestoPaesaggistico"); - String livelloDiTutela = ParamUtil.getString(request, "livelloDiTutela"); - String vincoli = ParamUtil.getString(request, "vincoli"); - - long userId = PortalUtil.getUserId(request); - String via = dettPratica.getVia(); - String localita = dettPratica.getLocalita(); - if (!ParamUtil.getString(request, "via").equals(StringPool.BLANK)) { - via = ParamUtil.getString(request, "via"); - } - if (!ParamUtil.getString(request, "localita").equals(StringPool.BLANK)) { - localita = ParamUtil.getString(request, "localita"); - } - IntPratica intPratica = IntPraticaLocalServiceUtil.getIntPratica(dettPratica.getIntPraticaId()); - if(intPratica.isPraticaOspedaliera()){ - destinazione = dettPratica.getDestinazione(); - normEsenteBollo = dettPratica.getNormEsenteBollo(); - normEsenteSpese = dettPratica.getNormEsenteSpese(); - lavoriPubblici = dettPratica.getLavoriPubblici(); - } - try { - DettPraticaServiceUtil.updateDettPratica(userId, dettPratica.getDettPraticaId(), - dettPratica.getIntPraticaId(), dettPratica.getIntegrazione(), protocollo, tipoIntegrazione, - dettPratica.getCompleta(), dettPratica.getGestita(), codicePagamento, causalePagamento, - mezzoPagamento, importoBolli, importoSpeseIstruttoria, dataEffettuazione, - dettPratica.getStatusTask(), dettPratica.getWorkflowForzato(), - dettPratica.getSoggettoSostituitoId(), destinazione, ag, descLongIntervento, via, localita, - estremiCatastali, estremiPratCom, dettPratica.getVariataDa(), dettPratica.getVarianteNumero(), - varianteSostanziale, dettPratica.getOperaConforme(), collaudoStatico, - codiceFiscaleDelegatoCommittente, codiceFiscaleDelegatoFineLavori, codiceFiscaleDelegatoCollaudo, - dettPratica.getCodiceRuoloDelegato(), lavoriInEconomiaCommittente, inizioLavoriContestualeOpera, - dataInizioLavoriOpera, dataInizioEsecuzioneOpera, dataFineEsecuzioneOpera, metratura, - lavoriPubblici, pagamentoId, lavoriPubbliciPercentuale, numeroCivico, dcParticelle, dcFoglio, - dcAllegato, dePiani, deAltezza, deInterrati, deSuperficie, deCostruzione, deRistrutturazione, - deUso, dePubblica, dePrivata, deUtilizzazione, dePosizioneEdificio, deInfStradalePonte, - deInfStradaleStrada, deInfStradaleAltro, deInfIdraulicaLong, deInfIdraulicaTrasv, - deInfIdraulicaAltro, deInfOperaAccStradale, deInfOperaAccIdraulica, deInfOperaAccAltro, - deInfAltraInfrastruttura, deInfAltro, deInfAltroDesc, dccFondazioni, - dccStruttureEleMuraturePietrame, dccStruttureEleMuratureLaterizio, dccStruttureEleMuratureMisto, - dccStruttureEleMuratureStoriche, dccStruttureEleAcciaio, dccStruttureEleCA, dccStruttureEleLegno, - dccStruttureEleMistoCA, dccStruttureEleMistoAcciaio, dccStruttureEleMistoMuratura, - dccStruttureEleMistoLegno, dccStruttureElePrefabbricato, dccStruttureEleAltro, - dccStruttureEleAltroDescrizione, dccOrizzontamentiCAAcciaio, dccOrizzontamentiLegno, - dccOrizzontamentiLegnoCA, dccOrizzontamentiLamieraGrecata, dccOrizzontamentiVolte, - dccOrizzontamentiAltro, dccOrizzontamentiAltroDescrizione, dccCopertura, dccCoperturaCAAcciaio, - dccCoperturaLegno, dccCoperturaLegnoCA, dccCoperturaLamieraGrecata, dccCoperturaPannelli, - dccCoperturaPVCTelonati, dccCoperturaLeggere, dccCoperturaAltro, dccCoperturaAltroDesrizione, - dccElemNonStrutLaterizio, dccElemNonStrutCartongesso, dccElemNonStrutCalcestruzzo, - dccElemNonStrutLegno, dccElemNonStrutAltro, dccElemNonStrutAltroDescrizione, - dccOpereDiRinforzoInsCatene, dccOpereDiRinforzoInsCordoli, dccOpereDiRinforzoIniArmate, - dccOpereDiRinforzoPlaccaggi, dccOpereDiRinforzoIrrSolai, dccOpereDiRinforzoRinforziFRP, - dccOpereDiRinforzoTelaiECerchiature, dccOpereDiRinforzoInsRompitratta, dccOpereDiRinforzoAltro, - dccOpereDiRinforzoAltroDescrizione, geoClasseIndagine, geoCategoriaSottosuolo, - geoCategoriaTopografica, geoConsolidamento, geoPericolositaGeologica, geoRischioGeomorfologicoPai, - geoPericolositaIdraulicaPai, geoRischioIdraulicoPai, geoPericolositaSismica, - geoPericolositaIdraulica, geoPericolositaGeomorfica, geoFattibilitaGeologica, - geoFattibilitaSismica, geoFattibilitaIdraulica, geoOperaRilevante, geoOpereDiSostegno, - geoOpereInSotterranea, geoPresenzaPrescrizioni, geoNotePrescrizioni, geoNoteIndagini, - geoEvidenzeGeomorfiche, geoEvidenzeGeologiche, geoDtRelazione, pagNuoveCostruzioni, - pagAdeguamentoSismico, pagMiglioramentoSismico, pagRiparazioneInterventoLocale, - pagNuovaCostruzione, pagVarianti, pagAltro, pagMiglioramentoSismicoSicilia, - pagCalcolatoAdeguamentoSismico, pagCalcolatoMiglioramentoSismico, - pagCalcolatoRiparazioneInterventoLocale, pagCalcolatoOperaNonQuantificabile, - pagEffettivoAdeguamentoSismico, pagEffettivoMiglioramentoSismico, - pagEffettivoRiparazioneInterventoLocale, pagEffettivoOperaNonQuantificabile, pagNoteUtente, note, - noteUfficio, localizzazioneGeografica, tcNuovaCostruzione, tcAdeguamentoSismico, - tcMiglioramentoSismico, tcRiparazioneInterventoLocale, tcInCA, tcInOpera, tcPrefabbricato, - tcInAcciaio, tcMista, tcInMuratura, tcInMuraturaOrdinaria, tcInMuraturaArmata, tcInMuraturaMista, - tcInLegno, tcAltro, tcAltroDescrizione, tcConDispositivi, normLavoriInProprio, normEsenteBollo, - normEsenteSpese, normDpr01Dep, normDpr02Dep, normDpr01Aut, normDpr02Aut, normDm01, normDm02, - normDm03, normDm2018, normDprg01, normDprg02, normAnr, normArt3com3, normArt3com4, normOrd01, - normDm04, normDm05, normCI01, normLTC01, suap, normSismaBonus, clRischioPreInt, clRischioPostInt, - intervFinPub, intervFinPubDesc, tcNuovaCostruzioneComplessa, contestoPaesaggistico, - livelloDiTutela, vincoli, serviceContext, bozza, disabledSubmit, geoDisabledSubmit); - String redirect = ParamUtil.getString(request, "redirect"); - if (Validator.isNull(redirect)) { - String successURL = ParamUtil.getString(request, "successURL"); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "isNewVariante"); - if (Validator.isNotNull(successURL)) { - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", - String.valueOf(!bozza)); - String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", - String.valueOf(verifyArea)); - String fragmentURL = ParamUtil.getString(request, "current_tab"); - if (Validator.isNotNull(fragmentURL)) { - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "current_tab"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "current_tab", - fragmentURL); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "historyKey"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "historyKey", - "_1_WAR_portosfeportlet_tab=" + fragmentURL); - - if (successURL.contains(StringPool.POUND)) { - successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, + "codiceFiscaleDelegatoCollaudoEnabled"); + String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, + "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; + boolean inizioLavoriContestualeOpera = ParamUtil.getBoolean(request, "inizioLavoriContestualeOpera"); + long pagamentoId = ParamUtil.getLong(request, "pagamentoId"); + Date dataEffettuazione = ParamUtil.getDate(request, "dataEffettuazione", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataInizioLavoriOpera = ParamUtil.getDate(request, "dataInizioLavoriOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataInizioEsecuzioneOpera = ParamUtil.getDate(request, "dataInizioEsecuzioneOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + Date dataFineEsecuzioneOpera = ParamUtil.getDate(request, "dataFineEsecuzioneOpera", + DateFormatFactoryUtil.getDate(request.getLocale())); + String note = ParamUtil.getString(request, "note"); + String noteUfficio = ParamUtil.getString(request, "noteUfficio"); + // PAGAMENTI + String codicePagamento = ParamUtil.getString(request, "codicePagamento"); + String causalePagamento = ParamUtil.getString(request, "causalePagamento"); + String mezzoPagamento = ParamUtil.getString(request, "mezzoPagamento"); + String importoBolli = ParamUtil.getString(request, "importoBolli"); + String importoSpeseIstruttoria = ParamUtil.getString(request, "importoSpeseIstruttoria"); + boolean pagNuoveCostruzioni = ParamUtil.getBoolean(request, "pagNuoveCostruzioni"); + int pagAdeguamentoSismico = ParamUtil.getInteger(request, "pagAdeguamentoSismico"); + int pagMiglioramentoSismico = ParamUtil.getInteger(request, "pagMiglioramentoSismico"); + boolean pagRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "pagRiparazioneInterventoLocale"); + int pagNuovaCostruzione = ParamUtil.getInteger(request, "pagNuovaCostruzione"); + boolean pagVarianti = ParamUtil.getBoolean(request, "pagVarianti"); + int pagAltro = ParamUtil.getInteger(request, "pagAltro"); + boolean pagMiglioramentoSismicoSicilia = ParamUtil.getBoolean(request, "pagMiglioramentoSismicoSicilia"); + String pagCalcolatoAdeguamentoSismico = ParamUtil.getString(request, "pagCalcolatoAdeguamentoSismico"); + String pagCalcolatoMiglioramentoSismico = ParamUtil.getString(request, "pagCalcolatoMiglioramentoSismico"); + String pagCalcolatoRiparazioneInterventoLocale = ParamUtil.getString(request, + "pagCalcolatoRiparazioneInterventoLocale"); + String pagCalcolatoOperaNonQuantificabile = ParamUtil.getString(request, "pagCalcolatoOperaNonQuantificabile"); + String pagEffettivoAdeguamentoSismico = ParamUtil.getString(request, "pagEffettivoAdeguamentoSismico"); + String pagEffettivoMiglioramentoSismico = ParamUtil.getString(request, "pagEffettivoMiglioramentoSismico"); + String pagEffettivoRiparazioneInterventoLocale = ParamUtil.getString(request, + "pagEffettivoRiparazioneInterventoLocale"); + String pagEffettivoOperaNonQuantificabile = ParamUtil.getString(request, "pagEffettivoOperaNonQuantificabile"); + String pagNoteUtente = ParamUtil.getString(request, "pagNoteUtente"); + // SEZIONE DETTAGLI PRINCIPALI + DettPratica dettCheck = DettPraticaLocalServiceUtil.fetchDettPratica(dettPraticaId); + boolean disabledCollaudoStatico = false; + if (dettCheck != null) { + disabledCollaudoStatico = SoggettiUtil.isCommittenteAndDitta(dettCheck.getIntPraticaId()); + } + boolean collaudoStatico = ParamUtil.getBoolean(request, "collaudoStatico"); + if (disabledCollaudoStatico) { + collaudoStatico = dettCheck.getCollaudoStatico(); + } + boolean lavoriInEconomiaCommittente = ParamUtil.getBoolean(request, "lavoriInEconomiaCommittente"); + String destinazione = ParamUtil.getString(request, "destinazione"); + String ag = ParamUtil.getString(request, "ag"); + String descLongIntervento = ParamUtil.getString(request, "descLongIntervento"); + String estremiCatastali = ParamUtil.getString(request, "estremiCatastali"); + String estremiPratCom = ParamUtil.getString(request, "estremiPratCom"); + String metratura = ParamUtil.getString(request, "metratura"); + boolean lavoriPubblici = ParamUtil.getBoolean(request, "lavoriPubblici"); + int lavoriPubbliciPercentuale = ParamUtil.getInteger(request, "lavoriPubbliciPercentuale"); + String numeroCivico = ParamUtil.getString(request, "numeroCivico"); + String dcFoglio = ParamUtil.getString(request, "dcFoglio"); + String dcAllegato = ParamUtil.getString(request, "dcAllegato"); + String particella1 = ParamUtil.getString(request, "particella1", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella2 = ParamUtil.getString(request, "particella2", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella3 = ParamUtil.getString(request, "particella3", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String particella4 = ParamUtil.getString(request, "particella4", StringPool.BLANK).replaceAll( + Pattern.quote(StringPool.PIPE), StringPool.SPACE); + String dcParticelle = particella1 + StringPool.PIPE + particella2 + StringPool.PIPE + particella3 + + StringPool.PIPE + particella4; + String localizzazioneGeografica = ParamUtil.getString(request, "localizzazioneGeografica"); + boolean tcNuovaCostruzione = ParamUtil.getBoolean(request, "tcNuovaCostruzione"); + boolean tcAdeguamentoSismico = ParamUtil.getBoolean(request, "tcAdeguamentoSismico"); + boolean tcMiglioramentoSismico = ParamUtil.getBoolean(request, "tcMiglioramentoSismico"); + boolean tcRiparazioneInterventoLocale = ParamUtil.getBoolean(request, "tcRiparazioneInterventoLocale"); + boolean tcNuovaCostruzioneComplessa = ParamUtil.getBoolean(request, "tcNuovaCostruzioneComplessa"); + boolean tcInCA = ParamUtil.getBoolean(request, "tcInCA"); + boolean tcInOpera = ParamUtil.getBoolean(request, "tcInOpera"); + boolean tcPrefabbricato = ParamUtil.getBoolean(request, "tcPrefabbricato"); + boolean tcInAcciaio = ParamUtil.getBoolean(request, "tcInAcciaio"); + boolean tcMista = ParamUtil.getBoolean(request, "tcMista"); + boolean tcInMuratura = ParamUtil.getBoolean(request, "tcInMuratura"); + boolean tcInMuraturaOrdinaria = ParamUtil.getBoolean(request, "tcInMuraturaOrdinaria"); + boolean tcInMuraturaArmata = ParamUtil.getBoolean(request, "tcInMuraturaArmata"); + boolean tcInMuraturaMista = ParamUtil.getBoolean(request, "tcInMuraturaMista"); + boolean tcInLegno = ParamUtil.getBoolean(request, "tcInLegno"); + boolean tcAltro = ParamUtil.getBoolean(request, "tcAltro"); + String tcAltroDescrizione = ParamUtil.getString(request, "tcAltroDescrizione"); + boolean tcConDispositivi = ParamUtil.getBoolean(request, "tcConDispositivi"); + // Descrizione edificio + String dePiani = ParamUtil.getString(request, "dePiani"); + String deAltezza = ParamUtil.getString(request, "deAltezza"); + String deInterrati = ParamUtil.getString(request, "deInterrati"); + String deSuperficie = ParamUtil.getString(request, "deSuperficie"); + String deCostruzione = ParamUtil.getString(request, "deCostruzione"); + String deRistrutturazione = ParamUtil.getString(request, "deRistrutturazione"); + String deUso = ParamUtil.getString(request, "deUso"); + String dePrivata = ParamUtil.getString(request, "dePrivata"); + String dePubblica = ParamUtil.getString(request, "dePubblica"); + String deUtilizzazione = ParamUtil.getString(request, "deUtilizzazione"); + String dePosizioneEdificio = ParamUtil.getString(request, "dePosizioneEdificio"); + boolean deInfStradalePonte = ParamUtil.getBoolean(request, "deInfStradalePonte"); + boolean deInfStradaleStrada = ParamUtil.getBoolean(request, "deInfStradaleStrada"); + boolean deInfStradaleAltro = ParamUtil.getBoolean(request, "deInfStradaleAltro"); + boolean deInfIdraulicaLong = ParamUtil.getBoolean(request, "deInfIdraulicaLong"); + boolean deInfIdraulicaTrasv = ParamUtil.getBoolean(request, "deInfIdraulicaTrasv"); + boolean deInfIdraulicaAltro = ParamUtil.getBoolean(request, "deInfIdraulicaAltro"); + boolean deInfOperaAccStradale = ParamUtil.getBoolean(request, "deInfOperaAccStradale"); + boolean deInfOperaAccIdraulica = ParamUtil.getBoolean(request, "deInfOperaAccIdraulica"); + boolean deInfOperaAccAltro = ParamUtil.getBoolean(request, "deInfOperaAccAltro"); + boolean deInfAltraInfrastruttura = ParamUtil.getBoolean(request, "deInfAltraInfrastruttura"); + boolean deInfAltro = ParamUtil.getBoolean(request, "deInfAltro"); + String deInfAltroDesc = ParamUtil.getString(request, "deInfAltroDesc"); + String dccFondazioni = ParamUtil.getString(request, "dccFondazioni"); + boolean dccStruttureEleMuraturePietrame = ParamUtil.getBoolean(request, "dccStruttureEleMuraturePietrame"); + boolean dccStruttureEleMuratureLaterizio = ParamUtil.getBoolean(request, "dccStruttureEleMuratureLaterizio"); + boolean dccStruttureEleMuratureMisto = ParamUtil.getBoolean(request, "dccStruttureEleMuratureMisto"); + boolean dccStruttureEleMuratureStoriche = ParamUtil.getBoolean(request, "dccStruttureEleMuratureStoriche"); + String dccStruttureEleAcciaio = ParamUtil.getString(request, "dccStruttureEleAcciaio"); + String dccStruttureEleCA = ParamUtil.getString(request, "dccStruttureEleCA"); + String dccStruttureEleLegno = ParamUtil.getString(request, "dccStruttureEleLegno"); + boolean dccStruttureEleMistoCA = ParamUtil.getBoolean(request, "dccStruttureEleMistoCA"); + boolean dccStruttureEleMistoAcciaio = ParamUtil.getBoolean(request, "dccStruttureEleMistoAcciaio"); + boolean dccStruttureEleMistoMuratura = ParamUtil.getBoolean(request, "dccStruttureEleMistoMuratura"); + boolean dccStruttureEleMistoLegno = ParamUtil.getBoolean(request, "dccStruttureEleMistoLegno"); + boolean dccStruttureElePrefabbricato = ParamUtil.getBoolean(request, "dccStruttureElePrefabbricato"); + boolean dccStruttureEleAltro = ParamUtil.getBoolean(request, "dccStruttureEleAltro"); + String dccStruttureEleAltroDescrizione = ParamUtil.getString(request, "dccStruttureEleAltroDescrizione"); + boolean dccOrizzontamentiCAAcciaio = ParamUtil.getBoolean(request, "dccOrizzontamentiCAAcciaio"); + boolean dccOrizzontamentiLegno = ParamUtil.getBoolean(request, "dccOrizzontamentiLegno"); + boolean dccOrizzontamentiLegnoCA = ParamUtil.getBoolean(request, "dccOrizzontamentiLegnoCA"); + boolean dccOrizzontamentiLamieraGrecata = ParamUtil.getBoolean(request, "dccOrizzontamentiLamieraGrecata"); + boolean dccOrizzontamentiVolte = ParamUtil.getBoolean(request, "dccOrizzontamentiVolte"); + boolean dccOrizzontamentiAltro = ParamUtil.getBoolean(request, "dccOrizzontamentiAltro"); + String dccOrizzontamentiAltroDescrizione = ParamUtil.getString(request, "dccOrizzontamentiAltroDescrizione"); + String dccCopertura = ParamUtil.getString(request, "dccCopertura"); + boolean dccCoperturaCAAcciaio = ParamUtil.getBoolean(request, "dccCoperturaCAAcciaio"); + boolean dccCoperturaLegno = ParamUtil.getBoolean(request, "dccCoperturaLegno"); + boolean dccCoperturaLegnoCA = ParamUtil.getBoolean(request, "dccCoperturaLegnoCA"); + boolean dccCoperturaLamieraGrecata = ParamUtil.getBoolean(request, "dccCoperturaLamieraGrecata"); + boolean dccCoperturaPannelli = ParamUtil.getBoolean(request, "dccCoperturaPannelli"); + boolean dccCoperturaPVCTelonati = ParamUtil.getBoolean(request, "dccCoperturaPVCTelonati"); + boolean dccCoperturaLeggere = ParamUtil.getBoolean(request, "dccCoperturaLeggere"); + boolean dccCoperturaAltro = ParamUtil.getBoolean(request, "dccCoperturaAltro"); + String dccCoperturaAltroDesrizione = ParamUtil.getString(request, "dccCoperturaAltroDesrizione"); + boolean dccElemNonStrutLaterizio = ParamUtil.getBoolean(request, "dccElemNonStrutLaterizio"); + boolean dccElemNonStrutCartongesso = ParamUtil.getBoolean(request, "dccElemNonStrutCartongesso"); + boolean dccElemNonStrutCalcestruzzo = ParamUtil.getBoolean(request, "dccElemNonStrutCalcestruzzo"); + boolean dccElemNonStrutLegno = ParamUtil.getBoolean(request, "dccElemNonStrutLegno"); + boolean dccElemNonStrutAltro = ParamUtil.getBoolean(request, "dccElemNonStrutAltro"); + String dccElemNonStrutAltroDescrizione = ParamUtil.getString(request, "dccElemNonStrutAltroDescrizione"); + boolean dccOpereDiRinforzoInsCatene = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCatene"); + boolean dccOpereDiRinforzoInsCordoli = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsCordoli"); + boolean dccOpereDiRinforzoIniArmate = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIniArmate"); + boolean dccOpereDiRinforzoPlaccaggi = ParamUtil.getBoolean(request, "dccOpereDiRinforzoPlaccaggi"); + boolean dccOpereDiRinforzoIrrSolai = ParamUtil.getBoolean(request, "dccOpereDiRinforzoIrrSolai"); + boolean dccOpereDiRinforzoRinforziFRP = ParamUtil.getBoolean(request, "dccOpereDiRinforzoRinforziFRP"); + boolean dccOpereDiRinforzoTelaiECerchiature = ParamUtil.getBoolean(request, + "dccOpereDiRinforzoTelaiECerchiature"); + boolean dccOpereDiRinforzoInsRompitratta = ParamUtil.getBoolean(request, "dccOpereDiRinforzoInsRompitratta"); + boolean dccOpereDiRinforzoAltro = ParamUtil.getBoolean(request, "dccOpereDiRinforzoAltro"); + String dccOpereDiRinforzoAltroDescrizione = ParamUtil.getString(request, "dccOpereDiRinforzoAltroDescrizione"); + // DATI geologici + String geoClasseIndagine = getNotNullString(request, "geoClasseIndagine", dettPratica.getGeoClasseIndagine()); + String geoCategoriaSottosuolo = getNotNullString(request, "geoCategoriaSottosuolo", + dettPratica.getGeoCategoriaSottosuolo()); + String geoCategoriaTopografica = getNotNullString(request, "geoCategoriaTopografica", + dettPratica.getGeoCategoriaTopografica()); + String geoConsolidamento = getNotNullString(request, "geoConsolidamento", dettPratica.getGeoConsolidamento()); + String geoPericolositaGeologica = getNotNullString(request, "geoPericolositaGeologica", + dettPratica.getGeoPericolositaGeologica()); + String geoRischioGeomorfologicoPai = getNotNullString(request, "geoRischioGeomorfologicoPai", + dettPratica.getGeoRischioGeomorfologicoPai()); + String geoPericolositaIdraulicaPai = getNotNullString(request, "geoPericolositaIdraulicaPai", + dettPratica.getGeoPericolositaIdraulicaPai()); + String geoRischioIdraulicoPai = getNotNullString(request, "geoRischioIdraulicoPai", + dettPratica.getGeoRischioIdraulicoPai()); + String geoPericolositaSismica = getNotNullString(request, "geoPericolositaSismica", + dettPratica.getGeoPericolositaSismica()); + String geoPericolositaIdraulica = getNotNullString(request, "geoPericolositaIdraulica", + dettPratica.getGeoPericolositaIdraulica()); + String geoPericolositaGeomorfica = getNotNullString(request, "geoPericolositaGeomorfica", + dettPratica.getGeoPericolositaGeomorfica()); + String geoFattibilitaGeologica = getNotNullString(request, "geoFattibilitaGeologica", + dettPratica.getGeoFattibilitaGeologica()); + String geoFattibilitaSismica = getNotNullString(request, "geoFattibilitaSismica", + dettPratica.getGeoFattibilitaSismica()); + String geoFattibilitaIdraulica = getNotNullString(request, "geoFattibilitaIdraulica", + dettPratica.getGeoFattibilitaIdraulica()); + String geoOperaRilevante = getNotNullString(request, "geoOperaRilevante", dettPratica.getGeoOperaRilevante()); + String geoOpereDiSostegno = getNotNullString(request, "geoOpereDiSostegno", dettPratica.getGeoOpereDiSostegno()); + String geoOpereInSotterranea = getNotNullString(request, "geoOpereInSotterranea", + dettPratica.getGeoOpereInSotterranea()); + String geoPresenzaPrescrizioni = getNotNullString(request, "geoPresenzaPrescrizioni", + dettPratica.getGeoPresenzaPrescrizioni()); + String geoNotePrescrizioni = getNotNullString(request, "geoNotePrescrizioni", + dettPratica.getGeoNotePrescrizioni()); + String geoNoteIndagini = getNotNullString(request, "geoNoteIndagini", dettPratica.getGeoNoteIndagini()); + String geoEvidenzeGeomorfiche = getNotNullString(request, "geoEvidenzeGeomorfiche", + dettPratica.getGeoEvidenzeGeomorfiche()); + String geoEvidenzeGeologiche = getNotNullString(request, "geoEvidenzeGeologiche", + dettPratica.getGeoEvidenzeGeologiche()); + Date geoDtRelazione = getNotNullDate(request, "geoDtRelazione", dettPratica.getGeoDtRelazione()); + // normative + boolean normLavoriInProprio = ParamUtil.getBoolean(request, "normLavoriInProprio"); + boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); + boolean normEsenteSpese = ParamUtil.getBoolean(request, "normEsenteSpese"); + boolean normDpr01Dep = ParamUtil.getBoolean(request, "normDpr01Dep"); + boolean normDpr02Dep = ParamUtil.getBoolean(request, "normDpr02Dep"); + boolean normDpr01Aut = ParamUtil.getBoolean(request, "normDpr01Aut"); + boolean normDpr02Aut = ParamUtil.getBoolean(request, "normDpr02Aut"); + boolean normDm01 = ParamUtil.getBoolean(request, "normDm01"); + boolean normDm02 = ParamUtil.getBoolean(request, "normDm02"); + boolean normDm03 = ParamUtil.getBoolean(request, "normDm03"); + boolean normDm2018 = ParamUtil.getBoolean(request, "normDm2018"); + boolean normDprg01 = ParamUtil.getBoolean(request, "normDprg01"); + boolean normDprg02 = ParamUtil.getBoolean(request, "normDprg02"); + boolean normAnr = ParamUtil.getBoolean(request, "normAnr"); + boolean normArt3com3 = ParamUtil.getBoolean(request, "normArt3com3"); + boolean normArt3com4 = ParamUtil.getBoolean(request, "normArt3com4"); + boolean normOrd01 = ParamUtil.getBoolean(request, "normOrd01"); + boolean normDm04 = ParamUtil.getBoolean(request, "normDm04"); + boolean normDm05 = ParamUtil.getBoolean(request, "normDm05"); + boolean normCI01 = ParamUtil.getBoolean(request, "normCI01"); + boolean normLTC01 = ParamUtil.getBoolean(request, "normLTC01"); + boolean suap = ParamUtil.getBoolean(request, "suap"); + boolean normSismaBonus = ParamUtil.getBoolean(request, "normSismaBonus"); + String clRischioPreInt = ParamUtil.getString(request, "clRischioPreInt"); + String clRischioPostInt = ParamUtil.getString(request, "clRischioPostInt"); + boolean intervFinPub = ParamUtil.getBoolean(request, "intervFinPub"); + String intervFinPubDesc = intervFinPub ? ParamUtil.getString(request, "intervFinPubDesc") : StringPool.BLANK; + + String contestoPaesaggistico = ParamUtil.getString(request, "contestoPaesaggistico"); + String livelloDiTutela = ParamUtil.getString(request, "livelloDiTutela"); + String vincoli = ParamUtil.getString(request, "vincoli"); + + long userId = PortalUtil.getUserId(request); + String via = dettPratica.getVia(); + String localita = dettPratica.getLocalita(); + if (!ParamUtil.getString(request, "via").equals(StringPool.BLANK)) { + via = ParamUtil.getString(request, "via"); + } + if (!ParamUtil.getString(request, "localita").equals(StringPool.BLANK)) { + localita = ParamUtil.getString(request, "localita"); + } + IntPratica intPratica = IntPraticaLocalServiceUtil.getIntPratica(dettPratica.getIntPraticaId()); + if(intPratica.isPraticaOspedaliera()){ + destinazione = dettPratica.getDestinazione(); + normEsenteBollo = dettPratica.getNormEsenteBollo(); + normEsenteSpese = dettPratica.getNormEsenteSpese(); + lavoriPubblici = dettPratica.getLavoriPubblici(); + } + try { + DettPraticaServiceUtil.updateDettPratica(userId, dettPratica.getDettPraticaId(), + dettPratica.getIntPraticaId(), dettPratica.getIntegrazione(), protocollo, tipoIntegrazione, + dettPratica.getCompleta(), dettPratica.getGestita(), codicePagamento, causalePagamento, + mezzoPagamento, importoBolli, importoSpeseIstruttoria, dataEffettuazione, + dettPratica.getStatusTask(), dettPratica.getWorkflowForzato(), + dettPratica.getSoggettoSostituitoId(), destinazione, ag, descLongIntervento, via, localita, + estremiCatastali, estremiPratCom, dettPratica.getVariataDa(), dettPratica.getVarianteNumero(), + varianteSostanziale, dettPratica.getOperaConforme(), collaudoStatico, + codiceFiscaleDelegatoCommittente, codiceFiscaleDelegatoFineLavori, codiceFiscaleDelegatoCollaudo, + dettPratica.getCodiceRuoloDelegato(), lavoriInEconomiaCommittente, inizioLavoriContestualeOpera, + dataInizioLavoriOpera, dataInizioEsecuzioneOpera, dataFineEsecuzioneOpera, metratura, + lavoriPubblici, pagamentoId, lavoriPubbliciPercentuale, numeroCivico, dcParticelle, dcFoglio, + dcAllegato, dePiani, deAltezza, deInterrati, deSuperficie, deCostruzione, deRistrutturazione, + deUso, dePubblica, dePrivata, deUtilizzazione, dePosizioneEdificio, deInfStradalePonte, + deInfStradaleStrada, deInfStradaleAltro, deInfIdraulicaLong, deInfIdraulicaTrasv, + deInfIdraulicaAltro, deInfOperaAccStradale, deInfOperaAccIdraulica, deInfOperaAccAltro, + deInfAltraInfrastruttura, deInfAltro, deInfAltroDesc, dccFondazioni, + dccStruttureEleMuraturePietrame, dccStruttureEleMuratureLaterizio, dccStruttureEleMuratureMisto, + dccStruttureEleMuratureStoriche, dccStruttureEleAcciaio, dccStruttureEleCA, dccStruttureEleLegno, + dccStruttureEleMistoCA, dccStruttureEleMistoAcciaio, dccStruttureEleMistoMuratura, + dccStruttureEleMistoLegno, dccStruttureElePrefabbricato, dccStruttureEleAltro, + dccStruttureEleAltroDescrizione, dccOrizzontamentiCAAcciaio, dccOrizzontamentiLegno, + dccOrizzontamentiLegnoCA, dccOrizzontamentiLamieraGrecata, dccOrizzontamentiVolte, + dccOrizzontamentiAltro, dccOrizzontamentiAltroDescrizione, dccCopertura, dccCoperturaCAAcciaio, + dccCoperturaLegno, dccCoperturaLegnoCA, dccCoperturaLamieraGrecata, dccCoperturaPannelli, + dccCoperturaPVCTelonati, dccCoperturaLeggere, dccCoperturaAltro, dccCoperturaAltroDesrizione, + dccElemNonStrutLaterizio, dccElemNonStrutCartongesso, dccElemNonStrutCalcestruzzo, + dccElemNonStrutLegno, dccElemNonStrutAltro, dccElemNonStrutAltroDescrizione, + dccOpereDiRinforzoInsCatene, dccOpereDiRinforzoInsCordoli, dccOpereDiRinforzoIniArmate, + dccOpereDiRinforzoPlaccaggi, dccOpereDiRinforzoIrrSolai, dccOpereDiRinforzoRinforziFRP, + dccOpereDiRinforzoTelaiECerchiature, dccOpereDiRinforzoInsRompitratta, dccOpereDiRinforzoAltro, + dccOpereDiRinforzoAltroDescrizione, geoClasseIndagine, geoCategoriaSottosuolo, + geoCategoriaTopografica, geoConsolidamento, geoPericolositaGeologica, geoRischioGeomorfologicoPai, + geoPericolositaIdraulicaPai, geoRischioIdraulicoPai, geoPericolositaSismica, + geoPericolositaIdraulica, geoPericolositaGeomorfica, geoFattibilitaGeologica, + geoFattibilitaSismica, geoFattibilitaIdraulica, geoOperaRilevante, geoOpereDiSostegno, + geoOpereInSotterranea, geoPresenzaPrescrizioni, geoNotePrescrizioni, geoNoteIndagini, + geoEvidenzeGeomorfiche, geoEvidenzeGeologiche, geoDtRelazione, pagNuoveCostruzioni, + pagAdeguamentoSismico, pagMiglioramentoSismico, pagRiparazioneInterventoLocale, + pagNuovaCostruzione, pagVarianti, pagAltro, pagMiglioramentoSismicoSicilia, + pagCalcolatoAdeguamentoSismico, pagCalcolatoMiglioramentoSismico, + pagCalcolatoRiparazioneInterventoLocale, pagCalcolatoOperaNonQuantificabile, + pagEffettivoAdeguamentoSismico, pagEffettivoMiglioramentoSismico, + pagEffettivoRiparazioneInterventoLocale, pagEffettivoOperaNonQuantificabile, pagNoteUtente, note, + noteUfficio, localizzazioneGeografica, tcNuovaCostruzione, tcAdeguamentoSismico, + tcMiglioramentoSismico, tcRiparazioneInterventoLocale, tcInCA, tcInOpera, tcPrefabbricato, + tcInAcciaio, tcMista, tcInMuratura, tcInMuraturaOrdinaria, tcInMuraturaArmata, tcInMuraturaMista, + tcInLegno, tcAltro, tcAltroDescrizione, tcConDispositivi, normLavoriInProprio, normEsenteBollo, + normEsenteSpese, normDpr01Dep, normDpr02Dep, normDpr01Aut, normDpr02Aut, normDm01, normDm02, + normDm03, normDm2018, normDprg01, normDprg02, normAnr, normArt3com3, normArt3com4, normOrd01, + normDm04, normDm05, normCI01, normLTC01, suap, normSismaBonus, clRischioPreInt, clRischioPostInt, + intervFinPub, intervFinPubDesc, tcNuovaCostruzioneComplessa, contestoPaesaggistico, + livelloDiTutela, vincoli, serviceContext, bozza, disabledSubmit, geoDisabledSubmit); + String redirect = ParamUtil.getString(request, "redirect"); + if (Validator.isNull(redirect)) { + String successURL = ParamUtil.getString(request, "successURL"); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "isNewVariante"); + if (Validator.isNotNull(successURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", + String.valueOf(!bozza)); + String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", + String.valueOf(verifyArea)); + String fragmentURL = ParamUtil.getString(request, "current_tab"); + if (Validator.isNotNull(fragmentURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "current_tab"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "current_tab", + fragmentURL); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "historyKey"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "historyKey", + "_1_WAR_portosfeportlet_tab=" + fragmentURL); + + if (successURL.contains(StringPool.POUND)) { + successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + } + successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; + } + response.sendRedirect(successURL); + } else { + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); + response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); + response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); + response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); } - successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; } - response.sendRedirect(successURL); - } else { + } catch (PortalException e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); - response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); - response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); - response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); + throw e; + } catch (Exception e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + throw new PortalException(e); } - } - } catch (PortalException e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw e; - } catch (Exception e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw new PortalException(e); - } } private void saveVariazioneSoggetti(long dettPraticaId, ActionRequest request, ActionResponse response) @@ -1717,53 +1756,53 @@ public class FascicoloFePortlet extends MVCPortlet { "codiceFiscaleDelegatoFineLavoriEnabled"); String codiceFiscaleDelegatoFineLavori = isCodiceFiscaleDelegatoFineLavoriAuthorized ? ParamUtil.getString( request, "codiceFiscaleDelegatoFineLavori") : StringPool.BLANK; - boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, - "codiceFiscaleDelegatoCollaudoEnabled"); - String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, - "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; - long userId = PortalUtil.getUserId(request); - try { - DettPratica dettPratica = DettPraticaServiceUtil.getDettPratica(dettPraticaId); - - DettPraticaServiceUtil.updateDettPraticaSoggetti(userId, dettPratica.getDettPraticaId(), - dettPratica.getIntPraticaId(), codiceFiscaleDelegatoCommittente, codiceFiscaleDelegatoFineLavori, - codiceFiscaleDelegatoCollaudo, serviceContext); - String redirect = ParamUtil.getString(request, "redirect"); - if (Validator.isNull(redirect)) { - String successURL = ParamUtil.getString(request, "successURL"); - if (Validator.isNotNull(successURL)) { - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); - successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", - String.valueOf(!bozza)); - String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); - successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", - String.valueOf(verifyArea)); - String fragmentURL = "_1_WAR_portosfeportlet_page_soggetti"; - if (successURL.contains(StringPool.POUND)) { - successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + boolean isCodiceFiscaleDelegatoCollaudoAuthorized = ParamUtil.getBoolean(request, + "codiceFiscaleDelegatoCollaudoEnabled"); + String codiceFiscaleDelegatoCollaudo = isCodiceFiscaleDelegatoCollaudoAuthorized ? ParamUtil.getString(request, + "codiceFiscaleDelegatoCollaudo") : StringPool.BLANK; + long userId = PortalUtil.getUserId(request); + try { + DettPratica dettPratica = DettPraticaServiceUtil.getDettPratica(dettPraticaId); + + DettPraticaServiceUtil.updateDettPraticaSoggetti(userId, dettPratica.getDettPraticaId(), + dettPratica.getIntPraticaId(), codiceFiscaleDelegatoCommittente, codiceFiscaleDelegatoFineLavori, + codiceFiscaleDelegatoCollaudo, serviceContext); + String redirect = ParamUtil.getString(request, "redirect"); + if (Validator.isNull(redirect)) { + String successURL = ParamUtil.getString(request, "successURL"); + if (Validator.isNotNull(successURL)) { + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "openVerifyUrl"); + successURL = HttpUtil.removeParameter(successURL, response.getNamespace() + "verifyArea"); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "openVerifyUrl", + String.valueOf(!bozza)); + String verifyArea = ParamUtil.getString(request, "verifyArea", StringPool.BLANK); + successURL = HttpUtil.addParameter(successURL, response.getNamespace() + "verifyArea", + String.valueOf(verifyArea)); + String fragmentURL = "_1_WAR_portosfeportlet_page_soggetti"; + if (successURL.contains(StringPool.POUND)) { + successURL = successURL.substring(0, successURL.lastIndexOf(StringPool.POUND)); + } + successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; + response.sendRedirect(successURL); + } else { + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); + response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); + response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); + response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); + } } - successURL += "#_1_WAR_portosfeportlet_tab=" + fragmentURL; - response.sendRedirect(successURL); - } else { + } catch (PortalException e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); + response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); + throw e; + } catch (Exception e) { + _log.error(e, e); + PortalUtil.copyRequestParameters(request, response); response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - response.setRenderParameter("backURL", ParamUtil.getString(request, "backURL")); - response.setRenderParameter("dettPraticaId", String.valueOf(dettPratica.getDettPraticaId())); - response.setRenderParameter("intPraticaId", String.valueOf(dettPratica.getIntPraticaId())); - response.setRenderParameter("openVerifyUrl", String.valueOf(!bozza)); + throw new PortalException(e); } - } - } catch (PortalException e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw e; - } catch (Exception e) { - _log.error(e, e); - PortalUtil.copyRequestParameters(request, response); - response.setRenderParameter("mvcPath", "/html/fascicolofe/edit_fascicolo.jsp"); - throw new PortalException(e); - } } public void deleteFascicolo(ActionRequest request, ActionResponse response) throws Exception { @@ -1779,7 +1818,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void richiediAsseverazioni(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); @@ -1791,7 +1830,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void annullaAsseverazione(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long asseverazioneId = ParamUtil.getLong(request, "asseverazioneId"); @@ -1804,7 +1843,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void rimuoviFileAsseverazione(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long asseverazioneId = ParamUtil.getLong(request, "asseverazioneId"); @@ -1816,7 +1855,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void allegatoFileAnnullamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { try { UploadPortletRequest uploadRequest = PortalUtil.getUploadPortletRequest(request); @@ -1876,7 +1915,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void generaFirmaAnnullamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { try { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); @@ -1897,7 +1936,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void allegatoFileAsseverazione(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { String dettagliFirme = StringPool.BLANK; try { @@ -1956,7 +1995,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void deleteFileAnnullamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { long fileAnnulamentoId = ParamUtil.getLong(request, "docPraticaAnnullamentoId"); if (Validator.isNotNull(fileAnnulamentoId)) { @@ -1965,7 +2004,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void confermaAsseverazione(ActionRequest request, ActionResponse response) throws IOException, - PortalException, SystemException { + PortalException, SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long asseverazioneId = ParamUtil.getLong(request, "asseverazioneId"); @@ -1977,7 +2016,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void annullaAsseverazioni(ActionRequest request, ActionResponse response) throws IOException, - PortalException, SystemException { + PortalException, SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); @@ -1989,7 +2028,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void updateFormPagamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); boolean normEsenteBollo = ParamUtil.getBoolean(request, "normEsenteBollo"); @@ -2164,7 +2203,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void salvaStampaPratica(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { long intPraticaId = ParamUtil.getLong(request, "intPraticaId"); IntPratica intPratica = IntPraticaLocalServiceUtil.getIntPratica(intPraticaId); @@ -2182,7 +2221,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void invioMailAsseverazione(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { try { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); @@ -2223,7 +2262,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void allegatoFilePagamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { try { UploadPortletRequest uploadRequest = PortalUtil.getUploadPortletRequest(request); @@ -2259,7 +2298,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void completeDomandaEsente(ActionRequest request, ActionResponse response) throws IOException, - PortalException, SystemException { + PortalException, SystemException { long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); long fineLavoriId = ParamUtil.getLong(request, "fineLavoriId"); @@ -2276,7 +2315,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void completeIntegrazione(ActionRequest request, ActionResponse response) throws IOException, - PortalException, SystemException { + PortalException, SystemException { long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); if (Validator.isNotNull(dettPraticaId)) { @@ -2287,7 +2326,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void completeCambioSoggetti(ActionRequest request, ActionResponse response) throws IOException, - PortalException, SystemException { + PortalException, SystemException { long dettPraticaId = ParamUtil.getLong(request, "dettPraticaId"); if (Validator.isNotNull(dettPraticaId)) { @@ -2298,7 +2337,7 @@ public class FascicoloFePortlet extends MVCPortlet { } public void completeAnnullamento(ActionRequest request, ActionResponse response) throws PortalException, - SystemException { + SystemException { ServiceContext serviceContext = ServiceContextFactory.getInstance(request); long intPraticaId = ParamUtil.getLong(request, "intPraticaId"); diff --git a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/html/fascicolofe/navigator/domanda/page_dettagli_principali.jsp b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/html/fascicolofe/navigator/domanda/page_dettagli_principali.jsp index 65c9b938..f010b170 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/html/fascicolofe/navigator/domanda/page_dettagli_principali.jsp +++ b/liferay-plugins-sdk-6.2/portlets/portos-fe-portlet/docroot/html/fascicolofe/navigator/domanda/page_dettagli_principali.jsp @@ -727,11 +727,16 @@ function duplicati(input) {

    • - -
    • -     + <% + String tcRiparazioneInterventoLocalClass = ""; + if(!isPraticaOspedaliera){ + tcRiparazioneInterventoLocalClass = "hide"; + } + %> +
    • diff --git a/liferay-plugins-sdk-6.2/portlets/portos-firma-portlet/.settings/org.eclipse.wst.common.component b/liferay-plugins-sdk-6.2/portlets/portos-firma-portlet/.settings/org.eclipse.wst.common.component index 9fda3447..7a047eaa 100644 --- a/liferay-plugins-sdk-6.2/portlets/portos-firma-portlet/.settings/org.eclipse.wst.common.component +++ b/liferay-plugins-sdk-6.2/portlets/portos-firma-portlet/.settings/org.eclipse.wst.common.component @@ -2,6 +2,9 @@ + + uses +