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)