def mutate_and_get_payload(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
_procedura_avvio_data = input.get('procedura_avvio')
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:
# ProceduraAvvio (M)
_procedura_avvio_data['piano'] = _piano
# Ente (M)
_procedura_avvio_data['ente'] = _piano.ente
_procedura_avvio, created = ProceduraAvvio.objects.get_or_create(
piano=_piano, ente=_piano.ente)
_procedura_avvio_data['id'] = _procedura_avvio.id
_procedura_avvio_data['uuid'] = _procedura_avvio.uuid
nuova_procedura_avvio = update_create_instance(
_procedura_avvio, _procedura_avvio_data)
_piano.procedura_avvio = nuova_procedura_avvio
_piano.save()
return cls(nuova_procedura_avvio=nuova_procedura_avvio)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_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 not auth.can_edit_piano(info.context.user, _piano, Qualifica.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
errs = []
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PARERE_AC.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("File relativo al pareri AC mancante",
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return TrasmissionePareriAC(vas_aggiornata=_procedura_vas,
errors=errs)
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'])
_procedura_vas = ProceduraVAS.objects.get(piano=_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:
nuova_consultazione_vas = ConsultazioneVAS()
nuova_consultazione_vas.user = info.context.user
nuova_consultazione_vas.procedura_vas = _procedura_vas
_consultazioni_vas_expire_days = getattr(
settings, 'CONSULTAZIONI_SCA_EXPIRE_DAYS', 90)
nuova_consultazione_vas.data_scadenza = datetime.datetime.now(timezone.get_current_timezone()) + \
datetime.timedelta(days=_consultazioni_vas_expire_days)
nuova_consultazione_vas.save()
return cls(nuova_consultazione_vas=nuova_consultazione_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(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _procedura_vas.piano
# check generico sul piano
if not auth.can_access_piano(info.context.user, _piano):
return GraphQLError(
"Forbidden - Utente non abilitato ad editare questo piano",
code=403)
# check specifico azione
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
# check risorsa
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.DOCUMENTO_PRELIMINARE_VAS.value, archiviata=False, user=info.context.user)\
.exists():
return GraphQLError("Risorsa mancante: {}".format(
TipoRisorsa.DOCUMENTO_PRELIMINARE_VAS.value),
code=409)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return InvioDocPreliminare(procedura_vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_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 not auth.can_edit_piano(info.context.user, _piano, Qualifica.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
if not _procedura_vas.pubblicazione_provvedimento_verifica_ac:
return GraphQLError("URL di pubblicazione non impostata", code=409)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info)
return PubblicazioneProvvedimentoVerificaAc(
vas_aggiornata=_procedura_vas, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_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 not auth.can_edit_piano(info.context.user, _piano, Qualifica.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
if not _procedura_vas.risorse\
.filter(tipo=TipoRisorsa.PROVVEDIMENTO_VERIFICA_VAS.value, archiviata=False)\
.exists():
return GraphQLError("File mancante: {}".format(
TipoRisorsa.PROVVEDIMENTO_VERIFICA_VAS.value),
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return EmissioneProvvedimentoVerifica(
vas_aggiornata=_procedura_vas, errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_piano = _procedura_avvio.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'):
try:
cls.update_actions_for_phase(_piano.fase, _piano,
_procedura_avvio,
info.context.user)
# Notify Users
"""
TODO
"""
# piano_phase_changed.send(
# sender=Piano,
# user=info.context.user,
# piano=_piano,
# message_type="piano_phase_changed")
return IntegrazioniRichieste(avvio_aggiornato=_procedura_avvio,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, file, **input):
if info.context.user and rules.test_rule(
'strt_core.api.can_access_private_area', info.context.user):
# Fetching input arguments
_uuid_avvio = input['codice']
_tipo_file = input['tipo_file']
try:
# Validating 'Procedura VAS'
_procedura_avvio = ProceduraAvvio.objects.get(uuid=_uuid_avvio)
if rules.test_rule('strt_core.api.can_edit_piano',
info.context.user, _procedura_avvio.piano):
_resources = UploadBaseBase.handle_uploaded_data(
file, _uuid_avvio, _procedura_avvio.piano.fase,
_tipo_file, info.context.user)
_success = False
if _resources and len(_resources) > 0:
_success = True
for _risorsa in _resources:
RisorseAvvio(procedura_avvio=_procedura_avvio,
risorsa=_risorsa).save()
return UploadRisorsaAvvio(
procedura_avvio_aggiornata=_procedura_avvio,
success=_success,
file_name=_resources[0].nome)
else:
return GraphQLError(_("Forbidden"), code=403)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_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 not auth.can_edit_piano(info.context.user, _piano, Qualifica.AC):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
if not _procedura_vas.risorse \
.filter(tipo=TipoRisorsa.DOCUMENTO_PRELIMINARE_VERIFICA_VAS.value, archiviata=False) \
.exists():
return GraphQLError("File mancante: {}".format(
TipoRisorsa.DOCUMENTO_PRELIMINARE_VERIFICA_VAS.value),
code=409)
if not SoggettoOperante.get_by_qualifica(_piano, Qualifica.SCA).exists() and \
not Delega.objects.filter(qualifica=Qualifica.SCA, delegante__piano=_piano).exists():
return GraphQLError("Non sono associati SCA al piano",
code=409)
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas,
info.context.user)
return InvioPareriVerificaVAS(vas_aggiornata=_procedura_vas,
errors=[])
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _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), 'AC'):
try:
_pareri_verifica_sca = _piano.azioni.filter(
tipologia=TIPOLOGIA_AZIONE.pareri_verifica_sca).first()
if _pareri_verifica_sca and _pareri_verifica_sca.stato != STATO_AZIONE.nessuna:
return GraphQLError(_("Forbidden"), code=403)
if not _procedura_vas.verifica_effettuata and \
_procedura_vas.tipologia in (TIPOLOGIA_VAS.verifica, TIPOLOGIA_VAS.semplificata):
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
else:
return GraphQLError(_("Forbidden"), code=403)
return AssoggettamentoVAS(
vas_aggiornata=_procedura_vas,
errors=[]
)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
if info.context.user and rules.test_rule(
'strt_core.api.can_access_private_area', info.context.user):
# 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:
_conferenza_copianificazione = ConferenzaCopianificazione.objects.get(
uuid=_uuid_cc)
if rules.test_rule('strt_core.api.can_edit_piano',
info.context.user,
_conferenza_copianificazione.piano):
_risorsa = Risorsa.objects.get(uuid=_id)
_success = DeleteRisorsaBase.handle_downloaded_data(
_risorsa)
return DeleteRisorsaCopianificazione(
conferenza_copianificazione_aggiornata=
_conferenza_copianificazione,
success=_success)
else:
return GraphQLError(_("Forbidden"), code=403)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
# Something went wrong
return GraphQLError(_("Not Allowed"), code=405)
def mutate(self, info, data):
user = info.context.user
schedule = Schedule.objects.last()
presentation, created = Presentation.objects.get_or_create(owner=user)
if created and schedule.presentation_proposal_finish_at and \
schedule.presentation_proposal_finish_at < now():
raise GraphQLError(_('발표 제안 기간이 종료되었습니다.'))
if not schedule.presentation_proposal_start_at or \
schedule.presentation_proposal_start_at > now():
raise GraphQLError(_('발표 모집이 아직 시작되지 않았습니다.'))
if schedule.presentation_review_start_at < now(
) < schedule.presentation_review_finish_at:
raise GraphQLError(_('오픈 리뷰 중에는 제안서를 수정할 수 없습니다.'))
if 'category_id' in data:
presentation.category = Category.objects.get(
pk=data['category_id'])
del data['category_id']
if 'difficulty_id' in data:
presentation.difficulty = Difficulty.objects.get(
pk=data['difficulty_id'])
del data['difficulty_id']
for k, v in data.items():
setattr(presentation, k, v)
presentation.full_clean()
presentation.save()
return CreateOrUpdatePresentationProposal(proposal=presentation)
def check_product(cls, product):
if product.is_sold_out:
raise GraphQLError(_('티켓이 모두 판매되었습니다.'))
if product.is_not_open_yet():
raise GraphQLError(_('티켓 판매가 아직 시작되지 않았습니다.'))
if product.is_closed():
raise GraphQLError(_('티켓 판매가 종료되었습니다.'))
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _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'):
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
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 UploadElaboratiVAS(
vas_aggiornata=_procedura_vas,
errors=[]
)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_procedura_avvio = ProceduraAvvio.objects.get(uuid=input['uuid'])
_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)
if not auth.can_edit_piano(info.context.user, _piano, Qualifica.OPCOM):
return GraphQLError(
"Forbidden - Utente non abilitato per questa azione", code=403)
try:
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_avvio,
info.context.user)
check_and_promote(_piano, info)
return IntegrazioniRichieste(avvio_aggiornato=_procedura_avvio,
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'])
_procedura_vas_data = input.get('procedura_vas')
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:
# 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(cls, root, info, **input):
_piano = Piano.objects.get(codice=input['codice_piano'])
if info.context.user and rules.test_rule(
'strt_core.api.can_edit_piano', info.context.user, _piano):
try:
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 PromozionePiano(piano_aggiornato=_piano, errors=[])
else:
return GraphQLError(_("Not Allowed"), code=405)
except BaseException as e:
tb = traceback.format_exc()
logger.error(tb)
return GraphQLError(e, code=500)
else:
return GraphQLError(_("Forbidden"), code=403)
def mutate(cls, root, info, **input):
_procedura_vas = ProceduraVAS.objects.get(uuid=input['uuid'])
_piano = _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), 'SCA'):
try:
_pareri_vas_count = ParereVerificaVAS.objects.filter(
user=info.context.user,
procedura_vas=_procedura_vas
)
if _pareri_vas_count.count() == 0:
_parere_vas = ParereVerificaVAS(
inviata=True,
user=info.context.user,
procedura_vas=_procedura_vas
)
_parere_vas.save()
elif _pareri_vas_count.count() != 1:
return GraphQLError(_("Forbidden"), code=403)
_tutti_pareri_inviati = True
for _sca in _piano.soggetti_sca.all():
_pareri_vas_count = ParereVerificaVAS.objects.filter(
user=_sca.user,
procedura_vas=_procedura_vas
).count()
if _pareri_vas_count != 1:
_tutti_pareri_inviati = False
break
if _tutti_pareri_inviati:
# Notify Users
piano_phase_changed.send(
sender=Piano,
user=info.context.user,
piano=_piano,
message_type="tutti_pareri_inviati")
cls.update_actions_for_phase(_piano.fase, _piano, _procedura_vas)
return InvioPareriVerificaVAS(
vas_aggiornata=_procedura_vas,
errors=[]
)
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_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(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 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(self, info, category_ids):
if len(category_ids) < 2:
raise GraphQLError(_('리뷰할 카테고리를 2개 이상 선택해주어야 합니다.'))
user = info.context.user
exist_reviews = CFPReview.objects.filter(owner=user)
if exist_reviews.count() > 0:
return AssignCFPReviews(exist_reviews)
target_presentations = Presentation.objects.filter(
submitted=True, category__in=category_ids).exclude(owner=user)
if not target_presentations:
raise GraphQLError(_('선택한 카테고리에 리뷰할 제안서가 없습니다. 다시 카테고리를 선택해주세요.'))
reviews = assign_reviews(user, target_presentations)
return AssignCFPReviews(reviews)
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 resolve_city_users_now(self, info, **kwargs):
user = info.context.user
cityId = kwargs.get('cityId')
page = kwargs.get('page', 0)
offset = 10 * page
nextPage = page + 1
try:
city = models.City.objects.prefetch_related('currentCity').get(
city_id=cityId)
except models.City.DoesNotExist:
raise GraphQLError('City not found')
usersNow = city.currentCity.order_by('-id').distinct('id')
# usersNow = city.currentCity.order_by('-id')
hasNextPage = offset < usersNow.count()
usersNow = usersNow[offset:10 + offset]
return user_types.UsersNowResponse(usersNow=usersNow,
page=nextPage,
hasNextPage=hasNextPage)
def refund(self, request, queryset):
for ticket in queryset:
if ticket.status != Ticket.STATUS_PAID:
raise GraphQLError(_('이미 환불된 티켓이거나 결재되지 않은 티켓입니다.'))
try:
iamport = create_iamport(ticket.is_domestic_card)
response = iamport.cancel(u'티켓 환불', imp_uid=ticket.imp_uid)
except Iamport.ResponseError as e:
raise GraphQLError(e.message)
except Iamport.HttpError as e:
raise GraphQLError(_('환불이 실패했습니다'))
ticket.status = Ticket.STATUS_CANCELLED
ticket.cancelled_at = datetime.fromtimestamp(
response['cancelled_at'])
ticket.cancel_receipt_url = response['cancel_receipt_urls'][0]
ticket.save()
def resolve_error_400(self, info, **kwargs):
sleep(2)
# Your actual code
# ...
raise GraphQLError(message="Something went wrong, please try again",
code=400)
def resolve_city_users_before(self, info, **kwargs):
user = info.context.user
cityId = kwargs.get('cityId')
page = kwargs.get('page', 0)
offset = 10 * page
payload = kwargs.get('payload')
nextPage = page + 1
try:
city = models.City.objects.prefetch_related('currentCity').get(
city_id=cityId)
except models.City.DoesNotExist:
raise GraphQLError('City not found')
usersNow = city.currentCity.order_by('-id').distinct('id')
# usersNow = city.currentCity.order_by('-id')
usersBefore = city.moveNotificationCity.exclude(
actor__in=usersNow).order_by('-actor_id').distinct('actor_id')
# actor__in=usersNow).order_by('-actor_id')
if payload == "APP":
return notification_types.usersBeforeResponse(usersBefore=usersBefore,
page=None,
hasNextPage=None)
else:
hasNextPage = offset < usersBefore.count()
usersBefore = usersBefore[offset:10 + offset]
return notification_types.usersBeforeResponse(usersBefore=usersBefore,
page=nextPage,
hasNextPage=hasNextPage)
def resolve_continent_users_before(self, info, **kwargs):
user = info.context.user
continentCode = kwargs.get('continentCode')
page = kwargs.get('page', 0)
offset = 10 * page
nextPage = page + 1
try:
continent = models.Continent.objects.get(continent_code=continentCode)
except models.Continent.DoesNotExist:
raise GraphQLError('Continent not found')
usersNow = continent.currentContinent.order_by('-id').distinct('id')
# usersNow = continent.currentContinent.order_by('-id')
usersBefore = continent.moveNotificationContinent.exclude(
actor__in=usersNow).order_by('-actor_id').distinct('actor_id')
# actor__in=usersNow).order_by('-actor_id')
hasNextPage = offset < usersBefore.count()
usersBefore = usersBefore[offset:10 + offset]
return notification_types.usersBeforeResponse(usersBefore=usersBefore,
page=nextPage,
hasNextPage=hasNextPage)
def update_actions_for_phase(cls, fase, piano, procedura_vas, user):
ensure_fase(fase, Fase.ANAGRAFICA)
if procedura_vas.tipologia == TipologiaVAS.VERIFICA:
exp = TipoExpire.EMISSIONE_PV_VERIFICA
elif procedura_vas.tipologia == TipologiaVAS.PROCEDIMENTO_SEMPLIFICATO:
exp = TipoExpire.EMISSIONE_PV_PROCEDIMENTOSEMPLIFICATO
else:
raise GraphQLError("Tipo procedura VAS inaspettata: {}".format(
procedura_vas.tipologia),
code=403)
_pareri_verifica_vas = piano.getFirstAction(
TipologiaAzione.pareri_verifica_sca)
if needs_execution(_pareri_verifica_vas):
chiudi_azione(_pareri_verifica_vas)
_azione_start_vas = piano.getFirstAction(
TipologiaAzione.selezione_tipologia_vas)
_data_start_vas = _azione_start_vas.data
crea_azione(
Azione(
piano=piano,
tipologia=TipologiaAzione.emissione_provvedimento_verifica,
qualifica_richiesta=QualificaRichiesta.AC,
stato=StatoAzione.ATTESA,
).imposta_scadenza(get_scadenza(_data_start_vas, exp)))
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)