def mutate(cls, root, info, **input):
_procedura_vas = ProceduraAdozioneVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
_procedura_adozione = ProceduraAdozione.objects.get(piano=_piano)
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
if not _procedura_adozione.pubblicazione_burt_data:
return GraphQLError("Errore - burtdata mancante", code=500)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user)
check_and_promote(_piano, info)
return UploadElaboratiAdozioneVAS(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_approvazione = ProceduraApprovazione.objects.get(
uuid=input['uuid'])
_piano = _procedura_approvazione.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano,
QualificaRichiesta.REGIONE):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_approvazione,
info.context.user)
check_and_promote(_piano, info)
return AttribuzioneConformitaPIT(
approvazione_aggiornata=_procedura_approvazione, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_piano = _procedura_avvio.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.GC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
# check risorsa
if not _piano.risorse\
.filter(tipo=TipoRisorsa.DOCUMENTO_GENIO_CIVILE.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("Risorsa mancante: {}".format(
TipoRisorsa.DOCUMENTO_GENIO_CIVILE.value),
code=409)
try:
closed = cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_avvio,
info.context.user)
if closed:
check_and_promote(_piano, info)
return InvioProtocolloGenioCivile(
avvio_aggiornato=_procedura_avvio, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def check_join_pubblicazione_provvedimento(info, piano: Piano):
pp_ap = piano.getFirstAction(
TipologiaAzione.pubblicazione_provvedimento_verifica_ap)
pp_ac = piano.getFirstAction(
TipologiaAzione.pubblicazione_provvedimento_verifica_ac)
if is_executed(pp_ap) and is_executed(pp_ac):
_vas: ProceduraVAS = piano.procedura_vas
if not _vas.assoggettamento:
_vas.conclusa = True
_vas.save()
if try_and_close_avvio(piano):
check_and_promote(piano, info)
else:
if _vas.tipologia == TipologiaVAS.PROCEDIMENTO_SEMPLIFICATO:
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.redazione_documenti_vas,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
else:
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.invio_doc_preliminare,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
def crea_azione_post_cartografica(piano: Piano, tipologia: TipologiaAzione):
if tipologia == TipologiaAzione.validazione_cartografia_adozione:
utils.crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.pubblicazione_burt,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA,
))
elif tipologia == TipologiaAzione.validazione_cartografia_controdedotta:
procedura_adozione = piano.procedura_adozione
if procedura_adozione.richiesta_conferenza_paesaggistica:
utils.crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.esito_conferenza_paesaggistica,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA))
else:
if piano_mutations.try_and_close_adozione(piano):
piano_mutations.check_and_promote(piano)
elif tipologia == TipologiaAzione.validazione_cartografia_cp_adozione:
if piano_mutations.try_and_close_adozione(piano):
piano_mutations.check_and_promote(piano)
elif tipologia == TipologiaAzione.validazione_cartografia_approvazione:
if not piano.procedura_adozione.richiesta_conferenza_paesaggistica:
# Se non è stata fatta prima, va fatta ora...
utils.crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.
esito_conferenza_paesaggistica_ap,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA))
procedura_approvazione = piano.procedura_approvazione
procedura_approvazione.richiesta_conferenza_paesaggistica = True
procedura_approvazione.save()
else:
utils.crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.pubblicazione_approvazione,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
elif tipologia == TipologiaAzione.validazione_cartografia_cp_approvazione:
utils.crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.pubblicazione_approvazione,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
else:
raise Exception(
'Tipologia azione cartografica inaspettata [{}]'.format(tipologia))
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
errs = []
for tipo in [
TipoRisorsa.RAPPORTO_AMBIENTALE,
TipoRisorsa.SINTESI_NON_TECNICA
]:
if not _procedura_vas.risorse\
.filter(tipo=tipo.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File mancante: {}".format(tipo.value),
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
if try_and_close_avvio(_piano):
check_and_promote(_piano, info) # check for auto promotion
return RedazioneDocumentiVAS(vas_aggiornata=_procedura_vas,
errors=errs)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_vas = ProceduraVAS.objects.get(piano=_piano)
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
check_and_promote(_piano, info)
return FormazionePiano(piano_aggiornato=_piano, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)