def mutate(cls, root, info, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Utente non autenticato", code=401) # Fetching input arguments _id = input['risorsa_id'] _uuid_vas = input['codice'] # TODO: Andrebbe controllato se la risorsa in funzione del tipo e della fase del piano è eliminabile o meno try: _procedura_vas = ProceduraVAS.objects.get(uuid=_uuid_vas) _piano = _procedura_vas.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) _risorsa = Risorsa.objects.get(uuid=_id) if _risorsa.tipo == TipoRisorsa.PARERE_SCA.value: # if not auth_vas.parere_sca_ok(info.context.user, _procedura_vas): # return GraphQLError("Risorsa non eliminabile", code=403) if is_executed(_piano.getFirstAction(TipologiaAzione.trasmissione_pareri_sca)): return GraphQLError('Risorsa inviata e non modificabile', code=403) if _risorsa.tipo == TipoRisorsa.PARERE_VERIFICA_VAS and \ not auth_vas.parere_verifica_vas_ok(info.context.user, _procedura_vas): return GraphQLError("Risorsa non eliminabile", code=403) _success = DeleteRisorsaBase.handle_downloaded_data(_risorsa) return DeleteRisorsaVAS(procedura_vas_aggiornata=_procedura_vas, success=_success) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def mutate(cls, root, info, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Utente non autenticato", code=401) # Fetching input arguments _id = input['risorsa_id'] _uuid_cc = input['codice'] # TODO: Andrebbe controllato se la risorsa in funzione del tipo e della fase del piano è eliminabile o meno try: _piano_rev_post_cp = PianoRevPostCP.objects.get(uuid=_uuid_cc) _piano = _piano_rev_post_cp.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) _risorsa = Risorsa.objects.get(uuid=_id) _success = DeleteRisorsaBase.handle_downloaded_data(_risorsa) return DeleteRisorsaPianoRevPostCP( piano_rev_post_cp_aggiornato=_piano_rev_post_cp, success=_success) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def mutate(cls, root, info, 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 qs(self): # The query context can be found in self.request. _enti = [] # _memberships = None # if rules.test_rule('strt_core.api.can_access_private_area', self.request.user): if is_recognizable(self.request.user): id_piani = get_piani_visibili_id(self.request.user) return super(PianoUserMembershipFilter, self).qs\ .filter(id__in=id_piani).order_by('-last_update', '-codice') else: return super(PianoUserMembershipFilter, self).qs.none()
def mutate(cls, root, info, file, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Not Authorized - Utente non riconosciuto", code=401) # Fetching input arguments _uuid_vas = input['codice'] _tipo_file = input['tipo_file'] try: # Validating 'Procedura VAS' _procedura_vas = ProceduraVAS.objects.get(uuid=_uuid_vas) _piano = _procedura_vas.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) if _tipo_file == TipoRisorsa.PARERE_SCA.value: # if _procedura_vas.risorse.filter(tipo=_tipo_file, archiviata=False, user=info.context.user).exists(): # return GraphQLError('Precondition failed - Non si possono aggiungere ulteriori pareri SCA', code=412) if is_executed(_piano.getFirstAction(TipologiaAzione.trasmissione_pareri_sca)): return GraphQLError('Risorsa inviata e non modificabile', code=403) if _tipo_file == TipoRisorsa.PARERE_VERIFICA_VAS.value and \ not auth_vas.parere_verifica_vas_ok(info.context.user, _procedura_vas): return GraphQLError('Precondition failed - Verifica VAS esistente', code=412) # not rules.test_rule('strt_core.api.parere_verifica_vas_ok', info.context.user, _procedura_vas): # return GraphQLError(_("Forbidden"), code=403) _resources = UploadBaseBase.handle_uploaded_data( file, _uuid_vas, _procedura_vas.piano.fase, _tipo_file, info.context.user ) _success = False if _resources and len(_resources) > 0: _success = True for _risorsa in _resources: RisorseVas(procedura_vas=_procedura_vas, risorsa=_risorsa).save() return UploadRisorsaVAS( procedura_vas_aggiornata=_procedura_vas, success=_success, file_name=_resources[0].nome) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def qs(self): # The query context can be found in self.request. if is_recognizable(self.request.user): return super(UserMembershipFilter, self).qs\ .filter(fiscal_code=self.request.user.fiscal_code)\ .distinct() # if is_RUP(self.request.user): # return super(UserMembershipFilter, self).qs.filter(usermembership__member=self.request.user).distinct() # return super(UserMembershipFilter, self).qs.all() # else: # return super(UserMembershipFilter, self).qs.filter(id=self.request.user.id).distinct() else: return super(UserMembershipFilter, self).qs.none()
def mutate(cls, root, info, file, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Not Authorized - Utente non riconosciuto", code=401) # Fetching input arguments _uuid_adozione = input['codice'] _tipo_file = input['tipo_file'] try: _procedura_adozione = ProceduraAdozione.objects.get(uuid=_uuid_adozione) _piano = _procedura_adozione.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) require_action(_piano, _tipo_file, TipoRisorsa.OSSERVAZIONI_ENTI, TipologiaAzione.osservazioni_enti) require_action(_piano, _tipo_file, TipoRisorsa.OSSERVAZIONI_PRIVATI, TipologiaAzione.upload_osservazioni_privati) _resources = UploadBaseBase.handle_uploaded_data( file, _uuid_adozione, _procedura_adozione.piano.fase, _tipo_file, info.context.user ) _success = False if _resources and len(_resources) > 0: _success = True for _risorsa in _resources: RisorseAdozione(procedura_adozione=_procedura_adozione, risorsa=_risorsa).save() return UploadRisorsaAdozione( procedura_adozione_aggiornata=_procedura_adozione, success=_success, file_name=_resources[0].nome) except GraphQLError as ge: return ge except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def qs(self): # The query context can be found in self.request. if is_recognizable(self.request.user): if ProfiloUtente.objects.filter( utente=self.request.user, profilo__in=[Profilo.ADMIN_PORTALE, Profilo.RESP_RUP]).exists(): return super(EnteUserMembershipFilter, self).qs.all() elif ProfiloUtente.objects.filter( utente=self.request.user, profilo__in=[Profilo.ADMIN_ENTE, Profilo.OPERATORE]).exists(): profili = ProfiloUtente.objects.filter( utente=self.request.user, profilo__in=[Profilo.ADMIN_ENTE, Profilo.OPERATORE]) enti = [p.ente.id for p in profili] return super(EnteUserMembershipFilter, self).qs.filter(id__in=enti) return super(EnteUserMembershipFilter, self).qs.none()
def qs(self): # The query context can be found in self.request. _enti = [] # _memberships = None # if rules.test_rule('strt_core.api.can_access_private_area', self.request.user): # _memberships = self.request.user.memberships # if _memberships: # _is_iside = self.request.user.memberships.filter(type__code=settings.RESPONSABILE_ISIDE_CODE) # _is_regione = self.request.user.memberships.filter(type__organization_type__code='R') # if _is_regione and not _is_iside: # for _o in Ente.objects.filter(type__code='C'): # _enti.append(_o.code) # else: # for _m in _memberships.all(): # if _m.type.code == settings.RESPONSABILE_ISIDE_CODE: # # RESPONSABILE_ISIDE_CODE cannot access to Piani at all # continue # else: # _enti.append(_m.organization.code) # # _enti = [_m.organization.code for _m in _memberships.all()] is_op = False if is_recognizable(self.request.user): is_op = ProfiloUtente.objects.filter( utente=self.request.user, profilo=Profilo.OPERATORE).exists() # token = self.request.session.get('token', None) # TODO use also token access # if token: # _allowed_pianos = [_pt.piano.codice for _pt in PianoAuthTokens.objects.filter(token__key=token)] # _pianos = [_p for _p in Piano.objects.filter(codice__in=_allowed_pianos)] # for _p in _pianos: # _enti.append(_p.ente.code) # # return super(ProceduraMembershipFilterBase, self).qs.filter(ente__code__in=_enti) if is_op: return super(ProceduraMembershipFilterBase, self).qs else: return super(ProceduraMembershipFilterBase, self).qs.none()
def mutate(cls, root, info, file, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Forbidden - Utente non riconosciuto", code=403) # Fetching input arguments _uuid_cc = input['codice'] _tipo_file = input['tipo_file'] try: _conferenza_copianificazione = ConferenzaCopianificazione.objects.get(uuid=_uuid_cc) _piano = _conferenza_copianificazione.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) _resources = UploadBaseBase.handle_uploaded_data( file, _uuid_cc, _conferenza_copianificazione.piano.fase, _tipo_file, info.context.user ) _success = False if _resources and len(_resources) > 0: _success = True for _risorsa in _resources: RisorseCopianificazione( conferenza_copianificazione=_conferenza_copianificazione, risorsa=_risorsa).save() return UploadRisorsaCopianificazione( conferenza_copianificazione_aggiornata=_conferenza_copianificazione, success=_success, file_name=_resources[0].nome) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def mutate(cls, root, info, file, **input): if not auth.is_recognizable(info.context.user): return GraphQLError("Not Authorized - Utente non riconosciuto", code=401) # Fetching input arguments _uuid_vas = input['codice'] _tipo_file = input['tipo_file'] try: _procedura_vas = ProceduraAdozioneVAS.objects.get(uuid=_uuid_vas) _piano = _procedura_vas.piano if not auth.can_access_piano(info.context.user, _piano): return GraphQLError("Forbidden - Utente non abilitato ad editare questo piano", code=403) _resources = UploadBaseBase.handle_uploaded_data( file, _uuid_vas, _procedura_vas.piano.fase, _tipo_file, info.context.user ) _success = False if _resources and len(_resources) > 0: _success = True for _risorsa in _resources: RisorseAdozioneVas(procedura_adozione_vas=_procedura_vas, risorsa=_risorsa).save() return UploadRisorsaAdozioneVAS( procedura_vas_aggiornata=_procedura_vas, success=_success, file_name=_resources[0].nome) except BaseException as e: tb = traceback.format_exc() logger.error(tb) return GraphQLError(e, code=500)
def privateAreaView(request): current_user = get_current_authenticated_user() if current_user: # TODO if is_recognizable(current_user) and \ ( has_profile(current_user, Profilo.OPERATORE) or has_profile(current_user, Profilo.ADMIN_ENTE)): logger.warning('Redirecting to serapide') return redirect('serapide') else: logger.warning('Redirecting to /') return redirect('/') # # if 'role' in request.session and request.session['role']: # current_role = current_user.memberships.filter(pk=request.session['role']).first() # if current_role: # if current_role.type.code == settings.RESPONSABILE_ISIDE_CODE: # return redirect('users_list') # if current_user.has_perm('strt_users.can_access_serapide'): # return redirect('serapide') # else: # return redirect('/') # # logout(request) # # return redirect('user_registration') else: # TODO: redirect to RT SSO service endpoint if request.method == "POST": form = UserAuthenticationForm(request.POST) if form.is_valid(): form_cleaned_data = form.cleaned_data orgs = [{ 'organization': org } for org in form_cleaned_data['hidden_orgs'].split('-') if org] form_cleaned_data.pop('hidden_orgs') form_cleaned_data['organizations'] = orgs # TODO: MembershipType Check _role = form_cleaned_data.pop('membership_type') if not _role: ve = forms.ValidationError(_("Ruolo non valido.")) form.add_error(None, ve) else: encoded_jwt = jwt.encode(payload=form_cleaned_data, key=settings.SECRET_KEY, algorithm='HS256') try: user = authenticate(encoded_jwt) _organization = orgs.pop()['organization'].strip() organization = None try: # Organizations must be already registered organization = Ente._default_manager.get( code=_organization) except Ente.DoesNotExist: ve = forms.ValidationError( _("L'ente {} non risulta censito.".format( _organization))) form.add_error(None, ve) if user and organization: try: membership = None # TODO Ruolo._default_manager.get(code=_role) login(request, user) request.session['role'] = membership.pk request.session[ 'organization'] = organization.code request.session[ 'attore'] = membership.organization.type.name if membership.type.code == settings.RESPONSABILE_ISIDE_CODE: return redirect('users_list') return redirect('serapide') except: # Ruolo.DoesNotExist: ve = forms.ValidationError( _("Utente {} non valido.".format(user))) form.add_error(None, ve) except ValidationError as ve: form.add_error(None, ve) else: form = UserAuthenticationForm() context = {'form': form} return render(request, 'strt_tests/user_authentication_test.html', context)
def __call__(self, request): # Code to be executed for each request before the view (and later middleware) are called. def create_redirect_piano(request, piano): return HttpResponseRedirect( '{request_path}/#/piano/{piano}/home'.format( request_path=request.path, piano=piano.codice)) # Read token either from param or from header token = request.GET.get('token', None) if token is None: auth_header = request.META.get('HTTP_AUTHORIZATION', b'').split() if auth_header and auth_header[0].lower() == b'token': # If they specified an invalid token, let them know. if len(auth_header) != 2: return HttpResponseBadRequest("Improperly formatted token") token = auth_header[1] if token: if not is_recognizable(request.user): logger.debug("Token specificato su utente sconosciuto") redirected = request.GET.get('redirected_by', None) if not redirected == 'TokenMiddleware': # did we just redirect this return HttpResponseRedirect( '{login_path}?next={request_path}%3Ftoken={token}&redirected_by=TokenMiddleware' .format(login_path=getattr(settings, 'LOGIN_URL', '/'), request_path=request.path, token=token)) else: logger.debug( "Token e utente specificati. Token [{}]".format(token)) t: Token = Token.objects.filter(key=token).first() if t: if not t.is_expired(): utente = request.user d: Delega = Delega.objects.get(token=t) piano = d.delegante.piano if t.user is None: ok, err = assegna_token(d, utente) return create_redirect_piano(request, piano) elif t.user == utente: logger.info("Token già in uso [{}]".format(token)) return create_redirect_piano(request, piano) else: logger.warning( "Token già assegnato ad altro utente [{}]". format(token)) # se l'utente ha cmq accesso al piano, usiamo il token come semplice bookmark if can_access_piano(utente, piano): return create_redirect_piano(request, piano) else: logger.warning("Token expired [{}]".format(token)) else: logger.warning("Token non trovato [{}]".format(token)) # ------------------------ # calls the view response = self.get_response(request) # ------------------------ # Code to be executed for each request/response after the view is called. return response
def get_piano_qs(user): if is_recognizable(user): id_piani = get_piani_visibili_id(user) return Piano.objects.filter(id__in=id_piani) else: return Piano.objects.none()