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)
