def update_actions_for_phase(cls, fase, piano, procedura_vas):
# Update Azioni Piano
# - Complete Current Actions
_order = 0
for _a in piano.azioni.all():
_order += 1
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_avvio_consultazioni_sca = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_consultazioni_sca).first()
if _avvio_consultazioni_sca.stato == STATO_AZIONE.attesa:
_avvio_consultazioni_sca.stato = STATO_AZIONE.nessuna
_avvio_consultazioni_sca.data = datetime.datetime.now(
timezone.get_current_timezone())
_avvio_consultazioni_sca.save()
_pareri_vas_expire_days = getattr(settings,
'PARERI_VAS_EXPIRE_DAYS', 60)
_pareri_sca = Azione(
tipologia=TIPOLOGIA_AZIONE.pareri_sca,
attore=TIPOLOGIA_ATTORE.sca,
order=_order,
stato=STATO_AZIONE.attesa,
data=datetime.datetime.now(timezone.get_current_timezone())
+ datetime.timedelta(days=_pareri_vas_expire_days))
_pareri_sca.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_pareri_sca,
piano=piano)
def update_actions_for_phase(cls, fase, piano, procedura_vas):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_pareri_sca = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pareri_sca).first()
if _pareri_sca.stato == STATO_AZIONE.nessuna:
_avvio_esame_pareri_sca = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_esame_pareri_sca).first()
if _avvio_esame_pareri_sca.stato != STATO_AZIONE.nessuna:
_avvio_esame_pareri_sca.stato = STATO_AZIONE.nessuna
_avvio_esame_pareri_sca.data = datetime.datetime.now(timezone.get_current_timezone())
_avvio_esame_pareri_sca.save()
_upload_elaborati_vas = Azione(
tipologia=TIPOLOGIA_AZIONE.upload_elaborati_vas,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.necessaria
)
_upload_elaborati_vas.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_upload_elaborati_vas, piano=piano)
else:
raise Exception(_("Fase Piano incongruente con l'azione richiesta"))
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
# Update Azioni Piano
# - Complete Current Actions
_order = 0
for _a in piano.azioni.all():
_order += 1
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_richiesta_integrazioni = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.richiesta_integrazioni).first()
if _richiesta_integrazioni and _richiesta_integrazioni.stato != STATO_AZIONE.nessuna:
if procedura_avvio.messaggio_integrazione and \
len(procedura_avvio.messaggio_integrazione) > 0 and \
procedura_avvio.richiesta_integrazioni:
_richiesta_integrazioni.stato = STATO_AZIONE.nessuna
_richiesta_integrazioni.data = datetime.datetime.now(
timezone.get_current_timezone())
_richiesta_integrazioni.save()
_integrazioni_richieste = Azione(
tipologia=TIPOLOGIA_AZIONE.integrazioni_richieste,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.attesa)
_integrazioni_richieste.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_integrazioni_richieste, piano=piano)
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio:
_esito_cp = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.esito_conferenza_paesaggistica
).first()
if _esito_cp and _esito_cp.stato != STATO_AZIONE.nessuna:
_esito_cp.stato = STATO_AZIONE.nessuna
_esito_cp.data = datetime.datetime.now(
timezone.get_current_timezone())
_esito_cp.save()
_rev_piano_post_cp = Azione(
tipologia=TIPOLOGIA_AZIONE.rev_piano_post_cp,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.necessaria)
_rev_piano_post_cp.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_rev_piano_post_cp,
piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio and \
piano.procedura_vas and piano.procedura_vas.tipologia != TIPOLOGIA_VAS.non_necessaria:
_parere_motivato_ac = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.parere_motivato_ac).first()
if _parere_motivato_ac and _parere_motivato_ac.stato != STATO_AZIONE.nessuna:
_parere_motivato_ac.stato = STATO_AZIONE.nessuna
_parere_motivato_ac.data = datetime.datetime.now(
timezone.get_current_timezone())
_parere_motivato_ac.save()
_upload_elaborati_adozione_vas = Azione(
tipologia=TIPOLOGIA_AZIONE.upload_elaborati_adozione_vas,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.attesa)
_upload_elaborati_adozione_vas.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_upload_elaborati_adozione_vas, piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
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 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_adozione, user,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio:
_controdeduzioni = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.controdeduzioni).first()
if _controdeduzioni and _controdeduzioni.stato != STATO_AZIONE.nessuna:
_controdeduzioni.stato = STATO_AZIONE.nessuna
_controdeduzioni.data = datetime.datetime.now(
timezone.get_current_timezone())
_controdeduzioni.save()
_piano_controdedotto = Azione(
tipologia=TIPOLOGIA_AZIONE.piano_controdedotto,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.attesa)
_piano_controdedotto.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_piano_controdedotto,
piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
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 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 update_actions_for_phase(cls, fase, piano, procedura_adozione, user,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio:
_osservazioni_enti = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.osservazioni_enti).first()
_osservazioni_regione = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.osservazioni_regione).first()
_upload_osservazioni_privati = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.upload_osservazioni_privati).first(
)
_organization = piano.ente
if rules.test_rule('strt_core.api.is_actor', token
or (user, _organization), 'Regione'):
if _osservazioni_regione and _osservazioni_regione.stato != STATO_AZIONE.nessuna:
_osservazioni_regione.stato = STATO_AZIONE.nessuna
_osservazioni_regione.data = datetime.datetime.now(
timezone.get_current_timezone())
_osservazioni_regione.save()
if _osservazioni_enti and _osservazioni_enti.stato != STATO_AZIONE.nessuna:
_osservazioni_enti.stato = STATO_AZIONE.nessuna
_osservazioni_enti.data = datetime.datetime.now(
timezone.get_current_timezone())
_osservazioni_enti.save()
if rules.test_rule('strt_core.api.is_actor', token
or (user, _organization), 'Comune'):
if _upload_osservazioni_privati and _upload_osservazioni_privati.stato != STATO_AZIONE.nessuna:
_upload_osservazioni_privati.stato = STATO_AZIONE.nessuna
_upload_osservazioni_privati.data = datetime.datetime.now(
timezone.get_current_timezone())
_upload_osservazioni_privati.save()
if _upload_osservazioni_privati.stato == STATO_AZIONE.nessuna and \
_osservazioni_regione.stato == STATO_AZIONE.nessuna:
_controdeduzioni = Azione(
tipologia=TIPOLOGIA_AZIONE.controdeduzioni,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.attesa)
_controdeduzioni.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_controdeduzioni,
piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_avvio_procedimento = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_procedimento).first()
if _avvio_procedimento and _avvio_procedimento.stato == STATO_AZIONE.nessuna:
if procedura_avvio.conferenza_copianificazione == TIPOLOGIA_CONF_COPIANIFIZAZIONE.posticipata:
_richiesta_cc = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.
richiesta_conferenza_copianificazione).first()
if _richiesta_cc and _richiesta_cc.stato != STATO_AZIONE.nessuna:
_richiesta_cc.stato = STATO_AZIONE.nessuna
_richiesta_cc.save()
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc = ConferenzaCopianificazione.objects.get(
piano=piano)
_cc.data_richiesta_conferenza = datetime.datetime.now(
timezone.get_current_timezone())
_cc.data_scadenza_risposta = procedura_avvio.data_scadenza_risposta
_cc.save()
_conferenza_copianificazione = Azione(
tipologia=TIPOLOGIA_AZIONE.
esito_conferenza_copianificazione,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa,
data=procedura_avvio.data_scadenza_risposta)
_conferenza_copianificazione.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_conferenza_copianificazione, piano=piano)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=user,
piano=piano,
message_type="conferenza_copianificazione")
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
def update_actions_for_phase(cls, fase, piano, consultazione_vas, user):
# Update Azioni Piano
# - Complete Current Actions
_order = 0
for _a in piano.azioni.all():
_order += 1
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_avvio_consultazioni_sca = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_consultazioni_sca)
for _ac in _avvio_consultazioni_sca:
if _ac.stato != STATO_AZIONE.nessuna:
_avvio_consultazioni_sca = _ac
break
if _avvio_consultazioni_sca and \
not isinstance(_avvio_consultazioni_sca, QuerySet) and \
_avvio_consultazioni_sca.stato != STATO_AZIONE.nessuna:
_avvio_consultazioni_sca.stato = STATO_AZIONE.nessuna
_avvio_consultazioni_sca.data = datetime.datetime.now(
timezone.get_current_timezone())
consultazione_vas.data_avvio_consultazioni_sca = _avvio_consultazioni_sca.data
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=user,
piano=piano,
message_type="piano_verifica_vas_updated")
_avvio_consultazioni_sca.save()
consultazione_vas.save()
_pareri_vas_expire_days = getattr(settings,
'PARERI_VAS_EXPIRE_DAYS', 60)
_pareri_sca = Azione(
tipologia=TIPOLOGIA_AZIONE.pareri_sca,
attore=TIPOLOGIA_ATTORE.sca,
order=_order,
stato=STATO_AZIONE.attesa,
data=datetime.datetime.now(timezone.get_current_timezone())
+ datetime.timedelta(days=_pareri_vas_expire_days))
_pareri_sca.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_pareri_sca,
piano=piano)
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 inizializza_procedura_cartografica(parent: Azione):
piano: Piano = parent.piano
tipo_carto: TipologiaAzione = MAPPING_AZIONI_CARTO_NEXT[parent.tipologia]
azione_carto = piano.getFirstAction(tipo_carto)
# Le azioni di controllo cartografico possono fallire: in quel caso l'azione precedente viene resa nuovamente
# eseguibile. Una volta che l'azione parent è nuovamente eseguita, non creeremo una nuova azione cartografica,
# ma useremo quella precedentemente creata
if azione_carto:
riapri_azione(azione_carto)
else:
azione_carto = crea_azione(
Azione(
piano=piano,
tipologia=tipo_carto,
qualifica_richiesta=QualificaRichiesta.AUTO,
stato=StatoAzione.NECESSARIA,
))
lotto = LottoCartografico.objects.filter(azione=azione_carto).first()
if lotto:
ElaboratoCartografico.objects.filter(lotto=lotto).delete()
else:
lotto = LottoCartografico(piano=piano,
azione=azione_carto,
azione_parent=parent)
lotto.save()
esegui_procedura_cartografica.delay(lotto.id)
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_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,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio and \
piano.procedura_vas and piano.procedura_vas.tipologia != TIPOLOGIA_VAS.non_necessaria:
_pareri_sca = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pareri_adozione_sca)
for _psca in _pareri_sca:
if _psca.stato != STATO_AZIONE.nessuna:
_pareri_sca = _psca
break
if _pareri_sca and \
(isinstance(_pareri_sca, QuerySet) or
_pareri_sca.stato != STATO_AZIONE.nessuna):
if isinstance(_pareri_sca, QuerySet):
_pareri_sca = _pareri_sca.last()
_pareri_sca.stato = STATO_AZIONE.nessuna
_pareri_sca.data = datetime.datetime.now(
timezone.get_current_timezone())
_pareri_sca.save()
_expire_days = getattr(
settings, 'ADOZIONE_VAS_PARERE_MOTIVATO_AC_EXPIRE_DAYS',
30)
_alert_delta = datetime.timedelta(days=_expire_days)
_parere_motivato_ac_expire = procedura_adozione.pubblicazione_burt_data + _alert_delta
_parere_motivato_ac = Azione(
tipologia=TIPOLOGIA_AZIONE.parere_motivato_ac,
attore=TIPOLOGIA_ATTORE.ac,
order=_order,
stato=STATO_AZIONE.attesa,
data=_parere_motivato_ac_expire)
_parere_motivato_ac.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_parere_motivato_ac,
piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
def update_actions_for_phase(cls, fase, piano, procedura_avvio, user):
# Update Azioni Piano
# - Complete Current Actions
_order = 0
for _a in piano.azioni.all():
_order += 1
# - Update Action state accordingly
if fase.nome == FASE.anagrafica:
_avvio_procedimento = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_procedimento).first()
if _avvio_procedimento and _avvio_procedimento.stato == STATO_AZIONE.nessuna:
_esito_cc = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.
esito_conferenza_copianificazione).first()
if _esito_cc and _esito_cc.stato != STATO_AZIONE.nessuna:
_esito_cc.stato = STATO_AZIONE.nessuna
_esito_cc.save()
procedura_avvio.notifica_genio_civile = True
procedura_avvio.save()
_cc = ConferenzaCopianificazione.objects.get(piano=piano)
_cc.data_chiusura_conferenza = datetime.datetime.now(
timezone.get_current_timezone())
_cc.save()
_protocollo_genio_civile = Azione(
tipologia=TIPOLOGIA_AZIONE.protocollo_genio_civile,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.attesa,
data=procedura_avvio.data_scadenza_risposta)
_protocollo_genio_civile.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_protocollo_genio_civile, piano=piano)
_protocollo_genio_civile_id = Azione(
tipologia=TIPOLOGIA_AZIONE.protocollo_genio_civile_id,
attore=TIPOLOGIA_ATTORE.genio_civile,
order=_order,
stato=STATO_AZIONE.necessaria)
_protocollo_genio_civile_id.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_protocollo_genio_civile_id, piano=piano)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=user,
piano=piano,
message_type="protocollo_genio_civile")
def update_actions_for_phase(cls, fase, piano, procedura_adozione, user,
token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.avvio:
_piano_controdedotto = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.piano_controdedotto).first()
if _piano_controdedotto and _piano_controdedotto.stato != STATO_AZIONE.nessuna:
_piano_controdedotto.stato = STATO_AZIONE.nessuna
_piano_controdedotto.data = datetime.datetime.now(
timezone.get_current_timezone())
_piano_controdedotto.save()
if not procedura_adozione.richiesta_conferenza_paesaggistica:
_procedura_adozione_vas = ProceduraAdozioneVAS.objects.filter(
piano=piano).last()
if not _procedura_adozione_vas or _procedura_adozione_vas.conclusa:
piano.chiudi_pendenti()
procedura_adozione.conclusa = True
procedura_adozione.save()
procedura_approvazione, created = ProceduraApprovazione.objects.get_or_create(
piano=piano, ente=piano.ente)
piano.procedura_approvazione = procedura_approvazione
piano.save()
else:
_convocazione_cp = Azione(tipologia=TIPOLOGIA_AZIONE.
esito_conferenza_paesaggistica,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa)
_convocazione_cp.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_convocazione_cp,
piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
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 crea_azione_ingestione(azione_validazione: Azione):
tipo_validazione = azione_validazione.tipologia
tipo_ingestione = MAPPING_AZIONI_VALIDAZIONECARTO_INGESTIONE[
tipo_validazione]
return utils.crea_azione(
Azione(
piano=azione_validazione.piano,
tipologia=tipo_ingestione,
qualifica_richiesta=QualificaRichiesta.AUTO,
stato=StatoAzione.NECESSARIA,
))
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_approvazione,
user, token):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.adozione:
_trasmissione_approvazione = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.trasmissione_approvazione).first()
_pubblicazione_approvazione = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pubblicazione_approvazione).first()
if _pubblicazione_approvazione and _pubblicazione_approvazione.stato != STATO_AZIONE.nessuna:
_pubblicazione_approvazione.stato = STATO_AZIONE.nessuna
_pubblicazione_approvazione.data = datetime.datetime.now(
timezone.get_current_timezone())
_pubblicazione_approvazione.save()
_expire_days = getattr(
settings, 'ATTRIBUZIONE_CONFORMITA_PIT_EXPIRE_DAYS', 30)
_alert_delta = datetime.timedelta(days=_expire_days)
_attribuzione_conformita_pit = Azione(
tipologia=TIPOLOGIA_AZIONE.attribuzione_conformita_pit,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa,
data=_trasmissione_approvazione.data + _alert_delta)
_attribuzione_conformita_pit.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_attribuzione_conformita_pit, piano=piano)
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
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_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
_invio_doc_preliminare = piano.getFirstAction(
TipologiaAzione.invio_doc_preliminare)
if needs_execution(_invio_doc_preliminare):
now = get_now()
chiudi_azione(_invio_doc_preliminare, now)
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.trasmissione_pareri_sca,
qualifica_richiesta=QualificaRichiesta.SCA,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(now, TipoExpire.TRASMISSIONE_PARERI_SCA)))
crea_azione(
Azione(piano=piano,
tipologia=TipologiaAzione.trasmissione_pareri_ac,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA))
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 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_approvazione,
user):
# Update Azioni Piano
# - Complete Current Actions
_order = piano.azioni.count()
# - Update Action state accordingly
if fase.nome == FASE.adozione:
_trasmissione_approvazione = piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.trasmissione_approvazione).first()
if _trasmissione_approvazione and _trasmissione_approvazione.stato != STATO_AZIONE.nessuna:
_trasmissione_approvazione.stato = STATO_AZIONE.nessuna
_trasmissione_approvazione.data = datetime.datetime.now(
timezone.get_current_timezone())
_trasmissione_approvazione.save()
if not piano.procedura_adozione.richiesta_conferenza_paesaggistica:
# Se non è stata fatta prima, va fatta ora...
_convocazione_cp = Azione(
tipologia=TIPOLOGIA_AZIONE.
esito_conferenza_paesaggistica_ap,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa)
_convocazione_cp.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_convocazione_cp,
piano=piano)
else:
_pubblicazione_approvazione = Azione(
tipologia=TIPOLOGIA_AZIONE.pubblicazione_approvazione,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.necessaria)
_pubblicazione_approvazione.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_pubblicazione_approvazione, piano=piano)
procedura_approvazione.richiesta_conferenza_paesaggistica = True
procedura_approvazione.save()
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
