def assegna_token(delega: Delega, utente: Utente):
logger.warning("Richiesta assegnazione Token [{}] a {}".format(
delega.token, utente))
piano = delega.delegante.piano
ente = delega.delegante.qualifica_ufficio.ufficio.ente
if has_qualifica(utente, ente, Qualifica.OPCOM):
logger.warning("Assegnazione token rifiutata a responsabile")
return False, "Assegnazione token rifiutata a responsabile"
if is_soggetto_operante(utente, piano, delega.qualifica):
logger.warning(
"Assegnazione token rifiutata a utente con qualifica già assegnata"
)
return False, "Assegnazione token rifiutata a utente con qualifica già assegnata"
token = delega.token
token.user = utente
token.save()
if not ProfiloUtente.objects.filter(utente=utente,
profilo=Profilo.OPERATORE).exists():
p = ProfiloUtente(utente=utente, profilo=Profilo.OPERATORE, ente=ente)
p.save()
return True, None
def resolve_delegabile(self, info, **args):
utente = info.context.user
piano = self.piano
if self.qualifica_ufficio.qualifica == Qualifica.OPCOM:
return False
return has_qualifica(utente, piano.ente, Qualifica.OPCOM) or \
Assegnatario.objects.filter(qualifica_ufficio=self.qualifica_ufficio, utente=utente).exists()
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(cls, root, info, **input):
def _get_or_create_resp_so():
so = auth.get_so(info.context.user, _piano,
Qualifica.OPCOM).first()
if not so:
# l'utente non ha SO direttamente associato, quindi lo creiamo
ass = get_assegnamenti(info.context.user, _piano.ente,
Qualifica.OPCOM).first()
so = SoggettoOperante(piano=_piano,
qualifica_ufficio=ass.qualifica_ufficio)
so.save()
return so
_piano = Piano.objects.get(codice=input['codice_piano'])
# Primo check 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:
qualifica = Qualifica.fix_enum(input['qualifica'],
none_on_error=True)
is_resp = auth.has_qualifica(info.context.user, _piano.ente,
Qualifica.OPCOM)
if not qualifica:
return GraphQLError("Qualifica sconosciuta", code=404)
elif qualifica == Qualifica.OPCOM:
return GraphQLError("Qualifica non delegabile", code=400)
elif qualifica == Qualifica.READONLY:
# associa alla delega un qualiasi SO associato all'utente
so = auth.get_so(info.context.user, _piano).first()
if not so:
if is_resp:
# l'utente è RESP per l'ente, ma non ha SO direttamente associato, quindi lo creiamo
so = _get_or_create_resp_so()
else:
return GraphQLError(
"Forbidden - Utente non assegnatario", code=403)
else:
#
so = auth.get_so(info.context.user, _piano, qualifica).first()
if not so:
if is_resp:
# l'utente è RESP per l'ente, ma non ha SO direttamente associato, quindi lo creiamo
so = _get_or_create_resp_so()
else:
return GraphQLError(
"Forbidden - Qualifica non assegnabile", code=403)
token = Token()
token.key = Token.generate_key()
token.expires = datetime.datetime.now() + datetime.timedelta(
days=30) # TODO
token.save()
delega = Delega()
delega.qualifica = qualifica
delega.delegante = so
delega.created_by = info.context.user
delega.token = token
delega.save()
# TODO: USE EMAIL
# piano_phase_changed.send(
# sender=Piano,
# user=info.context.user,
# piano=_piano,
# message_type="delega")
return CreaDelega(token=token.key, 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_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)