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)