def mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_piano = _procedura_avvio.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_avvio,
info.context.user)
return AvvioPiano(avvio_aggiornato=_procedura_avvio, errors=[])
except GraphQLError as e:
return e
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_approvazione = ProceduraApprovazione.objects.get(
uuid=input['uuid'])
_piano = _procedura_approvazione.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,
QualificaRichiesta.REGIONE):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_approvazione,
info.context.user)
check_and_promote(_piano, info)
return AttribuzioneConformitaPIT(
approvazione_aggiornata=_procedura_approvazione, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_adozione = ProceduraAdozione.objects.get(uuid=input['uuid'])
_piano = _procedura_adozione.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)
if not _procedura_adozione.pubblicazione_burt_url \
or not _procedura_adozione.pubblicazione_burt_data \
or not _procedura_adozione.pubblicazione_burt_bollettino \
or not _procedura_adozione.pubblicazione_sito_url:
return GraphQLError("Dati BURT non impostati", code=409)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user)
return PubblicazioneBurt(adozione_aggiornata=_procedura_adozione,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraAdozioneVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
_procedura_adozione = ProceduraAdozione.objects.get(piano=_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)
if not _procedura_adozione.pubblicazione_burt_data:
return GraphQLError("Errore - burtdata mancante", code=500)
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user)
check_and_promote(_piano, info)
return UploadElaboratiAdozioneVAS(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PROVVEDIMENTO_VERIFICA_VAS.value, archiviata=False)\
.exists():
return GraphQLError("File mancante: {}".format(
TipoRisorsa.PROVVEDIMENTO_VERIFICA_VAS.value),
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return EmissioneProvvedimentoVerifica(
vas_aggiornata=_procedura_vas, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_piano = _procedura_avvio.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.GC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
# check risorsa
if not _piano.risorse\
.filter(tipo=TipoRisorsa.DOCUMENTO_GENIO_CIVILE.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("Risorsa mancante: {}".format(
TipoRisorsa.DOCUMENTO_GENIO_CIVILE.value),
code=409)
try:
closed = cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_avvio,
info.context.user)
if closed:
check_and_promote(_piano, info)
return InvioProtocolloGenioCivile(
avvio_aggiornato=_procedura_avvio, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
errs = []
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PARERE_AC.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File relativo al pareri AC mancante",
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return TrasmissionePareriAC(vas_aggiornata=_procedura_vas,
errors=errs)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
if not _procedura_vas.risorse \
.filter(tipo=TipoRisorsa.DOCUMENTO_PRELIMINARE_VERIFICA_VAS.value, archiviata=False) \
.exists():
return GraphQLError("File mancante: {}".format(
TipoRisorsa.DOCUMENTO_PRELIMINARE_VERIFICA_VAS.value),
code=409)
if not SoggettoOperante.get_by_qualifica(_piano, Qualifica.SCA).exists() and \
not Delega.objects.filter(qualifica=Qualifica.SCA, delegante__piano=_piano).exists():
return GraphQLError("Non sono associati SCA al piano",
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return InvioPareriVerificaVAS(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
# check generico sul piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
# check specifico azione
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
# check risorsa
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.DOCUMENTO_PRELIMINARE_VAS.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("Risorsa mancante: {}".format(
TipoRisorsa.DOCUMENTO_PRELIMINARE_VAS.value),
code=409)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return InvioDocPreliminare(procedura_vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
if not _procedura_vas.pubblicazione_provvedimento_verifica_ac:
return GraphQLError("URL di pubblicazione non impostata", code=409)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info)
return PubblicazioneProvvedimentoVerificaAc(
vas_aggiornata=_procedura_vas, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
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):
_procedura_vas = ProceduraAdozioneVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
_procedura_adozione = ProceduraAdozione.objects.get(piano=_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.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
if not _procedura_adozione.pubblicazione_burt_data:
return GraphQLError("Errore - burtdata mancante", code=500)
try:
# _tutti_pareri_inviati = True
# for _sca in _piano.soggetti_sca.all():
# _pareri_vas_count = ParereAdozioneVAS.objects.filter(
# user=_sca.user,
# procedura_adozione=_procedura_adozione
# ).count()
#
# if _pareri_vas_count == 0:
# _tutti_pareri_inviati = False
# break
#
# if _tutti_pareri_inviati:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user)
return InvioParereMotivatoAC(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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:
errs = []
for tipo in [
TipoRisorsa.RAPPORTO_AMBIENTALE,
TipoRisorsa.SINTESI_NON_TECNICA
]:
if not _procedura_vas.risorse\
.filter(tipo=tipo.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File mancante: {}".format(tipo.value),
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
if try_and_close_avvio(_piano):
check_and_promote(_piano, info) # check for auto promotion
return RedazioneDocumentiVAS(vas_aggiornata=_procedura_vas,
errors=errs)
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'])
_procedura_vas = ProceduraVAS.objects.get(piano=_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_vas,
info.context.user)
check_and_promote(_piano, info)
return FormazionePiano(piano_aggiornato=_piano, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate_and_get_payload(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice'])
_piano_input = input.get('piano_operativo')
_ente = _piano.ente
if not info.context.user:
return GraphQLError("Unauthorized", code=401)
# Primo chek generico di autorizzazione
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
try:
for fixed_field in [
'codice', 'data_creazione', 'data_accettazione',
'data_avvio', 'data_approvazione', 'ente', 'fase',
'tipologia', 'data_protocollo_genio_civile', 'responsabile'
]:
if fixed_field in _piano_input:
logger.warning(
'Il campo "{}" non può essere modificato attraverso questa operazione'
.format(fixed_field))
_piano_input.pop(fixed_field)
# TODO: check what to do with 'data_delibera'
# ############################################################ #
# Editable fields - consistency checks
# ############################################################ #
# Descrizione (O)
if 'descrizione' in _piano_input:
_data = _piano_input.pop('descrizione')
# if rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano):
_piano.descrizione = _data[0]
# Data Delibera (O)
# if 'data_delibera' in _piano_input:
# if not rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano):
# _piano_input.pop('data_delibera')
# This cannot be changed
# Soggetto Proponente (O)
if 'soggetto_proponente_uuid' in _piano_input:
if not auth.can_edit_piano(info.context.user, _piano,
Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione",
code=403)
_soggetto_proponente_uuid = _piano_input.pop(
'soggetto_proponente_uuid')
if _soggetto_proponente_uuid:
ufficio = Ufficio.objects.filter(
uuid=_soggetto_proponente_uuid).get()
if not ufficio:
return GraphQLError(
_("Not found - Ufficio proponente sconosciuto"),
code=404)
qu = QualificaUfficio.objects.filter(
ufficio=ufficio, qualifica=Qualifica.OPCOM).get()
if not qu:
return GraphQLError(_(
"Not found - L'ufficio proponente non è responsabile di Comune"
),
code=404)
_piano.soggetto_proponente = qu
else:
_piano.soggetto_proponente = None
if 'soggetti_operanti' in _piano_input:
# if not auth.is_soggetto(info.context.user, _piano):
# return GraphQLError(_("Forbidden - L'utente non è soggetto"), code=403)
_soggetti_operanti = _piano_input.pop(
'soggetti_operanti') # potrebbe essere vuoto
old_so_qs = SoggettoOperante.objects.filter(piano=_piano)
old_so_dict = {
so.qualifica_ufficio.ufficio.uuid.__str__() + "_" +
so.qualifica_ufficio.qualifica.name: so
for so in old_so_qs
}
add_so = []
for _so in _soggetti_operanti:
uff = Ufficio.objects.filter(uuid=_so.ufficio_uuid).get()
qualifica = Qualifica.fix_enum(
_so.qualifica, none_on_error=True) # TODO: 404
hash = _so.ufficio_uuid + "_" + qualifica.name
if hash in old_so_dict:
del old_so_dict[hash]
else:
qu = QualificaUfficio.objects \
.filter(ufficio=uff, qualifica=qualifica).get()
new_so = SoggettoOperante(qualifica_ufficio=qu,
piano=_piano)
add_so.append(new_so)
# pre-check
# - OPCOM può modificare SO con qualunque qualifica
# - AC può modificare SO con qualifica SCA
for so in list(old_so_dict.values()) + add_so:
if not auth.has_qualifica(info.context.user, _ente,
Qualifica.OPCOM):
if so.qualifica_ufficio.qualifica == Qualifica.SCA:
if not auth.has_qualifica(info.context.user, _ente,
Qualifica.AC):
return GraphQLError(
"Utente non abilitato alla modifica di questo SoggettoOperante",
code=403)
# remove all SO left in the old_so_dict since they are not in the input list
for so in old_so_dict.values():
for d in Delega.objects.filter(delegante=so):
d.token.delete()
d.delete()
so.delete()
# create new SO
for so in add_so:
so.save()
piano_aggiornato = update_create_instance(_piano, _piano_input)
return cls(piano_aggiornato=piano_aggiornato)
except (Ufficio.DoesNotExist, QualificaUfficio.DoesNotExist) as e:
return GraphQLError(e, code=404)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_ad_vas: ProceduraAdozioneVAS = ProceduraAdozioneVAS.objects.get(
uuid=input['uuid'])
_piano: Piano = _procedura_ad_vas.piano
_procedura_adozione: ProceduraAdozione = ProceduraAdozione.objects.get(
piano=_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,
QualificaRichiesta.SCA):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
# controlla se l'utente ha caricato il suo file parere
_esiste_risorsa = _procedura_ad_vas.risorse\
.filter(tipo=TipoRisorsa.PARERE_ADOZIONE_SCA.value, archiviata=False, user=info.context.user)\
.exists()
if not _esiste_risorsa:
logger.warning("RISORSA NON TROVATA per utente {}".format(
info.context.user))
for r in _procedura_ad_vas.risorse.filter(archiviata=False):
logger.warning('Risorsa {tipo} per utente {u}'.format(
tipo=r.tipo, u=r.user))
for r in RisorseAdozioneVas.objects.all():
logger.warning(
'RisorseAdozioneVas {tipo} per utente {u}'.format(
tipo=r.risorsa.tipo, u=r.risorsa.user))
return GraphQLError("File relativo al pareri SCA mancante",
code=409)
# controlla se l'utente ha già validato il parere
_esiste_parere_ad_vas = ParereAdozioneVAS.objects\
.filter(user=info.context.user, procedura_adozione=_procedura_adozione)\
.exists()
if _esiste_parere_ad_vas:
return GraphQLError("Parere SCA esistente per questo utente")
# ok, salva parere
_parere_vas = ParereAdozioneVAS(
inviata=True,
user=info.context.user,
procedura_adozione=_procedura_adozione)
_parere_vas.save()
# controlla se l'azione può essere chiusa
_tutti_pareri_inviati = True
for _so_sca in SoggettoOperante.get_by_qualifica(
_piano, Qualifica.SCA):
ass = Assegnatario.objects.filter(
qualifica_ufficio=_so_sca.qualifica_ufficio)
# todo aggiungi token
utenti_sca = [a.utente for a in ass]
_parere_sent = ParereAdozioneVAS.objects\
.filter(
procedura_adozione=_procedura_adozione,
user__in=utenti_sca)\
.exists()
if not _parere_sent:
deleghe = Delega.objects.filter(delegante=_so_sca)
users = [d.token.user for d in deleghe]
_parere_sent = ParereAdozioneVAS.objects.filter(
procedura_adozione=_procedura_adozione,
user__in=users,
).exists()
if not _parere_sent:
_tutti_pareri_inviati = False
break
if _tutti_pareri_inviati:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_adozione,
info.context.user)
return InvioPareriAdozioneVAS(vas_aggiornata=_procedura_ad_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def resolve_eseguibile(self, info, **args):
qreq = self.qualifica_richiesta
user = info.context.user
piano = self.piano
return needs_execution(self) and can_edit_piano(user, piano, qreq)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.SCA):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
errs = []
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PARERE_SCA.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File relativo al pareri SCA mancante",
code=409)
# attenzione: se ci sono più utenti collegati ad uno stesso SO SCA, con questo controllo ognuno
# puo caricare il proprio parere.
_esiste_parere = ParereVAS.objects.filter(
user=info.context.user, procedura_vas=_procedura_vas).exists()
if not _esiste_parere:
_parere_vas = ParereVAS(
inviata=True,
user=info.context.user,
procedura_vas=_procedura_vas,
)
_parere_vas.save()
# controlliamo se tutti gli SCA associati al piano hanno dato parere
_tutti_pareri_inviati = True
for _so_sca in SoggettoOperante.get_by_qualifica(
_piano, Qualifica.SCA):
# controlla invio per assegnatari
ass = Assegnatario.objects.filter(
qualifica_ufficio=_so_sca.qualifica_ufficio)
utenti_sca = {a.utente for a in ass}
deleghe = Delega.objects.filter(delegante=_so_sca,
qualifica=Qualifica.SCA)
utenti_sca |= {
d.token.user
for d in deleghe if d.token.user is not None
}
_esiste_parere_sca = ParereVAS.objects\
.filter(
procedura_vas=_procedura_vas,
user__in=utenti_sca)\
.exists()
if not _esiste_parere_sca:
_tutti_pareri_inviati = False
errs.append('Parere mancante da {}'.format(
_so_sca.qualifica_ufficio.ufficio))
# non si effettua il break, così avremo la lista di tutti gli SCA mancanti
if _tutti_pareri_inviati:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_vas, info.context.user)
return TrasmissionePareriSCA(vas_aggiornata=_procedura_vas,
errors=errs)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate_and_get_payload(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_procedura_vas_data = input.get('procedura_vas')
_piano = _procedura_vas.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
_ente = _piano.ente
try:
# These fields cannot be changed
for field in ['piano', 'uuid', 'data_creazione', 'ente']:
if 'field' in _procedura_vas_data:
logger.warning(
'Il campo "{}" non può essere modificato attraverso questa operazione'
.format(field))
_procedura_vas_data.pop(field)
# These fields can be changed by the RESP only
# Tipologia (O)
if 'tipologia' in _procedura_vas_data:
_tipologia = _procedura_vas_data.pop('tipologia')
if auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
if _tipologia: # and _tipologia in TipologiaVAS:
_tipo_parsed = TipologiaVAS.fix_enum(
_tipologia, none_on_error=True)
if not _tipo_parsed:
return GraphQLError(
"Tipologia non riconosciuta [{}]".format(
_tipologia),
code=400)
_procedura_vas_data['tipologia'] = _tipo_parsed
else:
logger.info(
'Non si hanno i privilegi per modificare il campo "tipologia"'
)
# Note (O)
if 'note' in _procedura_vas_data:
_data = _procedura_vas_data.pop('note')
if auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
_procedura_vas.note = _data[0]
else:
logger.info(
'Non si hanno i privilegi per modificare il campo "note"'
)
# perform check before update
if _procedura_vas_data.pubblicazione_provvedimento_verifica_ap:
if not auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Non è permesso modificare un campo AP",
code=403)
if is_executed(
_piano.getFirstAction(
TipologiaAzione.
pubblicazione_provvedimento_verifica_ap)):
return GraphQLError(
"Il campo pubblicazione provvedimento è bloccato ",
code=403)
# perform check before update
if _procedura_vas_data.pubblicazione_provvedimento_verifica_ac:
if not auth.can_edit_piano(info.context.user, _piano,
Qualifica.AC):
return GraphQLError(
"Forbidden - Non è permesso modificare un campo AC",
code=403)
if is_executed(
_piano.getFirstAction(
TipologiaAzione.
pubblicazione_provvedimento_verifica_ac)):
return GraphQLError(
"Il campo pubblicazione provvedimento è bloccato ",
code=403)
# update!
procedura_vas_aggiornata = update_create_instance(
_procedura_vas, _procedura_vas_data)
return cls(procedura_vas_aggiornata=procedura_vas_aggiornata)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.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.SCA):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PARERE_VERIFICA_VAS.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File mancante: {}".format(
TipoRisorsa.PARERE_VERIFICA_VAS.value),
code=409)
_pareri_vas_count = ParereVerificaVAS.objects.filter(
user=info.context.user, procedura_vas=_procedura_vas).count()
if _pareri_vas_count == 0:
_parere_vas = ParereVerificaVAS(inviata=True,
user=info.context.user,
procedura_vas=_procedura_vas)
_parere_vas.save()
elif _pareri_vas_count == 1:
pass
else:
return GraphQLError(
"L'utente ha già inviato un parere verifica VAS", code=400)
_tutti_pareri_inviati = True
for _sca in SoggettoOperante.get_by_qualifica(
_piano, Qualifica.SCA):
# controlliamo che per ogni ufficio SCA assegnato come SO, almeno un assegnatario abbia inviato parere
assegnatari = Assegnatario.objects.filter(
qualifica_ufficio=_sca.qualifica_ufficio)
users = [a.utente for a in assegnatari]
_pareri_vas_exists = ParereVerificaVAS.objects.filter(
procedura_vas=_procedura_vas,
user__in=users,
).exists()
if not _pareri_vas_exists:
deleghe = Delega.objects.filter(delegante=_sca,
qualifica=Qualifica.SCA)
users = [d.token.user for d in deleghe]
_pareri_vas_exists = ParereVerificaVAS.objects.filter(
procedura_vas=_procedura_vas,
user__in=users,
).exists()
if not _pareri_vas_exists:
_tutti_pareri_inviati = False
break
if _tutti_pareri_inviati:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_vas, info.context.user)
return InvioPareriVerificaVAS(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
