def try_and_close_adozione(piano: Piano):
logger.warning('check_and_close_adozione')
procedura_adozione: ProceduraAdozione = piano.procedura_adozione
if not procedura_adozione.conclusa:
piano_controdedotto = piano.getFirstAction(
TipologiaAzione.piano_controdedotto)
rev_piano_post_cp = piano.getFirstAction(
TipologiaAzione.rev_piano_post_cp)
_procedura_adozione_vas = ProceduraAdozioneVAS.objects.filter(
piano=piano).last()
if is_executed(piano_controdedotto) \
and (not procedura_adozione.richiesta_conferenza_paesaggistica or is_executed(rev_piano_post_cp)) \
and (not _procedura_adozione_vas or _procedura_adozione_vas.conclusa):
logger.warning('CHIUSURA FASE ADOZIONE')
chiudi_pendenti(piano, attesa=True, necessaria=False)
procedura_adozione.conclusa = True
procedura_adozione.save()
procedura_approvazione, created = ProceduraApprovazione.objects.get_or_create(
piano=piano)
piano.procedura_approvazione = procedura_approvazione
piano.save()
return True
return False
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 check_join_redazione_documenti_vas(user, piano: Piano):
tp_sca = piano.getFirstAction(TipologiaAzione.trasmissione_pareri_sca)
tp_ac = piano.getFirstAction(TipologiaAzione.trasmissione_pareri_ac)
if is_executed(tp_sca) and is_executed(tp_ac):
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.redazione_documenti_vas,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
return True
return False
def try_and_close_avvio(piano: Piano):
procedura_avvio: ProceduraAvvio = piano.procedura_avvio
procedura_vas: ProceduraVAS = piano.procedura_vas
_conferenza_copianificazione_attiva = \
needs_execution(piano.getFirstAction(TipologiaAzione.richiesta_conferenza_copianificazione)) or \
needs_execution(piano.getFirstAction(TipologiaAzione.esito_conferenza_copianificazione))
_richiesta_integrazioni = piano.getFirstAction(
TipologiaAzione.richiesta_integrazioni)
_integrazioni_richieste = piano.getFirstAction(
TipologiaAzione.integrazioni_richieste)
_protocollo_genio_civile = piano.getFirstAction(
TipologiaAzione.protocollo_genio_civile)
_formazione_del_piano = piano.getFirstAction(
TipologiaAzione.formazione_del_piano)
if not _conferenza_copianificazione_attiva and \
is_executed(_protocollo_genio_civile) and \
is_executed(_formazione_del_piano) and \
(not procedura_avvio.richiesta_integrazioni or (is_executed(_integrazioni_richieste))) and \
(not procedura_vas or procedura_vas.conclusa or procedura_vas.tipologia == TipologiaVAS.NON_NECESSARIA):
if procedura_vas and procedura_vas.conclusa:
chiudi_pendenti(piano, attesa=True, necessaria=False)
procedura_avvio.conclusa = True
procedura_avvio.save()
PianoControdedotto.objects.get_or_create(piano=piano)
PianoRevPostCP.objects.get_or_create(piano=piano)
procedura_adozione, created = ProceduraAdozione.objects.get_or_create(
piano=piano)
piano.procedura_adozione = procedura_adozione
piano.save()
return True
return False
def is_eligible_for_promotion(piano:Piano):
logger.warning("Is eligible for promotion {p} {f}".format(p=piano, f=piano.fase))
msg = []
load_pending_alerts(piano, msg)
if piano.fase == Fase.DRAFT:
# rules.add_rule('strt_core.api.fase_anagrafica_completa',
# ~has_pending_alerts &
# is_draft &
# has_data_delibera &
# has_description &
# has_delibera_comunale &
# has_soggetto_proponente &
# has_procedura_vas &
# vas_rules.procedura_vas_is_valid
# load_pending_alerts(piano, msg)
# if not is_draft(piano):
# msg.append("Piano non in stato di bozza")
if piano.data_delibera is None:
msg.append("Data delibera non impostata")
if piano.descrizione is None:
msg.append("Descrizione non impostata")
if not has_delibera_comunale(piano):
msg.append("Delibera comunale mancante")
if piano.soggetto_proponente is None:
msg.append("Soggetto proponente mancante")
if not ProceduraVAS.objects.filter(piano=piano).exists():
msg.append("Procedura VAS mancante")
vas_ok, vas_msg = auth_vas.procedura_vas_is_valid(piano)
if not vas_ok:
msg = msg + vas_msg
return len(msg) == 0, msg
elif piano.fase == Fase.ANAGRAFICA:
# rules.add_rule('strt_core.api.fase_avvio_completa',
# ~has_pending_alerts &
# is_anagrafica &
# protocollo_genio_inviato &
# formazione_piano_conclusa &
# has_procedura_avvio &
# avvio_piano_conclusa &
# (~has_procedura_vas | vas_piano_conclusa)
# )
# if has_pending_alerts(piano):
# msg.append("Ci sono azioni non ancora completate")
if not is_executed(piano.getFirstAction(TipologiaAzione.protocollo_genio_civile)):
msg.append("Protocollo Genio Civile mancante")
if not formazione_piano_conclusa(piano):
msg.append("Formazione piano non conclusa")
if not ProceduraAvvio.objects.filter(piano=piano).exists():
msg.append("Procedura di avvio mancante")
if not avvio_piano_conclusa(piano):
msg.append("Procedura di avvio non conclusa")
if not vas_piano_conclusa(piano):
msg.append("Procedura VAS non conclusa")
return len(msg) == 0, msg
elif piano.fase == Fase.AVVIO:
# rules.add_rule(
# 'strt_core.api.fase_adozione_completa',
# ~has_pending_alerts &
# is_avvio &
# has_procedura_adozione &
# adozione_piano_conclusa &
# (~has_procedura_adozione_vas | adozione_vas_piano_conclusa)
# )
# if has_pending_alerts(piano):
# msg.append("Ci sono azioni non ancora completate")
_procedura_adozione = ProceduraAdozione.objects.filter(piano=piano).first()
if not _procedura_adozione:
msg.append("Procedura di adozione mancante")
if not _procedura_adozione.conclusa:
msg.append("Procedura di adozione non conclusa")
_procedura_adozione_vas = ProceduraAdozioneVAS.objects.filter(piano=piano).first()
if _procedura_adozione_vas and not _procedura_adozione_vas.conclusa:
msg.append("Procedura AdozioneVAS non conclusa")
return len(msg) == 0, msg
elif piano.fase == Fase.ADOZIONE:
# rules.add_rule(
# 'strt_core.api.fase_approvazione_completa',
# ~has_pending_alerts &
# is_adozione &
# has_procedura_approvazione &
# approvazione_piano_conclusa
# )
_procedura_approvazione = ProceduraApprovazione.objects.filter(piano=piano).first()
if not _procedura_approvazione:
msg.append("Procedura di approvazione mancante")
if not _procedura_approvazione.conclusa:
msg.append("Procedura di approvazione non conclusa")
return len(msg) == 0, msg
else:
raise Exception('Fase non riconosciute [{}]'.format(piano.fase))
def formazione_piano_conclusa(piano):
az = piano.getFirstAction(TipologiaAzione.formazione_del_piano)
return az and is_executed(az)
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_avvio_procedimento = piano.getFirstAction(
TipologiaAzione.avvio_procedimento)
_contributi_tecnici = piano.getFirstAction(
TipologiaAzione.contributi_tecnici)
if is_executed(_avvio_procedimento) and needs_execution(
_contributi_tecnici):
chiudi_azione(_contributi_tecnici)
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.formazione_del_piano,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
if procedura_avvio.conferenza_copianificazione == TipologiaCopianificazione.NECESSARIA:
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc, created = ConferenzaCopianificazione.objects.get_or_create(
piano=piano)
_cc.data_richiesta_conferenza = get_now()
_cc.data_scadenza_risposta = procedura_avvio.data_scadenza_risposta
_cc.save()
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.richiesta_integrazioni,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA))
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.
esito_conferenza_copianificazione,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA))
elif procedura_avvio.conferenza_copianificazione == TipologiaCopianificazione.POSTICIPATA:
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc, created = ConferenzaCopianificazione.objects.get_or_create(
piano=piano)
_cc.data_scadenza_risposta = procedura_avvio.data_scadenza_risposta
_cc.save()
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.
richiesta_conferenza_copianificazione,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA))
elif procedura_avvio.conferenza_copianificazione == TipologiaCopianificazione.NON_NECESSARIA:
procedura_avvio.notifica_genio_civile = True
procedura_avvio.save()
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.protocollo_genio_civile,
qualifica_richiesta=QualificaRichiesta.GC,
stato=StatoAzione.NECESSARIA))
def mutate_and_get_payload(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_procedura_vas_data = input.get('procedura_vas')
_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)
_ente = _piano.ente
try:
# These fields cannot be changed
for field in ['piano', 'uuid', 'data_creazione', 'ente']:
if 'field' in _procedura_vas_data:
logger.warning(
'Il campo "{}" non può essere modificato attraverso questa operazione'
.format(field))
_procedura_vas_data.pop(field)
# These fields can be changed by the RESP only
# Tipologia (O)
if 'tipologia' in _procedura_vas_data:
_tipologia = _procedura_vas_data.pop('tipologia')
if auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
if _tipologia: # and _tipologia in TipologiaVAS:
_tipo_parsed = TipologiaVAS.fix_enum(
_tipologia, none_on_error=True)
if not _tipo_parsed:
return GraphQLError(
"Tipologia non riconosciuta [{}]".format(
_tipologia),
code=400)
_procedura_vas_data['tipologia'] = _tipo_parsed
else:
logger.info(
'Non si hanno i privilegi per modificare il campo "tipologia"'
)
# Note (O)
if 'note' in _procedura_vas_data:
_data = _procedura_vas_data.pop('note')
if auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
_procedura_vas.note = _data[0]
else:
logger.info(
'Non si hanno i privilegi per modificare il campo "note"'
)
# perform check before update
if _procedura_vas_data.pubblicazione_provvedimento_verifica_ap:
if not auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Non è permesso modificare un campo AP",
code=403)
if is_executed(
_piano.getFirstAction(
TipologiaAzione.
pubblicazione_provvedimento_verifica_ap)):
return GraphQLError(
"Il campo pubblicazione provvedimento è bloccato ",
code=403)
# perform check before update
if _procedura_vas_data.pubblicazione_provvedimento_verifica_ac:
if not auth.can_edit_piano(info.context.user, _piano,
Qualifica.AC):
return GraphQLError(
"Forbidden - Non è permesso modificare un campo AC",
code=403)
if is_executed(
_piano.getFirstAction(
TipologiaAzione.
pubblicazione_provvedimento_verifica_ac)):
return GraphQLError(
"Il campo pubblicazione provvedimento è bloccato ",
code=403)
# update!
procedura_vas_aggiornata = update_create_instance(
_procedura_vas, _procedura_vas_data)
return cls(procedura_vas_aggiornata=procedura_vas_aggiornata)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)