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_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_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_and_get_payload(cls, root, info, **input): _procedura_adozione = ProceduraAdozione.objects.get(uuid=input['uuid']) _procedura_adozione_data = input.get('procedura_adozione') if 'piano' in _procedura_adozione_data: # This cannot be changed _procedura_adozione_data.pop('piano') _piano = _procedura_adozione.piano # _token = info.context.session['token'] if 'token' in info.context.session else None # _ente = _piano.ente if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_adozione_data: _procedura_adozione_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_adozione_data: _procedura_adozione_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_adozione_data: _procedura_adozione_data.pop('ente') # This cannot be changed procedura_adozione_aggiornata = update_create_instance( _procedura_adozione, _procedura_adozione_data) 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 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) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): try: if info.context.user and \ rules.test_rule('strt_users.is_superuser', info.context.user): _data = input.get('fase') _fase = Fase() nuova_fase = update_create_instance(_fase, _data) return cls(nuova_fase=nuova_fase) else: return GraphQLError(_("Forbidden"), code=403) 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_and_get_payload(cls, root, info, **input): _procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid']) _procedura_avvio_data = input.get('procedura_avvio') if 'piano' in _procedura_avvio_data: # This cannot be changed _procedura_avvio_data.pop('piano') _piano = _procedura_avvio.piano _token = info.context.session[ 'token'] if 'token' in info.context.session else None _ente = _piano.ente if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_avvio_data: _procedura_avvio_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_avvio_data: _procedura_avvio_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_avvio_data: _procedura_avvio_data.pop('ente') # This cannot be changed # Tipologia (O) if 'conferenza_copianificazione' in _procedura_avvio_data and \ (rules.test_rule('strt_users.is_superuser', info.context.user) or is_RUP(info.context.user) or rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune')): _conferenza_copianificazione = _procedura_avvio_data.pop( 'conferenza_copianificazione') if _conferenza_copianificazione and _conferenza_copianificazione in TIPOLOGIA_CONF_COPIANIFIZAZIONE: _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) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): _consultazione_vas = ConsultazioneVAS.objects.get(uuid=input['uuid']) _consultazione_vas_data = input.get('consultazione_vas') _piano = _consultazione_vas.procedura_vas.piano if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: consultazione_vas_aggiornata = update_create_instance( _consultazione_vas, _consultazione_vas_data) return cls( consultazione_vas_aggiornata=consultazione_vas_aggiornata) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): try: if info.context.user and \ rules.test_rule('strt_users.is_superuser', info.context.user): try: _instance = Fase.objects.get(codice=input['codice']) if _instance: _data = input.get('fase') fase_aggiornata = update_create_instance(_instance, _data) return cls(fase_aggiornata=fase_aggiornata) except ValidationError as e: return cls(fase_aggiornata=None, errors=get_errors(e)) else: return GraphQLError(_("Forbidden"), code=403) 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): try: _piano_data = input.get('piano_operativo') # Ente (M) _data = _piano_data.pop('ente') _ente = Organization.objects.get(usermembership__member=info.context.user, code=_data['code']) _piano_data['ente'] = _ente if rules.test_rule('strt_users.is_RUP_of', info.context.user, _ente): # Codice (M) if 'codice' in _piano_data: _data = _piano_data.pop('codice') _codice = _data else: _year = str(datetime.date.today().year)[2:] _month = datetime.date.today().month _piano_id = Piano.objects.filter(ente=_ente).count() + 1 _codice = '%s%02d%02d%05d' % (_ente.code, int(_year), _month, _piano_id) _piano_data['codice'] = _codice # Fase (O) if 'fase' in _piano_data: _data = _piano_data.pop('fase') _fase = Fase.objects.get(codice=_data['codice']) else: _fase = Fase.objects.get(codice='FP255') _piano_data['fase'] = _fase # Descrizione (O) if 'descrizione' in _piano_data: _data = _piano_data.pop('descrizione') _piano_data['descrizione'] = _data[0] _piano_data['user'] = info.context.user _piano = Piano() nuovo_piano = update_create_instance(_piano, _piano_data) _procedura_vas = ProceduraVAS() _procedura_vas.piano = nuovo_piano _procedura_vas.ente = nuovo_piano.ente _procedura_vas.tipologia = TIPOLOGIA_VAS.semplificata _procedura_vas.save() return cls(nuovo_piano=nuovo_piano) else: return GraphQLError(_("Forbidden"), code=403) 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_and_get_payload(cls, root, info, **input): _consultazione_vas = ConsultazioneVAS.objects.get(uuid=input['uuid']) _consultazione_vas_data = input.get('consultazione_vas') _piano = _consultazione_vas.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') or rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _organization), 'AC')): try: consultazione_vas_aggiornata = update_create_instance(_consultazione_vas, _consultazione_vas_data) return cls(consultazione_vas_aggiornata=consultazione_vas_aggiornata) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): _piano = Piano.objects.get(codice=input['codice_piano']) _procedura_vas_data = input.get('procedura_vas') _token = info.context.session['token'] if 'token' in info.context.session else None _ente = _piano.ente if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano) and \ rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano) and \ (rules.test_rule('strt_users.is_superuser', info.context.user) or is_RUP(info.context.user) or rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune')): 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, created = ProceduraVAS.objects.get_or_create( piano=_piano, ente=_piano.ente) _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) _piano.procedura_vas = nuova_procedura_vas _piano.save() 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_and_get_payload(cls, root, info, **input): _procedura_pubblicazione = ProceduraPubblicazione.objects.get( uuid=input['uuid']) _procedura_pubblicazione_data = input.get('procedura_pubblicazione') if 'piano' in _procedura_pubblicazione_data: # This cannot be changed _procedura_pubblicazione_data.pop('piano') _piano = _procedura_pubblicazione.piano # _token = info.context.session['token'] if 'token' in info.context.session else None # _ente = _piano.ente if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_pubblicazione_data: _procedura_pubblicazione_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_pubblicazione_data: _procedura_pubblicazione_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_pubblicazione_data: _procedura_pubblicazione_data.pop('ente') # This cannot be changed procedura_pubblicazione_aggiornata = update_create_instance( _procedura_pubblicazione, _procedura_pubblicazione_data) return cls(procedura_pubblicazione_aggiornata= procedura_pubblicazione_aggiornata) 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): _procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid']) _procedura_vas_data = input.get('procedura_vas') if 'piano' in _procedura_vas_data: # This cannot be changed _procedura_vas_data.pop('piano') _piano = _procedura_vas.piano if rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_vas_data: _procedura_vas_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_vas_data: _procedura_vas_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_vas_data: _procedura_vas_data.pop('ente') # This cannot be changed # Tipologia (O) if 'tipologia' in _procedura_vas_data: _tipologia = _procedura_vas_data.pop('tipologia') if _tipologia and _tipologia in TIPOLOGIA_VAS: _procedura_vas_data['tipologia'] = _tipologia # Note (O) if 'note' in _procedura_vas_data: _data = _procedura_vas_data.pop('note') _procedura_vas.note = _data[0] 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) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): try: _data = input.get('contatto') # Ente (M) if 'ente' in _data: _ente = _data.pop('ente') _ente = Organization.objects.get(usermembership__member=info.context.user, code=_ente['code']) _data['ente'] = _ente if rules.test_rule('strt_users.is_RUP_of', info.context.user, _data['ente']): # Tipologia (M) if 'tipologia' in _data: _tipologia = _data.pop('tipologia') if _tipologia and _tipologia in TIPOLOGIA_CONTATTO: _data['tipologia'] = _tipologia _contatto = Contatto() nuovo_contatto = update_create_instance(_contatto, _data) return cls(nuovo_contatto=nuovo_contatto) else: return GraphQLError(_("Forbidden"), code=403) 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_and_get_payload(cls, root, info, **input): try: _piano_data = input.get('piano_operativo') # Ente (M) _data = _piano_data.pop('ente') _ente = Organization.objects.get( usermembership__member=info.context.user, code=_data['code']) _piano_data['ente'] = _ente if info.context.user and rules.test_rule('strt_users.is_RUP_of', info.context.user, _ente): # Codice (M) if 'codice' in _piano_data: _data = _piano_data.pop('codice') _codice = _data else: _year = str(datetime.date.today().year)[2:] _month = datetime.date.today().month _piano_id = Piano.objects.filter(ente=_ente).count() + 1 _codice = '%s%02d%02d%05d' % (_ente.code, int(_year), _month, _piano_id) _piano_data['codice'] = _codice # Fase (O) if 'fase' in _piano_data: _data = _piano_data.pop('fase') _fase = Fase.objects.get(codice=_data['codice']) else: _fase = Fase.objects.get(codice='FP255') _piano_data['fase'] = _fase # Descrizione (O) if 'descrizione' in _piano_data: _data = _piano_data.pop('descrizione') _piano_data['descrizione'] = _data[0] _piano_data['user'] = info.context.user _piano = Piano() # Inizializzazione Azioni del Piano _order = 0 _azioni_piano = [] for _a in AZIONI_BASE[_fase.nome]: _azione = Azione(tipologia=_a["tipologia"], attore=_a["attore"], order=_order) _azioni_piano.append(_azione) _order += 1 # Inizializzazione Procedura VAS _procedura_vas = ProceduraVAS() _procedura_vas.tipologia = TIPOLOGIA_VAS.semplificata nuovo_piano = update_create_instance(_piano, _piano_data) _procedura_vas.piano = nuovo_piano _procedura_vas.ente = nuovo_piano.ente _procedura_vas.save() for _ap in _azioni_piano: _ap.save() AzioniPiano.objects.get_or_create(azione=_ap, piano=nuovo_piano) _creato = nuovo_piano.azioni.filter( tipologia=TIPOLOGIA_AZIONE.creato_piano).first() if _creato: _creato.stato = STATO_AZIONE.necessaria _creato.save() return cls(nuovo_piano=nuovo_piano) else: return GraphQLError(_("Forbidden"), code=403) 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_data = input.get('piano_operativo') 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: # Codice Piano (M) if 'codice' in _piano_data: _piano_data.pop('codice') # This cannot be changed # Data Accettazione (M) if 'data_creazione' in _piano_data: _piano_data.pop('data_creazione') # This cannot be changed # Data Accettazione (O) if 'data_accettazione' in _piano_data: _piano_data.pop('data_accettazione') # This cannot be changed # Data Avvio (O) if 'data_avvio' in _piano_data: _piano_data.pop('data_avvio') # This cannot be changed # Data Approvazione (O) if 'data_approvazione' in _piano_data: _piano_data.pop('data_approvazione') # This cannot be changed # Ente (M) if 'ente' in _piano_data: _piano_data.pop('ente') # This cannot be changed # Fase (O) if 'fase' in _piano_data: _piano_data.pop('fase') # This cannot be changed # Tipologia (O) if 'tipologia' in _piano_data: _piano_data.pop('tipologia') # This cannot be changed # ############################################################ # # Editable fields - consistency checks # ############################################################ # # Descrizione (O) if 'descrizione' in _piano_data: _data = _piano_data.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_data: if not rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano): _piano_data.pop('data_delibera') # This cannot be changed # Soggetto Proponente (O) if 'soggetto_proponente_uuid' in _piano_data: _soggetto_proponente_uuid = _piano_data.pop( 'soggetto_proponente_uuid') if rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano): if _piano.soggetto_proponente: UpdatePiano.delete_token( _piano.soggetto_proponente.user, _piano) _piano.soggetto_proponente = None if _soggetto_proponente_uuid and len( _soggetto_proponente_uuid) > 0: _soggetto_proponente = Contatto.objects.get( uuid=_soggetto_proponente_uuid) UpdatePiano.get_or_create_token( _soggetto_proponente.user, _piano) _piano.soggetto_proponente = _soggetto_proponente # Autorità Competente VAS (O) if 'autorita_competente_vas' in _piano_data: _autorita_competente_vas = _piano_data.pop( 'autorita_competente_vas') if rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano): _piano.autorita_competente_vas.clear() if _autorita_competente_vas: for _ac in _piano.autorita_competente_vas.all(): UpdatePiano.delete_token(_ac.user, _piano) if len(_autorita_competente_vas) > 0: _autorita_competenti = [] for _contatto_uuid in _autorita_competente_vas: _autorita_competenti.append( AutoritaCompetenteVAS( piano=_piano, autorita_competente=Contatto. objects.get(uuid=_contatto_uuid))) for _ac in _autorita_competenti: UpdatePiano.get_or_create_token( _ac.autorita_competente.user, _piano) _ac.save() # Soggetti SCA (O) if 'soggetti_sca' in _piano_data: _soggetti_sca_uuid = _piano_data.pop('soggetti_sca') if rules.test_rule('strt_core.api.can_update_piano', info.context.user, _piano): _piano.soggetti_sca.clear() if _soggetti_sca_uuid: for _sca in _piano.soggetti_sca.all(): UpdatePiano.delete_token(_sca.user, _piano) if len(_soggetti_sca_uuid) > 0: _soggetti_sca = [] for _contatto_uuid in _soggetti_sca_uuid: _soggetti_sca.append( SoggettiSCA( piano=_piano, soggetto_sca=Contatto.objects.get( uuid=_contatto_uuid))) for _sca in _soggetti_sca: UpdatePiano.get_or_create_token( _sca.soggetto_sca.user, _piano) _sca.save() piano_aggiornato = update_create_instance(_piano, _piano_data) return cls(piano_aggiornato=piano_aggiornato) 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): _procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid']) _procedura_vas_data = input.get('procedura_vas') if 'piano' in _procedura_vas_data: # This cannot be changed _procedura_vas_data.pop('piano') _piano = _procedura_vas.piano if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_vas_data: _procedura_vas_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_vas_data: _procedura_vas_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_vas_data: _procedura_vas_data.pop('ente') # This cannot be changed # Tipologia (O) if 'tipologia' in _procedura_vas_data: _tipologia = _procedura_vas_data.pop('tipologia') if _tipologia and _tipologia in TIPOLOGIA_VAS: _procedura_vas_data['tipologia'] = _tipologia # Note (O) if 'note' in _procedura_vas_data: _data = _procedura_vas_data.pop('note') _procedura_vas.note = _data[0] procedura_vas_aggiornata = update_create_instance( _procedura_vas, _procedura_vas_data) if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ap: _pubblicazione_provvedimento_verifica_ap = _piano.azioni.filter( tipologia=TIPOLOGIA_AZIONE. pubblicazione_provvedimento_verifica, attore=TIPOLOGIA_ATTORE.comune).first() if _pubblicazione_provvedimento_verifica_ap and \ _pubblicazione_provvedimento_verifica_ap.stato != STATO_AZIONE.nessuna: _pubblicazione_provvedimento_verifica_ap.stato = STATO_AZIONE.nessuna _pubblicazione_provvedimento_verifica_ap.save() if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ac: _pubblicazione_provvedimento_verifica_ac = _piano.azioni.filter( tipologia=TIPOLOGIA_AZIONE. pubblicazione_provvedimento_verifica, attore=TIPOLOGIA_ATTORE.ac).first() if _pubblicazione_provvedimento_verifica_ac and \ _pubblicazione_provvedimento_verifica_ac.stato != STATO_AZIONE.nessuna: _pubblicazione_provvedimento_verifica_ac.stato = STATO_AZIONE.nessuna _pubblicazione_provvedimento_verifica_ac.save() return cls(procedura_vas_aggiornata=procedura_vas_aggiornata) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): _procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid']) _procedura_vas_data = input.get('procedura_vas') if 'piano' in _procedura_vas_data: # This cannot be changed _procedura_vas_data.pop('piano') _piano = _procedura_vas.piano _token = info.context.session['token'] if 'token' in info.context.session else None _ente = _piano.ente if info.context.user and \ rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'uuid' in _procedura_vas_data: _procedura_vas_data.pop('uuid') # This cannot be changed if 'data_creazione' in _procedura_vas_data: _procedura_vas_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _procedura_vas_data: _procedura_vas_data.pop('ente') # This cannot be changed # Tipologia (O) if 'tipologia' in _procedura_vas_data: if rules.test_rule('strt_users.is_superuser', info.context.user) or \ is_RUP(info.context.user) or \ rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'): _tipologia = _procedura_vas_data.pop('tipologia') if _tipologia and _tipologia in TIPOLOGIA_VAS: _procedura_vas_data['tipologia'] = _tipologia # Note (O) if 'note' in _procedura_vas_data: if rules.test_rule('strt_users.is_superuser', info.context.user) or \ is_RUP(info.context.user) or \ rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'): _data = _procedura_vas_data.pop('note') _procedura_vas.note = _data[0] procedura_vas_aggiornata = update_create_instance(_procedura_vas, _procedura_vas_data) if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ap: if rules.test_rule('strt_users.is_superuser', info.context.user) or \ is_RUP(info.context.user) or \ rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'Comune'): _pubblicazione_provvedimento_verifica_ap = _piano.azioni.filter( tipologia=TIPOLOGIA_AZIONE.pubblicazione_provvedimento_verifica, attore=TIPOLOGIA_ATTORE.comune).first() if _pubblicazione_provvedimento_verifica_ap and \ _pubblicazione_provvedimento_verifica_ap.stato != STATO_AZIONE.nessuna: _pubblicazione_provvedimento_verifica_ap.stato = STATO_AZIONE.nessuna # Notify Users piano_phase_changed.send( sender=Piano, user=info.context.user, piano=_piano, message_type="piano_verifica_vas_updated") _pubblicazione_provvedimento_verifica_ap.save() if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ac: if rules.test_rule('strt_users.is_superuser', info.context.user) or \ is_RUP(info.context.user) or \ rules.test_rule('strt_core.api.is_actor', _token or (info.context.user, _ente), 'AC'): _pubblicazione_provvedimento_verifica_ac = _piano.azioni.filter( tipologia=TIPOLOGIA_AZIONE.pubblicazione_provvedimento_verifica, attore=TIPOLOGIA_ATTORE.ac).first() if _pubblicazione_provvedimento_verifica_ac and \ _pubblicazione_provvedimento_verifica_ac.stato != STATO_AZIONE.nessuna: _pubblicazione_provvedimento_verifica_ac.stato = STATO_AZIONE.nessuna # Notify Users piano_phase_changed.send( sender=Piano, user=info.context.user, piano=_piano, message_type="piano_verifica_vas_updated") _pubblicazione_provvedimento_verifica_ac.save() if procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ap and \ procedura_vas_aggiornata.pubblicazione_provvedimento_verifica_ac: _procedura_avvio = ProceduraAvvio.objects.filter(piano=_piano).last() if not _procedura_avvio or _procedura_avvio.conclusa: _piano.chiudi_pendenti() procedura_vas_aggiornata.conclusa = True procedura_vas_aggiornata.save() if _piano.is_eligible_for_promotion: _piano.fase = _fase = Fase.objects.get(nome=_piano.next_phase) # Notify Users piano_phase_changed.send( sender=Piano, user=info.context.user, piano=_piano, message_type="piano_phase_changed") _piano.save() fase.promuovi_piano(_fase, _piano) return cls(procedura_vas_aggiornata=procedura_vas_aggiornata) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500) else: return GraphQLError(_("Forbidden"), code=403)
def mutate_and_get_payload(cls, root, info, **input): try: _data = input.get('contatto') # Ente (M) if 'ente' in _data: _ente = _data.pop('ente') if is_RUP(info.context.user): _ente = Organization.objects.get(code=_ente['code']) else: _ente = Organization.objects.get(usermembership__member=info.context.user, code=_ente['code']) _data['ente'] = _ente if info.context.user and not info.context.user.is_anonymous: # Tipologia (M) if 'tipologia' in _data: _tipologia = _data.pop('tipologia') if _tipologia and _tipologia in TIPOLOGIA_CONTATTO: _data['tipologia'] = _tipologia _contatto = Contatto() nuovo_contatto = update_create_instance(_contatto, _data) if nuovo_contatto.user is None: # #### # Creating a Temporary User to be associate to this 'Contatto' # ### first_name = nuovo_contatto.nome.split(' ')[0] if len(nuovo_contatto.nome.split(' ')) > 0 \ else nuovo_contatto.nome last_name = nuovo_contatto.nome.split(' ')[1] if len(nuovo_contatto.nome.split(' ')) > 1 \ else nuovo_contatto.nome fiscal_code = codicefiscale.encode( surname=last_name, name=first_name, sex='M', birthdate=datetime.datetime.now(timezone.get_current_timezone()).strftime('%m/%d/%Y'), birthplace=nuovo_contatto.ente.name if nuovo_contatto.ente.type.code == 'C' else settings.DEFAULT_MUNICIPALITY ) nuovo_contatto.user, created = AppUser.objects.get_or_create( fiscal_code=fiscal_code, defaults={ 'first_name': nuovo_contatto.nome, 'last_name': None, 'email': nuovo_contatto.email, 'is_staff': False, 'is_active': True } ) _new_role_type = MembershipType.objects.get( code=settings.TEMP_USER_CODE, organization_type=nuovo_contatto.ente.type ) _new_role_name = '%s-%s-membership' % (fiscal_code, nuovo_contatto.ente.code) _new_role, created = UserMembership.objects.get_or_create( name=_new_role_name, defaults={ 'member': nuovo_contatto.user, 'organization': nuovo_contatto.ente, 'type': _new_role_type } ) _new_role.save() nuovo_contatto.save() return cls(nuovo_contatto=nuovo_contatto) else: return GraphQLError(_("Forbidden"), code=403) 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_data = input.get('piano_operativo') if rules.test_rule('strt_core.api.can_edit_piano', info.context.user, _piano): try: if 'codice' in _piano_data: _piano_data.pop('codice') # This cannot be changed if 'data_creazione' in _piano_data: _piano_data.pop('data_creazione') # This cannot be changed # Ente (M) if 'ente' in _piano_data: _piano_data.pop('ente') # This cannot be changed # Fase (O) if 'fase' in _piano_data: _piano_data.pop('fase') # This cannot be changed # Tipologia (O) if 'tipologia' in _piano_data: _piano_data.pop('tipologia') # This cannot be changed # Descrizione (O) if 'descrizione' in _piano_data: _data = _piano_data.pop('descrizione') _piano.descrizione = _data[0] # SoggettoProponente (O) if 'soggetto_proponente_uuid' in _piano_data: _soggetto_proponente_uuid = _piano_data.pop('soggetto_proponente_uuid') if len(_soggetto_proponente_uuid) > 0: _soggetto_proponente = Contatto.objects.get(uuid=_soggetto_proponente_uuid) _piano.soggetto_proponente = _soggetto_proponente else: _piano.soggetto_proponente = None if 'autorita_competente_vas' in _piano_data: _autorita_competente_vas = _piano_data.pop('autorita_competente_vas') if len(_autorita_competente_vas) > 0: _autorita_competenti = [] for _contatto_uuid in _autorita_competente_vas: _autorita_competenti.append(AutoritaCompetenteVAS( piano=_piano, autorita_competente=Contatto.objects.get(uuid=_contatto_uuid) ) ) _piano.autorita_competente_vas.clear() for _ac in _autorita_competenti: _ac.save() else: _piano.autorita_competente_vas.all().delete() if 'soggetti_sca' in _piano_data: _soggetti_sca_uuid = _piano_data.pop('soggetti_sca') if len(_soggetti_sca_uuid) > 0: _soggetti_sca = [] for _contatto_uuid in _soggetti_sca_uuid: _soggetti_sca.append(SoggettiSCA( piano=_piano, soggetto_sca=Contatto.objects.get(uuid=_contatto_uuid) ) ) _piano.soggetti_sca.clear() for _sca in _soggetti_sca: _sca.save() else: _piano.soggetti_sca.all().delete() piano_aggiornato = update_create_instance(_piano, _piano_data) return cls(piano_aggiornato=piano_aggiornato) 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): try: _piano_data = input.get('piano_operativo') # Ente (M) _data = _piano_data.pop('ente') _ente = Ente.objects.get(ipa=_data['ipa']) # _role = info.context.session.get('role', None) # _token = info.context.session.get('token', None) _piano_data['ente'] = _ente if not info.context.user: return GraphQLError("Unauthorized", code=401) if not _ente.is_comune(): return GraphQLError("Ente deve essere un comune", code=400) if not auth.can_create_piano(info.context.user, _ente): return GraphQLError("Forbidden: user can't create piano", code=403) # create Piano and assign id _piano = Piano() _piano.ente = _ente # mandatory field _piano.codice = "temp" # mandatory field _piano.save() # Codice (M) if 'codice' in _piano_data: _codice = _piano_data.pop('codice') else: _year = str(datetime.date.today().year)[2:] _month = datetime.date.today().month _codice = '%s%02d%02d%05d' % (_ente.ipa, int(_year), _month, _piano.id) _piano_data['codice'] = _codice # Fase (O) _fase = None if 'fase' in _piano_data: _data = _piano_data.pop('fase') _fase = Fase.fix_enum(_data, none_on_error=True) _fase = _fase if _fase else Fase.DRAFT _piano_data['fase'] = _fase # Descrizione (O) if 'descrizione' in _piano_data: _data = _piano_data.pop('descrizione') _piano_data['descrizione'] = _data[0] if 'tipologia' in _piano_data: _tipologia = _piano_data.pop('tipologia') _tipologia = TipologiaPiano.fix_enum(_tipologia, none_on_error=True) _piano_data['tipologia'] = _tipologia _piano_data['responsabile'] = info.context.user # Crea piano # _piano = Piano() nuovo_piano = update_create_instance(_piano, _piano_data) # Aggiunta soggetti operanti di default for qu in QualificaUfficio.get_soggetti_default(): so = SoggettoOperante(piano=nuovo_piano, qualifica_ufficio=qu) so.save() # Inizializzazione Azioni del Piano _order = 0 for _a in AZIONI_BASE[_fase]: crea_azione( Azione(piano=nuovo_piano, tipologia=_a["tipologia"], qualifica_richiesta=_a["qualifica"], stato=_a.get('stato', None), order=_order)) _order += 1 # Inizializzazione Procedura VAS _procedura_vas, created = ProceduraVAS.objects.get_or_create( piano=nuovo_piano, tipologia=TipologiaVAS.UNKNOWN) # Inizializzazione Procedura Avvio _procedura_avvio, created = ProceduraAvvio.objects.get_or_create( piano=nuovo_piano) nuovo_piano.procedura_vas = _procedura_vas nuovo_piano.procedura_avvio = _procedura_avvio nuovo_piano.save() return cls(nuovo_piano=nuovo_piano) 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)