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)
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_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_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 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):
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 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 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 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_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_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):
# 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 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_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 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))
def mutate_and_get_payload(cls, root, info, **input):
try:
_piano_data = input.get('piano_operativo')
# Ente (M)
_data = _piano_data.pop('ente')
_ente = Ente.objects.get(ipa=_data['ipa'])
# _role = info.context.session.get('role', None)
# _token = info.context.session.get('token', None)
_piano_data['ente'] = _ente
if not info.context.user:
return GraphQLError("Unauthorized", code=401)
if not _ente.is_comune():
return GraphQLError("Ente deve essere un comune", code=400)
if not auth.can_create_piano(info.context.user, _ente):
return GraphQLError("Forbidden: user can't create piano",
code=403)
# create Piano and assign id
_piano = Piano()
_piano.ente = _ente # mandatory field
_piano.codice = "temp" # mandatory field
_piano.save()
# Codice (M)
if 'codice' in _piano_data:
_codice = _piano_data.pop('codice')
else:
_year = str(datetime.date.today().year)[2:]
_month = datetime.date.today().month
_codice = '%s%02d%02d%05d' % (_ente.ipa, int(_year), _month,
_piano.id)
_piano_data['codice'] = _codice
# Fase (O)
_fase = None
if 'fase' in _piano_data:
_data = _piano_data.pop('fase')
_fase = Fase.fix_enum(_data, none_on_error=True)
_fase = _fase if _fase else Fase.DRAFT
_piano_data['fase'] = _fase
# Descrizione (O)
if 'descrizione' in _piano_data:
_data = _piano_data.pop('descrizione')
_piano_data['descrizione'] = _data[0]
if 'tipologia' in _piano_data:
_tipologia = _piano_data.pop('tipologia')
_tipologia = TipologiaPiano.fix_enum(_tipologia,
none_on_error=True)
_piano_data['tipologia'] = _tipologia
_piano_data['responsabile'] = info.context.user
# Crea piano
# _piano = Piano()
nuovo_piano = update_create_instance(_piano, _piano_data)
# Aggiunta soggetti operanti di default
for qu in QualificaUfficio.get_soggetti_default():
so = SoggettoOperante(piano=nuovo_piano, qualifica_ufficio=qu)
so.save()
# Inizializzazione Azioni del Piano
_order = 0
for _a in AZIONI_BASE[_fase]:
crea_azione(
Azione(piano=nuovo_piano,
tipologia=_a["tipologia"],
qualifica_richiesta=_a["qualifica"],
stato=_a.get('stato', None),
order=_order))
_order += 1
# Inizializzazione Procedura VAS
_procedura_vas, created = ProceduraVAS.objects.get_or_create(
piano=nuovo_piano, tipologia=TipologiaVAS.UNKNOWN)
# Inizializzazione Procedura Avvio
_procedura_avvio, created = ProceduraAvvio.objects.get_or_create(
piano=nuovo_piano)
nuovo_piano.procedura_vas = _procedura_vas
nuovo_piano.procedura_avvio = _procedura_avvio
nuovo_piano.save()
return cls(nuovo_piano=nuovo_piano)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def init_vas_procedure(piano: Piano, utente: Utente):
procedura_vas = piano.procedura_vas
_selezione_tipologia_vas = piano.getFirstAction(
TipologiaAzione.selezione_tipologia_vas)
now = get_now()
if needs_execution(_selezione_tipologia_vas):
chiudi_azione(_selezione_tipologia_vas, now)
else:
raise GraphQLError("Stato inconsistente nell'inizializzazione VAS",
code=500)
if procedura_vas.tipologia == TipologiaVAS.NON_NECESSARIA:
pass
elif procedura_vas.tipologia == TipologiaVAS.PROCEDURA_ORDINARIA:
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.invio_doc_preliminare,
qualifica_richiesta=QualificaRichiesta.COMUNE,
stato=StatoAzione.ATTESA,
))
elif procedura_vas.tipologia == TipologiaVAS.VERIFICA:
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.trasmissione_dpv_vas,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(now, TipoExpire.TRASMISSIONE_DPV_VAS)))
elif procedura_vas.tipologia == TipologiaVAS.VERIFICA_SEMPLIFICATA:
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.emissione_provvedimento_verifica,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA,
).imposta_scadenza(
get_scadenza(now,
TipoExpire.EMISSIONE_PV_VERIFICASEMPLIFICATA)))
elif procedura_vas.tipologia == TipologiaVAS.PROCEDIMENTO_SEMPLIFICATO:
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_PROCEDIMENTOSEMPLIFICATO)))
# AC deve essere notificato
piano_phase_changed.send(
message_type=TipoMail.trasmissione_dp_vas,
sender=Piano,
piano=piano,
user=utente,
)
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))
