def mutate(cls, root, info, **input):
_procedura_adozione = ProceduraAdozione.objects.get(uuid=input['uuid'])
_piano = _procedura_adozione.piano
_token = info.context.session[
'token'] if 'token' in info.context.session else None
_organization = _piano.ente
if info.context.user and rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano) and \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'Regione'):
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user, _token)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="esito_conferenza_paesaggistica")
return EsitoConferenzaPaesaggistica(
adozione_aggiornata=_procedura_adozione, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_vas = ProceduraVAS.objects.get(piano=_piano)
if info.context.user and rules.test_rule(
'strt_core.api.can_edit_piano', info.context.user, _piano):
try:
_next_fase = cls.get_next_phase(_piano.fase)
if rules.test_rule(
'strt_core.api.fase_{next}_completa'.format(
next=_next_fase), _piano, _procedura_vas):
_piano.fase = _fase = Fase.objects.get(nome=_next_fase)
piano_phase_changed.send(sender=Piano,
user=info.context.user,
piano=_piano)
_piano.save()
cls.update_actions_for_phase(_fase, _piano, _procedura_vas)
return PromozionePiano(piano_aggiornato=_piano, errors=[])
else:
return GraphQLError(_("Not Allowed"), code=405)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
_token = info.context.session['token'] if 'token' in info.context.session else None
_organization = _piano.ente
if info.context.user and \
rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano) and \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'Comune'):
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
if _piano.is_eligible_for_promotion:
_piano.fase = _fase = Fase.objects.get(nome=_piano.next_phase)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="piano_phase_changed")
_piano.save()
fase.promuovi_piano(_fase, _piano)
return UploadElaboratiVAS(
vas_aggiornata=_procedura_vas,
errors=[]
)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_procedura_pubblicazione = ProceduraPubblicazione.objects.get(
uuid=input['uuid'])
_piano = _procedura_pubblicazione.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_pubblicazione,
info.context.user)
# Notify Users
piano_phase_changed.send(sender=Piano,
user=info.context.user,
piano=_piano,
message_type=TipoMail.pubblicazione_piano)
return PubblicazionePiano(
pubblicazione_aggiornata=_procedura_pubblicazione, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
if info.context.user and rules.test_rule(
'strt_core.api.can_edit_piano', info.context.user, _piano):
try:
if _piano.is_eligible_for_promotion:
_piano.fase = _fase = Fase.objects.get(
nome=_piano.next_phase)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="piano_phase_changed")
_piano.save()
fase.promuovi_piano(_fase, _piano)
return PromozionePiano(piano_aggiornato=_piano, errors=[])
else:
return GraphQLError(_("Not Allowed"), code=405)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
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:
_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")
else:
raise Exception(
_("Fase Piano incongruente con l'azione richiesta"))
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
_token = info.context.session['token'] if 'token' in info.context.session else None
_organization = _piano.ente
if info.context.user and \
rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano) and \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'SCA'):
try:
_pareri_vas_count = ParereVerificaVAS.objects.filter(
user=info.context.user,
procedura_vas=_procedura_vas
)
if _pareri_vas_count.count() == 0:
_parere_vas = ParereVerificaVAS(
inviata=True,
user=info.context.user,
procedura_vas=_procedura_vas
)
_parere_vas.save()
elif _pareri_vas_count.count() != 1:
return GraphQLError(_("Forbidden"), code=403)
_tutti_pareri_inviati = True
for _sca in _piano.soggetti_sca.all():
_pareri_vas_count = ParereVerificaVAS.objects.filter(
user=_sca.user,
procedura_vas=_procedura_vas
).count()
if _pareri_vas_count != 1:
_tutti_pareri_inviati = False
break
if _tutti_pareri_inviati:
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="tutti_pareri_inviati")
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
return InvioPareriVerificaVAS(
vas_aggiornata=_procedura_vas,
errors=[]
)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
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:
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")
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 mutate_and_get_payload(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_procedura_vas_data = input.get('procedura_vas')
if 'piano' in _procedura_vas_data:
# This cannot be changed
_procedura_vas_data.pop('piano')
_piano = _procedura_vas.piano
_token = info.context.session['token'] if 'token' in info.context.session else None
_ente = _piano.ente
if info.context.user and \
rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano):
try:
if 'uuid' in _procedura_vas_data:
_procedura_vas_data.pop('uuid')
# This cannot be changed
if 'data_creazione' in _procedura_vas_data:
_procedura_vas_data.pop('data_creazione')
# This cannot be changed
# Ente (M)
if 'ente' in _procedura_vas_data:
_procedura_vas_data.pop('ente')
# This cannot be changed
# Tipologia (O)
if 'tipologia' in _procedura_vas_data:
if rules.test_rule('strt_users.is_superuser', info.context.user) or \
is_RUP(info.context.user) or \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'):
_tipologia = _procedura_vas_data.pop('tipologia')
if _tipologia and _tipologia in TIPOLOGIA_VAS:
_procedura_vas_data['tipologia'] = _tipologia
# Note (O)
if 'note' in _procedura_vas_data:
if rules.test_rule('strt_users.is_superuser', info.context.user) or \
is_RUP(info.context.user) or \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'):
_data = _procedura_vas_data.pop('note')
_procedura_vas.note = _data[0]
procedura_vas_aggiornata = update_create_instance(_procedura_vas, _procedura_vas_data)
if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ap:
if rules.test_rule('strt_users.is_superuser', info.context.user) or \
is_RUP(info.context.user) or \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'):
_pubblicazione_provvedimento_verifica_ap = _piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pubblicazione_provvedimento_verifica,
attore=TIPOLOGIA_ATTORE.comune).first()
if _pubblicazione_provvedimento_verifica_ap and \
_pubblicazione_provvedimento_verifica_ap.stato != STATO_AZIONE.nessuna:
_pubblicazione_provvedimento_verifica_ap.stato = STATO_AZIONE.nessuna
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="piano_verifica_vas_updated")
_pubblicazione_provvedimento_verifica_ap.save()
if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ac:
if rules.test_rule('strt_users.is_superuser', info.context.user) or \
is_RUP(info.context.user) or \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'AC'):
_pubblicazione_provvedimento_verifica_ac = _piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pubblicazione_provvedimento_verifica,
attore=TIPOLOGIA_ATTORE.ac).first()
if _pubblicazione_provvedimento_verifica_ac and \
_pubblicazione_provvedimento_verifica_ac.stato != STATO_AZIONE.nessuna:
_pubblicazione_provvedimento_verifica_ac.stato = STATO_AZIONE.nessuna
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="piano_verifica_vas_updated")
_pubblicazione_provvedimento_verifica_ac.save()
if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ap and \
procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ac:
_procedura_avvio = ProceduraAvvio.objects.filter(piano=_piano).last()
if not _procedura_avvio or _procedura_avvio.conclusa:
_piano.chiudi_pendenti()
procedura_vas_aggiornata.conclusa = True
procedura_vas_aggiornata.save()
if _piano.is_eligible_for_promotion:
_piano.fase = _fase = Fase.objects.get(nome=_piano.next_phase)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="piano_phase_changed")
_piano.save()
fase.promuovi_piano(_fase, _piano)
return cls(procedura_vas_aggiornata=procedura_vas_aggiornata)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
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:
if not cls.autorita_ok(piano, TIPOLOGIA_CONTATTO.genio_civile):
raise Exception("Missing %s" %
TIPOLOGIA_CONTATTO.genio_civile)
if not cls.autorita_ok(
piano, TIPOLOGIA_ATTORE.regione, contatto=False):
raise Exception("Missing %s" % TIPOLOGIA_ATTORE.regione)
_avvio_procedimento.stato = STATO_AZIONE.nessuna
_avvio_procedimento.data = datetime.datetime.now(
timezone.get_current_timezone())
_avvio_procedimento.save()
_formazione_del_piano = Azione(
tipologia=TIPOLOGIA_AZIONE.formazione_del_piano,
attore=TIPOLOGIA_ATTORE.comune,
order=_order,
stato=STATO_AZIONE.necessaria)
_formazione_del_piano.save()
_order += 1
AzioniPiano.objects.get_or_create(azione=_formazione_del_piano,
piano=piano)
_richiesta_integrazioni = Azione(
tipologia=TIPOLOGIA_AZIONE.richiesta_integrazioni,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa)
_richiesta_integrazioni.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_richiesta_integrazioni, piano=piano)
if procedura_avvio.conferenza_copianificazione == TIPOLOGIA_CONF_COPIANIFIZAZIONE.necessaria:
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc = ConferenzaCopianificazione(piano=piano)
_cc.data_richiesta_conferenza = datetime.datetime.now(
timezone.get_current_timezone())
_cc.data_scadenza_risposta = procedura_avvio.data_scadenza_risposta
_cc.save()
_esito_conferenza_copianificazione = Azione(
tipologia=TIPOLOGIA_AZIONE.
esito_conferenza_copianificazione,
attore=TIPOLOGIA_ATTORE.regione,
order=_order,
stato=STATO_AZIONE.attesa)
_esito_conferenza_copianificazione.save()
_order += 1
AzioniPiano.objects.get_or_create(
azione=_esito_conferenza_copianificazione, piano=piano)
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=user,
piano=piano,
message_type="conferenza_copianificazione")
elif procedura_avvio.conferenza_copianificazione == TIPOLOGIA_CONF_COPIANIFIZAZIONE.posticipata:
procedura_avvio.notifica_genio_civile = False
procedura_avvio.save()
_cc = ConferenzaCopianificazione(piano=piano)
_cc.data_scadenza_risposta = procedura_avvio.data_scadenza_risposta
_cc.save()
_conferenza_copianificazione = Azione(
tipologia=TIPOLOGIA_AZIONE.
richiesta_conferenza_copianificazione,
attore=TIPOLOGIA_ATTORE.comune,
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)
elif procedura_avvio.conferenza_copianificazione == TIPOLOGIA_CONF_COPIANIFIZAZIONE.non_necessaria:
procedura_avvio.notifica_genio_civile = True
procedura_avvio.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 mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_consultazione_vas = ConsultazioneVAS.objects.filter(
procedura_vas=_procedura_vas).order_by('data_creazione').first()
_piano = _procedura_vas.piano
_token = info.context.session[
'token'] if 'token' in info.context.session else None
_organization = _piano.ente
if info.context.user and \
rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano) and \
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'SCA'):
try:
if _procedura_vas.risorse.filter(
tipo='parere_sca',
archiviata=False,
user=info.context.user).count() == 0:
return GraphQLError(_("Forbidden"), code=403)
_avvio_consultazioni_sca_count = _piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.avvio_consultazioni_sca).count(
)
_pareri_vas_count = ParereVAS.objects.filter(
user=info.context.user,
procedura_vas=_procedura_vas,
consultazione_vas=_consultazione_vas)
print('%s / %s' % (_pareri_vas_count.count(),
_avvio_consultazioni_sca_count))
if _pareri_vas_count.count() == (
_avvio_consultazioni_sca_count - 1):
_parere_vas = ParereVAS(
inviata=True,
user=info.context.user,
procedura_vas=_procedura_vas,
consultazione_vas=_consultazione_vas,
)
_parere_vas.save()
elif _pareri_vas_count.count(
) != _avvio_consultazioni_sca_count:
return GraphQLError(_("Forbidden"), code=403)
_tutti_pareri_inviati = True
for _sca in _piano.soggetti_sca.all():
_pareri_vas_count = ParereVAS.objects.filter(
user=_sca.user,
procedura_vas=_procedura_vas,
consultazione_vas=_consultazione_vas).count()
if _pareri_vas_count != _avvio_consultazioni_sca_count:
_tutti_pareri_inviati = False
break
if _tutti_pareri_inviati:
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="tutti_pareri_inviati")
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_vas)
return InvioPareriVAS(vas_aggiornata=_procedura_vas, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
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,
)
