def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_epv = piano.getFirstAction(
TipologiaAzione.emissione_provvedimento_verifica)
if needs_execution(_epv):
now = get_now()
chiudi_azione(_epv, now)
procedura_vas.data_assoggettamento = now
procedura_vas.verifica_effettuata = True
procedura_vas.save()
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.
pubblicazione_provvedimento_verifica_ac,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.NECESSARIA,
))
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.
pubblicazione_provvedimento_verifica_ap,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA,
))
def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
if procedura_vas.tipologia == TipologiaVAS.VERIFICA:
exp = TipoExpire.EMISSIONE_PV_VERIFICA
elif procedura_vas.tipologia == TipologiaVAS.PROCEDIMENTO_SEMPLIFICATO:
exp = TipoExpire.EMISSIONE_PV_PROCEDIMENTOSEMPLIFICATO
else:
raise GraphQLError("Tipo procedura VAS inaspettata: {}".format(
procedura_vas.tipologia),
code=403)
_pareri_verifica_vas = piano.getFirstAction(
TipologiaAzione.pareri_verifica_sca)
if needs_execution(_pareri_verifica_vas):
chiudi_azione(_pareri_verifica_vas)
_azione_start_vas = piano.getFirstAction(
TipologiaAzione.selezione_tipologia_vas)
_data_start_vas = _azione_start_vas.data
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.emissione_provvedimento_verifica,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA,
).imposta_scadenza(get_scadenza(_data_start_vas, exp)))
def update_actions_for_phase(cls, fase, piano, procedura_approvazione,
user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.ADOZIONE)
_pubblicazione_approvazione = piano.getFirstAction(
TipologiaAzione.pubblicazione_approvazione)
if needs_execution(_pubblicazione_approvazione):
chiudi_azione(_pubblicazione_approvazione)
_trasmissione_approvazione = piano.getFirstAction(
TipologiaAzione.trasmissione_approvazione)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.attribuzione_conformita_pit,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(_trasmissione_approvazione.data,
TipoExpire.ATTRIBUZIONE_CONFORMITA_PIT)))
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.ANAGRAFICA)
_esito_cc = piano.getFirstAction(
TipologiaAzione.esito_conferenza_copianificazione)
if needs_execution(_esito_cc):
chiudi_azione(_esito_cc, set_data=False)
procedura_avvio.notifica_genio_civile = True
procedura_avvio.save()
now = get_now()
_cc = ConferenzaCopianificazione.objects.get(piano=piano)
_cc.data_chiusura_conferenza = now
_cc.save()
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.protocollo_genio_civile,
qualifica_richiesta=QualificaRichiesta.GC,
stato=StatoAzione.NECESSARIA,
))
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
if not piano.procedura_vas or (piano.procedura_vas
and piano.procedura_vas.tipologia
== TipologiaVAS.NON_NECESSARIA):
raise Exception(
"Tipologia VAS incongruente con l'azione richiesta")
# TODO: controllare se possibile usare --> _pareri_sca = piano.getFirstAction(TIPOLOGIA_AZIONE.pareri_adozione_sca)
_pareri_sca_list = piano.azioni(
tipologia_azione=TipologiaAzione.pareri_adozione_sca)
_pareri_sca = next((x for x in _pareri_sca_list if needs_execution(x)),
None)
if _pareri_sca:
chiudi_azione(_pareri_sca)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.parere_motivato_ac,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(procedura_adozione.pubblicazione_burt_data,
TipoExpire.ADOZIONE_VAS_PARERE_MOTIVATO_AC)))
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
ensure_fase(fase, Fase.AVVIO)
pubblicazione_burt = piano.getFirstAction(
TipologiaAzione.pubblicazione_burt)
if needs_execution(pubblicazione_burt):
chiudi_azione(pubblicazione_burt)
now = get_now()
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.osservazioni_enti,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA,
).imposta_scadenza((
now, # ???
procedura_adozione.data_ricezione_osservazioni)))
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.osservazioni_regione,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA,
).imposta_scadenza((
now, # ???
procedura_adozione.data_ricezione_osservazioni)))
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.upload_osservazioni_privati,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA,
).imposta_scadenza((
now, # ???
procedura_adozione.data_ricezione_osservazioni)))
if procedura_adozione.pubblicazione_burt_data and \
piano.procedura_vas.tipologia != TipologiaVAS.NON_NECESSARIA:
_procedura_adozione_vas, created = ProceduraAdozioneVAS.objects.get_or_create(
piano=piano)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.pareri_adozione_sca,
qualifica_richiesta=QualificaRichiesta.SCA,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(
procedura_adozione.pubblicazione_burt_data,
TipoExpire.ADOZIONE_VAS_PARERI_SCA)))
def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_azione = piano.getFirstAction(TipologiaAzione.trasmissione_pareri_ac)
if needs_execution(_azione):
chiudi_azione(_azione)
check_join_redazione_documenti_vas(user, piano)
def update_actions_for_phase(cls, fase, piano, procedura_vas, info):
ensure_fase(fase, Fase.ANAGRAFICA)
_ppv = piano.getFirstAction(
TipologiaAzione.pubblicazione_provvedimento_verifica_ac)
if needs_execution(_ppv):
chiudi_azione(_ppv)
check_join_pubblicazione_provvedimento(info, piano)
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
ensure_fase(fase, Fase.AVVIO)
_trasmissione_adozione = piano.getFirstAction(
TipologiaAzione.trasmissione_adozione)
if needs_execution(_trasmissione_adozione):
chiudi_azione(_trasmissione_adozione)
inizializza_procedura_cartografica(_trasmissione_adozione)
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 update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_formazione_del_piano = piano.getFirstAction(
TipologiaAzione.formazione_del_piano)
if needs_execution(_formazione_del_piano):
chiudi_azione(_formazione_del_piano)
try_and_close_avvio(piano)
def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_azione = piano.getFirstAction(TipologiaAzione.redazione_documenti_vas)
if needs_execution(_azione):
chiudi_azione(_azione)
procedura_vas.conclusa = True
procedura_vas.save()
def update_actions_for_phase(cls, fase, piano: Piano, procedura_avvio,
user):
# Update Azioni Piano
# - Update Action state accordingly
ensure_fase(fase, Fase.ANAGRAFICA)
_integrazioni_richieste = piano.getFirstAction(
TipologiaAzione.integrazioni_richieste)
if needs_execution(_integrazioni_richieste):
chiudi_azione(_integrazioni_richieste)
try_and_close_avvio(piano)
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
_rev_piano_post_cp = piano.getFirstAction(
TipologiaAzione.rev_piano_post_cp)
if needs_execution(_rev_piano_post_cp):
chiudi_azione(_rev_piano_post_cp)
inizializza_procedura_cartografica(_rev_piano_post_cp)
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
_piano_controdedotto = piano.getFirstAction(
TipologiaAzione.piano_controdedotto)
if needs_execution(_piano_controdedotto):
chiudi_azione(_piano_controdedotto)
inizializza_procedura_cartografica(_piano_controdedotto)
def update_actions_for_phase(cls, fase, piano, procedura_approvazione,
user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.ADOZIONE)
_trasmissione_approvazione = piano.getFirstAction(
TipologiaAzione.trasmissione_approvazione)
if needs_execution(_trasmissione_approvazione):
chiudi_azione(_trasmissione_approvazione)
inizializza_procedura_cartografica(_trasmissione_approvazione)
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
ensure_fase(fase, Fase.AVVIO)
_controdeduzioni = piano.getFirstAction(
TipologiaAzione.controdeduzioni)
if needs_execution(_controdeduzioni):
now = get_now()
chiudi_azione(_controdeduzioni, now)
for tipo in [
TipologiaAzione.osservazioni_enti,
TipologiaAzione.osservazioni_regione,
TipologiaAzione.upload_osservazioni_privati
]:
oss = piano.getFirstAction(tipo)
if needs_execution(oss):
chiudi_azione(oss, now)
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.piano_controdedotto,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA))
def promuovi_piano(fase: Fase, piano):
procedura_vas = piano.procedura_vas
# Update Azioni Piano
_order = Azione.count_by_piano(piano)
# - Attach Actions Templates for the Next "Fase"
for _a in AZIONI_BASE[fase]:
crea_azione(
Azione(piano=piano,
tipologia=_a["tipologia"],
qualifica_richiesta=_a["qualifica"],
order=_order,
stato=StatoAzione.NECESSARIA))
_order += 1
# - Update Action state accordingly
if fase == Fase.ANAGRAFICA:
_creato = piano.getFirstAction(TipologiaAzione.creato_piano)
if _creato.stato != StatoAzione.NECESSARIA:
raise Exception("Stato Inconsistente!")
chiudi_azione(_creato)
elif fase == Fase.AVVIO:
## TODO check -- WTF?????
_richiesta_integrazioni = piano.getFirstAction(
TipologiaAzione.richiesta_integrazioni)
if needs_execution(_richiesta_integrazioni):
chiudi_azione(_richiesta_integrazioni)
_integrazioni_richieste = piano.getFirstAction(
TipologiaAzione.integrazioni_richieste)
if needs_execution(_integrazioni_richieste):
chiudi_azione(_integrazioni_richieste)
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_protocollo_genio_civile = piano.getFirstAction(
TipologiaAzione.protocollo_genio_civile)
if needs_execution(_protocollo_genio_civile):
now = datetime.datetime.now(timezone.get_current_timezone())
chiudi_azione(_protocollo_genio_civile, data=now)
piano.data_protocollo_genio_civile = now
piano.save()
return try_and_close_avvio(piano)
return False
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
ensure_fase(fase, Fase.AVVIO)
_upload_osservazioni_privati = piano.getFirstAction(
TipologiaAzione.upload_osservazioni_privati)
if needs_execution(_upload_osservazioni_privati):
chiudi_azione(_upload_osservazioni_privati)
if not piano.getFirstAction(TipologiaAzione.controdeduzioni):
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.controdeduzioni,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA))
def update_actions_for_phase(cls, fase, piano, procedura_approvazione,
user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.ADOZIONE)
_esito_cp = piano.getFirstAction(
TipologiaAzione.esito_conferenza_paesaggistica_ap)
if needs_execution(_esito_cp):
chiudi_azione(_esito_cp)
inizializza_procedura_cartografica(_esito_cp)
def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_pareri_verifica_vas = piano.getFirstAction(
TipologiaAzione.trasmissione_dpv_vas)
if needs_execution(_pareri_verifica_vas):
now = get_now()
chiudi_azione(_pareri_verifica_vas, now)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.pareri_verifica_sca,
qualifica_richiesta=QualificaRichiesta.SCA,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(now, TipoExpire.PARERI_VERIFICA_SCA)))
def update_actions_for_phase(cls, fase, piano, procedura_pubblicazione,
user):
ensure_fase(fase, Fase.APPROVAZIONE)
# - Update Action state accordingly
_pubblicazione_piano = piano.getFirstAction(
TipologiaAzione.pubblicazione_piano)
if needs_execution(_pubblicazione_piano):
chiudi_azione(_pubblicazione_piano)
if not procedura_pubblicazione.conclusa:
chiudi_pendenti(piano, attesa=True, necessaria=True)
procedura_pubblicazione.data_pubblicazione = _pubblicazione_piano.data
procedura_pubblicazione.conclusa = True
procedura_pubblicazione.save()
piano.save()
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
_esito_cp = piano.getFirstAction(
TipologiaAzione.esito_conferenza_paesaggistica)
if needs_execution(_esito_cp):
chiudi_azione(_esito_cp)
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.rev_piano_post_cp,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.NECESSARIA))
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_avvio_procedimento = piano.getFirstAction(
TipologiaAzione.avvio_procedimento)
if needs_execution(_avvio_procedimento):
if not cls.autorita_ok(piano, [Qualifica.GC]):
raise GraphQLError(
"Genio Civile non trovato tra i soggetti operanti",
code=400)
if not cls.autorita_ok(piano, [Qualifica.OPREG]):
raise GraphQLError(
"Pianificazione o Urbanistica non trovato tra i soggetti operanti",
code=400)
if procedura_avvio.conferenza_copianificazione is None:
raise GraphQLError("Conferenza copianificazione non impostata",
code=400)
chiudi_azione(_avvio_procedimento)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.contributi_tecnici,
qualifica_richiesta=QualificaRichiesta.REGIONE,
stato=StatoAzione.ATTESA,
).imposta_scadenza((
get_now(), # ??
procedura_avvio.data_scadenza_risposta)))
crea_azione(Azione(
piano=piano,
tipologia=TipologiaAzione.selezione_tipologia_vas,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA,
),
send_mail=False)
init_vas_procedure(piano, user)
def update_actions_for_phase(cls, fase, piano, procedura_approvazione,
user):
ensure_fase(fase, Fase.ADOZIONE)
_attribuzione_conformita_pit = piano.getFirstAction(
TipologiaAzione.attribuzione_conformita_pit)
if needs_execution(_attribuzione_conformita_pit):
chiudi_azione(_attribuzione_conformita_pit)
if not procedura_approvazione.conclusa:
chiudi_pendenti(piano, attesa=True, necessaria=False)
procedura_approvazione.conclusa = True
procedura_approvazione.save()
procedura_pubblicazione, created = ProceduraPubblicazione.objects.get_or_create(
piano=piano)
piano.procedura_pubblicazione = procedura_pubblicazione
piano.save()
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.ANAGRAFICA)
_richiesta_integrazioni = piano.getFirstAction(
TipologiaAzione.richiesta_integrazioni)
if needs_execution(_richiesta_integrazioni):
chiudi_azione(_richiesta_integrazioni)
if procedura_avvio.richiesta_integrazioni:
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.integrazioni_richieste,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA))
else:
try_and_close_avvio(piano)
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
ensure_fase(fase, Fase.ANAGRAFICA)
# _avvio_procedimento = piano.getFirstAction(TIPOLOGIA_AZIONE.avvio_procedimento)
# if isExecuted(_avvio_procedimento):
if procedura_avvio.conferenza_copianificazione != TipologiaCopianificazione.POSTICIPATA:
return GraphQLError(
"Errore nello stato del piano - Tipologia copianificazione errata",
code=400)
_richiesta_cc = piano.getFirstAction(
TipologiaAzione.richiesta_conferenza_copianificazione)
if needs_execution(_richiesta_cc):
chiudi_azione(_richiesta_cc, set_data=False)
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc = ConferenzaCopianificazione.objects.get(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,
))
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Complete Current Actions
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
if not piano.procedura_vas or (piano.procedura_vas
and piano.procedura_vas.tipologia
== TipologiaVAS.NON_NECESSARIA):
raise Exception(
"Tipologia VAS incongruente con l'azione richiesta")
_parere_motivato_ac = piano.getFirstAction(
TipologiaAzione.parere_motivato_ac)
if needs_execution(_parere_motivato_ac):
chiudi_azione(_parere_motivato_ac)
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.upload_elaborati_adozione_vas,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA))
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user):
# Update Azioni Piano
# - Update Action state accordingly
ensure_fase(fase, Fase.AVVIO)
if not piano.procedura_vas or (piano.procedura_vas
and piano.procedura_vas.tipologia
== TipologiaVAS.NON_NECESSARIA):
raise Exception(
"Tipologia VAS incongruente con l'azione richiesta")
_upload_elaborati_adozione_vas = piano.getFirstAction(
TipologiaAzione.upload_elaborati_adozione_vas)
if needs_execution(_upload_elaborati_adozione_vas):
chiudi_azione(_upload_elaborati_adozione_vas)
_procedura_adozione_vas = ProceduraAdozioneVAS.objects.filter(
piano=piano).last()
_procedura_adozione_vas.conclusa = True
_procedura_adozione_vas.save()
try_and_close_adozione(piano)
