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_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_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_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_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_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 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_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):
# 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_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_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_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_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_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_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 esegui_ingestione(lotto_id):
lotto: LottoCartografico = LottoCartografico.objects.filter(
id=lotto_id).get()
az_verifica = lotto.azione
az_ingestione = az_verifica.piano.getFirstAction(
MAPPING_AZIONI_VALIDAZIONECARTO_INGESTIONE[az_verifica.tipologia])
result_azione = StatoAzione.ESEGUITA
for elaborato in ElaboratoCartografico.objects.filter(lotto=lotto):
msgs = crea_msgs()
ok = ingest(elaborato, az_ingestione, msgs)
if not ok:
result_azione = StatoAzione.FALLITA
else:
elaborato.ingerito = True
elaborato.save()
log_msgs(msgs, "Ingestione {}".format(elaborato.nome))
utils.chiudi_azione(az_ingestione, stato=result_azione)
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 esegui_procedura_cartografica(lotto_id):
"""
Chiamato da shared_task
:param lotto:
:return:
"""
lotto: LottoCartografico = LottoCartografico.objects.filter(
id=lotto_id).get()
azione: Azione = lotto.azione
piano: Piano = azione.piano
msgs = crea_msgs()
# ci sono lotti diversi a seconda della tipologia di piano
tipi_risorsa = MAPPING_PIANO_RISORSE.get(piano.tipologia, ())
for tipo_risorsa in tipi_risorsa:
process_carto(lotto, tipo_risorsa, msgs)
error = len(msgs[TipoReportAzione.ERR]) > 0
# Log report
log_msgs(msgs, "Elaborati cartografici")
if error:
utils.chiudi_azione(azione, stato=StatoAzione.FALLITA)
# l'azione parent deve essere nuovamente eseguita
utils.riapri_azione(lotto.azione_parent)
else:
utils.chiudi_azione(azione)
crea_azione_post_cartografica(lotto.azione.piano,
lotto.azione.tipologia)
crea_azione_ingestione(azione)
esegui_ingestione.delay(lotto_id)
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)
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):
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))
