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()
