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)
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)
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_and_get_payload(cls, root, info, **input):
_procedura_approvazione = ProceduraApprovazione.objects.get(
uuid=input['uuid'])
_procedura_approvazione_data = input.get('procedura_approvazione')
_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)
for fixed_field in ['uuid', 'piano', 'data_creazione', 'ente']:
if fixed_field in _procedura_approvazione_data:
logger.warning(
'Il campo "{}" non può essere modificato'.format(
fixed_field))
_procedura_approvazione_data.pop(fixed_field)
try:
procedura_approvazione_aggiornata = update_create_instance(
_procedura_approvazione, _procedura_approvazione_data)
return cls(procedura_approvazione_aggiornata=
procedura_approvazione_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.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, file, **input):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Not Authorized - Utente non riconosciuto", code=401)
# Fetching input arguments
_codice_piano = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Piano'
_piano = Piano.objects.get(codice=_codice_piano) # TODO 404
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_codice_piano,
_piano.fase,
_tipo_file,
info.context.user
)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorsePiano(piano=_piano, risorsa=_risorsa).save()
return UploadFile(piano_aggiornato=_piano, success=_success, file_name=_resources[0].nome)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
try:
key = input['token']
token: Token = Token.objects.get(key=key)
delega: Delega = Delega.objects.get(token=token)
piano = delega.delegante.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 can_admin_delega(info.context.user, delega):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questa delega",
code=403)
delega.token.delete()
delega.delete()
return DeleteDelega(errors=[])
except (Token.DoesNotExist, Delega.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_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_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_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_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 = 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):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Utente non autenticato", code=401)
# Fetching input arguments
_id = input['risorsa_id']
_uuid_vas = input['codice']
# TODO: Andrebbe controllato se la risorsa in funzione del tipo e della fase del piano è eliminabile o meno
try:
_procedura_vas = ProceduraVAS.objects.get(uuid=_uuid_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)
_risorsa = Risorsa.objects.get(uuid=_id)
if _risorsa.tipo == TipoRisorsa.PARERE_SCA.value:
# if not auth_vas.parere_sca_ok(info.context.user, _procedura_vas):
# return GraphQLError("Risorsa non eliminabile", code=403)
if is_executed(_piano.getFirstAction(TipologiaAzione.trasmissione_pareri_sca)):
return GraphQLError('Risorsa inviata e non modificabile', code=403)
if _risorsa.tipo == TipoRisorsa.PARERE_VERIFICA_VAS and \
not auth_vas.parere_verifica_vas_ok(info.context.user, _procedura_vas):
return GraphQLError("Risorsa non eliminabile", code=403)
_success = DeleteRisorsaBase.handle_downloaded_data(_risorsa)
return DeleteRisorsaVAS(procedura_vas_aggiornata=_procedura_vas, success=_success)
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):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Utente non autenticato", code=401)
# Fetching input arguments
_id = input['risorsa_id']
_uuid_cc = input['codice']
# TODO: Andrebbe controllato se la risorsa in funzione del tipo e della fase del piano è eliminabile o meno
try:
_piano_rev_post_cp = PianoRevPostCP.objects.get(uuid=_uuid_cc)
_piano = _piano_rev_post_cp.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403)
_risorsa = Risorsa.objects.get(uuid=_id)
_success = DeleteRisorsaBase.handle_downloaded_data(_risorsa)
return DeleteRisorsaPianoRevPostCP(
piano_rev_post_cp_aggiornato=_piano_rev_post_cp, success=_success)
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, file, **input):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Not Authorized - Utente non riconosciuto", code=401)
# Fetching input arguments
_uuid_vas = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Procedura VAS'
_procedura_vas = ProceduraVAS.objects.get(uuid=_uuid_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)
if _tipo_file == TipoRisorsa.PARERE_SCA.value:
# if _procedura_vas.risorse.filter(tipo=_tipo_file, archiviata=False, user=info.context.user).exists():
# return GraphQLError('Precondition failed - Non si possono aggiungere ulteriori pareri SCA', code=412)
if is_executed(_piano.getFirstAction(TipologiaAzione.trasmissione_pareri_sca)):
return GraphQLError('Risorsa inviata e non modificabile', code=403)
if _tipo_file == TipoRisorsa.PARERE_VERIFICA_VAS.value and \
not auth_vas.parere_verifica_vas_ok(info.context.user, _procedura_vas):
return GraphQLError('Precondition failed - Verifica VAS esistente', code=412)
# not rules.test_rule('strt_core.api.parere_verifica_vas_ok', info.context.user, _procedura_vas):
# return GraphQLError(_("Forbidden"), code=403)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_uuid_vas,
_procedura_vas.piano.fase,
_tipo_file,
info.context.user
)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseVas(procedura_vas=_procedura_vas, risorsa=_risorsa).save()
return UploadRisorsaVAS(
procedura_vas_aggiornata=_procedura_vas,
success=_success,
file_name=_resources[0].nome)
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_adozione = ProceduraAdozione.objects.get(uuid=input['uuid'])
_procedura_adozione_data = input.get('procedura_adozione')
_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)
for fixed_field in ['uuid', 'piano', 'data_creazione', 'ente']:
if fixed_field in _procedura_adozione_data:
logger.warning(
'Il campo "{}" non può essere modificato'.format(
fixed_field))
_procedura_adozione_data.pop(fixed_field)
try:
procedura_adozione_aggiornata = update_create_instance(
_procedura_adozione, _procedura_adozione_data)
# todo: impedire aggiornamenti burt se pubblicazione_burt eseguita
if procedura_adozione_aggiornata.data_delibera_adozione:
_expire_days = getattr(
settings, 'ADOZIONE_RICEZIONE_PARERI_EXPIRE_DAYS', 30)
_alert_delta = datetime.timedelta(days=_expire_days)
procedura_adozione_aggiornata.data_ricezione_pareri = \
procedura_adozione_aggiornata.data_delibera_adozione + _alert_delta
# todo: eliminare dal modello, la data viene calcolata su richiesta nel nodo di output
if procedura_adozione_aggiornata.pubblicazione_burt_data:
_expire_days = getattr(
settings, 'ADOZIONE_RICEZIONE_OSSERVAZIONI_EXPIRE_DAYS',
30)
_alert_delta = datetime.timedelta(days=_expire_days)
procedura_adozione_aggiornata.data_ricezione_osservazioni = \
procedura_adozione_aggiornata.pubblicazione_burt_data + _alert_delta
procedura_adozione_aggiornata.save()
return cls(
procedura_adozione_aggiornata=procedura_adozione_aggiornata)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, file, **input):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Not Authorized - Utente non riconosciuto", code=401)
# Fetching input arguments
_uuid_adozione = input['codice']
_tipo_file = input['tipo_file']
try:
_procedura_adozione = ProceduraAdozione.objects.get(uuid=_uuid_adozione)
_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)
require_action(_piano, _tipo_file,
TipoRisorsa.OSSERVAZIONI_ENTI, TipologiaAzione.osservazioni_enti)
require_action(_piano, _tipo_file,
TipoRisorsa.OSSERVAZIONI_PRIVATI, TipologiaAzione.upload_osservazioni_privati)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_uuid_adozione,
_procedura_adozione.piano.fase,
_tipo_file,
info.context.user
)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseAdozione(procedura_adozione=_procedura_adozione, risorsa=_risorsa).save()
return UploadRisorsaAdozione(
procedura_adozione_aggiornata=_procedura_adozione,
success=_success,
file_name=_resources[0].nome)
except GraphQLError as ge:
return ge
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_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_procedura_avvio_data = input.get('procedura_avvio')
_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)
for fixed_field in ['uuid', 'piano', 'data_creazione', 'ente']:
if fixed_field in _procedura_avvio_data:
logger.warning(
'Il campo "{}" non può essere modificato'.format(
fixed_field))
_procedura_avvio_data.pop(fixed_field)
try:
# Tipologia (O)
if 'conferenza_copianificazione' in _procedura_avvio_data:
if not auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Richiesta qualifica Responsabile",
code=403)
_conferenza_copianificazione = TipologiaCopianificazione.fix_enum(
_procedura_avvio_data.pop('conferenza_copianificazione'),
none_on_error=True)
if _conferenza_copianificazione:
_procedura_avvio_data[
'conferenza_copianificazione'] = _conferenza_copianificazione
procedura_avvio_aggiornata = update_create_instance(
_procedura_avvio, _procedura_avvio_data)
return cls(procedura_avvio_aggiornata=procedura_avvio_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 = 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, file, **input):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Forbidden - Utente non riconosciuto", code=403)
# Fetching input arguments
_uuid_cc = input['codice']
_tipo_file = input['tipo_file']
try:
_conferenza_copianificazione = ConferenzaCopianificazione.objects.get(uuid=_uuid_cc)
_piano = _conferenza_copianificazione.piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_uuid_cc,
_conferenza_copianificazione.piano.fase,
_tipo_file,
info.context.user
)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseCopianificazione(
conferenza_copianificazione=_conferenza_copianificazione,
risorsa=_risorsa).save()
return UploadRisorsaCopianificazione(
conferenza_copianificazione_aggiornata=_conferenza_copianificazione,
success=_success,
file_name=_resources[0].nome)
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'])
# 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:
promoted, errors = check_and_promote(_piano, info)
if promoted:
return PromozionePiano(piano_aggiornato=_piano, errors=[])
else:
return GraphQLError("Dati non corretti",
code=409,
errors=errors)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, file, **input):
if not auth.is_recognizable(info.context.user):
return GraphQLError("Not Authorized - Utente non riconosciuto", code=401)
# Fetching input arguments
_uuid_vas = input['codice']
_tipo_file = input['tipo_file']
try:
_procedura_vas = ProceduraAdozioneVAS.objects.get(uuid=_uuid_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)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_uuid_vas,
_procedura_vas.piano.fase,
_tipo_file,
info.context.user
)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseAdozioneVas(procedura_adozione_vas=_procedura_vas, risorsa=_risorsa).save()
return UploadRisorsaAdozioneVAS(
procedura_vas_aggiornata=_procedura_vas,
success=_success,
file_name=_resources[0].nome)
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 __call__(self, request):
# Code to be executed for each request before the view (and later middleware) are called.
def create_redirect_piano(request, piano):
return HttpResponseRedirect(
'{request_path}/#/piano/{piano}/home'.format(
request_path=request.path, piano=piano.codice))
# Read token either from param or from header
token = request.GET.get('token', None)
if token is None:
auth_header = request.META.get('HTTP_AUTHORIZATION', b'').split()
if auth_header and auth_header[0].lower() == b'token':
# If they specified an invalid token, let them know.
if len(auth_header) != 2:
return HttpResponseBadRequest("Improperly formatted token")
token = auth_header[1]
if token:
if not is_recognizable(request.user):
logger.debug("Token specificato su utente sconosciuto")
redirected = request.GET.get('redirected_by', None)
if not redirected == 'TokenMiddleware': # did we just redirect this
return HttpResponseRedirect(
'{login_path}?next={request_path}%3Ftoken={token}&redirected_by=TokenMiddleware'
.format(login_path=getattr(settings, 'LOGIN_URL', '/'),
request_path=request.path,
token=token))
else:
logger.debug(
"Token e utente specificati. Token [{}]".format(token))
t: Token = Token.objects.filter(key=token).first()
if t:
if not t.is_expired():
utente = request.user
d: Delega = Delega.objects.get(token=t)
piano = d.delegante.piano
if t.user is None:
ok, err = assegna_token(d, utente)
return create_redirect_piano(request, piano)
elif t.user == utente:
logger.info("Token già in uso [{}]".format(token))
return create_redirect_piano(request, piano)
else:
logger.warning(
"Token già assegnato ad altro utente [{}]".
format(token))
# se l'utente ha cmq accesso al piano, usiamo il token come semplice bookmark
if can_access_piano(utente, piano):
return create_redirect_piano(request, piano)
else:
logger.warning("Token expired [{}]".format(token))
else:
logger.warning("Token non trovato [{}]".format(token))
# ------------------------
# calls the view
response = self.get_response(request)
# ------------------------
# Code to be executed for each request/response after the view is called.
return response
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 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):
def _get_or_create_resp_so():
so = auth.get_so(info.context.user, _piano,
Qualifica.OPCOM).first()
if not so:
# l'utente non ha SO direttamente associato, quindi lo creiamo
ass = get_assegnamenti(info.context.user, _piano.ente,
Qualifica.OPCOM).first()
so = SoggettoOperante(piano=_piano,
qualifica_ufficio=ass.qualifica_ufficio)
so.save()
return so
_piano = Piano.objects.get(codice=input['codice_piano'])
# Primo check 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:
qualifica = Qualifica.fix_enum(input['qualifica'],
none_on_error=True)
is_resp = auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM)
if not qualifica:
return GraphQLError("Qualifica sconosciuta", code=404)
elif qualifica == Qualifica.OPCOM:
return GraphQLError("Qualifica non delegabile", code=400)
elif qualifica == Qualifica.READONLY:
# associa alla delega un qualiasi SO associato all'utente
so = auth.get_so(info.context.user, _piano).first()
if not so:
if is_resp:
# l'utente è RESP per l'ente, ma non ha SO direttamente associato, quindi lo creiamo
so = _get_or_create_resp_so()
else:
return GraphQLError(
"Forbidden - Utente non assegnatario", code=403)
else:
#
so = auth.get_so(info.context.user, _piano, qualifica).first()
if not so:
if is_resp:
# l'utente è RESP per l'ente, ma non ha SO direttamente associato, quindi lo creiamo
so = _get_or_create_resp_so()
else:
return GraphQLError(
"Forbidden - Qualifica non assegnabile", code=403)
token = Token()
token.key = Token.generate_key()
token.expires = datetime.datetime.now() + datetime.timedelta(
days=30) # TODO
token.save()
delega = Delega()
delega.qualifica = qualifica
delega.delegante = so
delega.created_by = info.context.user
delega.token = token
delega.save()
# TODO: USE EMAIL
# piano_phase_changed.send(
# sender=Piano,
# user=info.context.user,
# piano=_piano,
# message_type="delega")
return CreaDelega(token=token.key, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)