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 check_product(cls, product):
if product.is_sold_out:
raise GraphQLError(_('티켓이 모두 판매되었습니다.'))
if product.is_not_open_yet():
raise GraphQLError(_('티켓 판매가 아직 시작되지 않았습니다.'))
if product.is_closed():
raise GraphQLError(_('티켓 판매가 종료되었습니다.'))
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, 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):
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, file, **input):
if rules.test_rule('strt_core.api.can_access_private_area', info.context.user):
# Fetching input arguments
_codice_piano = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Piano'
_piano = Piano.objects.get(codice=_codice_piano)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_codice_piano,
_piano.fase,
_tipo_file
)
_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)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
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(self, info, data):
user = info.context.user
schedule = Schedule.objects.last()
presentation, created = Presentation.objects.get_or_create(owner=user)
if created and schedule.presentation_proposal_finish_at and \
schedule.presentation_proposal_finish_at < now():
raise GraphQLError(_('발표 제안 기간이 종료되었습니다.'))
if not schedule.presentation_proposal_start_at or \
schedule.presentation_proposal_start_at > now():
raise GraphQLError(_('발표 모집이 아직 시작되지 않았습니다.'))
if schedule.presentation_review_start_at < now(
) < schedule.presentation_review_finish_at:
raise GraphQLError(_('오픈 리뷰 중에는 제안서를 수정할 수 없습니다.'))
if 'category_id' in data:
presentation.category = Category.objects.get(
pk=data['category_id'])
del data['category_id']
if 'difficulty_id' in data:
presentation.difficulty = Difficulty.objects.get(
pk=data['difficulty_id'])
del data['difficulty_id']
for k, v in data.items():
setattr(presentation, k, v)
presentation.full_clean()
presentation.save()
return CreateOrUpdatePresentationProposal(proposal=presentation)
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), 'AC'):
try:
_pareri_verifica_sca = _piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pareri_verifica_sca).first()
if _pareri_verifica_sca and _pareri_verifica_sca.stato != STATO_AZIONE.nessuna:
return GraphQLError(_("Forbidden"), code=403)
if not _procedura_vas.verifica_effettuata and \
_procedura_vas.tipologia in (TIPOLOGIA_VAS.verifica, TIPOLOGIA_VAS.semplificata):
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
else:
return GraphQLError(_("Forbidden"), code=403)
return AssoggettamentoVAS(
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, file, **input):
if info.context.user and rules.test_rule(
'strt_core.api.can_access_private_area', info.context.user):
# Fetching input arguments
_uuid_avvio = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Procedura VAS'
_procedura_avvio = ProceduraAvvio.objects.get(uuid=_uuid_avvio)
if rules.test_rule('strt_core.api.can_edit_piano',
info.context.user, _procedura_avvio.piano):
_resources = UploadBaseBase.handle_uploaded_data(
file, _uuid_avvio, _procedura_avvio.piano.fase,
_tipo_file, info.context.user)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseAvvio(procedura_avvio=_procedura_avvio,
risorsa=_risorsa).save()
return UploadRisorsaAvvio(
procedura_avvio_aggiornata=_procedura_avvio,
success=_success,
file_name=_resources[0].nome)
else:
return GraphQLError(_("Forbidden"), code=403)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
def mutate(cls, root, info, **input):
if info.context.user and rules.test_rule(
'strt_core.api.can_access_private_area', info.context.user):
# 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:
_conferenza_copianificazione = ConferenzaCopianificazione.objects.get(
uuid=_uuid_cc)
if rules.test_rule('strt_core.api.can_edit_piano',
info.context.user,
_conferenza_copianificazione.piano):
_risorsa = Risorsa.objects.get(uuid=_id)
_success = DeleteRisorsaBase.handle_downloaded_data(
_risorsa)
return DeleteRisorsaCopianificazione(
conferenza_copianificazione_aggiornata=
_conferenza_copianificazione,
success=_success)
else:
return GraphQLError(_("Forbidden"), code=403)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
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 mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_piano = _procedura_avvio.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_avvio,
info.context.user)
# Notify Users
"""
TODO
"""
# piano_phase_changed.send(
# sender=Piano,
# user=info.context.user,
# piano=_piano,
# message_type="piano_phase_changed")
return IntegrazioniRichieste(avvio_aggiornato=_procedura_avvio,
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_and_get_payload(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_vas = ProceduraVAS.objects.get(piano=_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') or
rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'AC')):
try:
nuova_consultazione_vas = ConsultazioneVAS()
nuova_consultazione_vas.user = info.context.user
nuova_consultazione_vas.procedura_vas = _procedura_vas
_consultazioni_vas_expire_days = getattr(
settings, 'CONSULTAZIONI_SCA_EXPIRE_DAYS', 90)
nuova_consultazione_vas.data_scadenza = datetime.datetime.now(timezone.get_current_timezone()) + \
datetime.timedelta(days=_consultazioni_vas_expire_days)
nuova_consultazione_vas.save()
return cls(nuova_consultazione_vas=nuova_consultazione_vas)
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):
_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_and_get_payload(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_vas_data = input.get('procedura_vas')
if rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano):
try:
# ProceduraVAS (M)
_procedura_vas_data['piano'] = _piano
# Ente (M)
_procedura_vas_data['ente'] = _piano.ente
# Note (O)
if 'note' in _procedura_vas_data:
_data = _procedura_vas_data.pop('note')
_procedura_vas_data['note'] = _data[0]
_procedura_vas = ProceduraVAS()
_procedura_vas.piano = _piano
_procedura_vas_data['id'] = _procedura_vas.id
_procedura_vas_data['uuid'] = _procedura_vas.uuid
nuova_procedura_vas = update_create_instance(_procedura_vas, _procedura_vas_data)
return cls(nuova_procedura_vas=nuova_procedura_vas)
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_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, file, **input):
if rules.test_rule('strt_core.api.can_access_private_area', info.context.user):
# Fetching input arguments
_uuid_vas = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Procedura VAS'
_procedura_vas = ProceduraVAS.objects.get(uuid=_uuid_vas)
_resources = UploadBaseBase.handle_uploaded_data(
file,
_uuid_vas,
_procedura_vas.piano.fase,
_tipo_file
)
_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)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
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_and_get_payload(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_adozione_data = input.get('procedura_adozione')
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.can_update_piano', info.context.user, _piano):
try:
# ProceduraAdozione (M)
_procedura_adozione_data['piano'] = _piano
# Ente (M)
_procedura_adozione_data['ente'] = _piano.ente
_procedura_adozione = ProceduraAdozione()
_procedura_adozione.piano = _piano
_procedura_adozione.ente = _piano.ente
_procedura_adozione_data['id'] = _procedura_adozione.id
_procedura_adozione_data['uuid'] = _procedura_adozione.uuid
nuova_procedura_adozione = update_create_instance(
_procedura_adozione, _procedura_adozione_data)
_piano.procedura_adozione = nuova_procedura_adozione
_piano.save()
return cls(nuova_procedura_adozione=nuova_procedura_adozione)
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_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 require_action(piano: Piano, tipo_file, tipo_risorsa: TipoRisorsa, tipo_azione: TipologiaAzione):
if tipo_file == tipo_risorsa.value:
_az = piano.getFirstAction(tipo_azione)
if _az is None:
raise GraphQLError('Risorsa inaspettata: azione richiesta "{}"'.format(tipo_azione.value), code=403)
if is_scaduta(_az) or is_executed(_az):
raise GraphQLError('Risorsa non più accettabile', code=403)
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):
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(self, info, **input):
if not ProfiloUtente.objects\
.filter(utente=info.context.user, profilo=Profilo.ADMIN_ENTE)\
.exists():
return GraphQLError(
"Utente non abilitato alle eliminazioni di piano", code=403)
# Fetching input arguments
_id = input['codice_piano']
try:
_piano = Piano.objects.get(codice=_id)
if ProfiloUtente.objects\
.filter(utente=info.context.user, profilo=Profilo.ADMIN_ENTE, ente=_piano.ente)\
.exists():
logger.warning("Eliminazione Piano {}".format(_piano))
_piano.delete()
return DeletePiano(success=True, codice_piano=_id)
else:
return GraphQLError("Utente non abilitato in questo ente",
code=403)
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 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):
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_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
# 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)