Esempio n. 1
0
 def qs(self):
     # The query context can be found in self.request.
     if rules.test_rule('strt_core.api.can_access_private_area', self.request.user):
         if is_RUP(self.request.user):
             return super(EnteUserMembershipFilter, self).qs.all()
         else:
             return super(EnteUserMembershipFilter, self).qs.filter(usermembership__member=self.request.user)
     else:
         return super(EnteUserMembershipFilter, self).qs.none()
Esempio n. 2
0
    def mutate(self, info, **input):
        if is_RUP(info.context.user):
            # Fetching input arguments
            _id = input['uuid']
            try:
                _contatto = Contatto.objects.get(uuid=_id)
                _contatto.delete()

                return DeleteContatto(success=True, uuid=_id)
            except BaseException as e:
                tb = traceback.format_exc()
                logger.error(tb)
                return GraphQLError(e, code=500)

        return DeleteContatto(success=False)
Esempio n. 3
0
    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)
Esempio n. 4
0
    def mutate(self, info, **input):
        if info.context.user and rules.test_rule('strt_users.can_access_private_area', info.context.user) and \
        (rules.test_rule('strt_users.is_superuser', info.context.user) or is_RUP(info.context.user)):

            # Fetching input arguments
            _id = input['uuid']
            try:
                _contatto = Contatto.objects.get(uuid=_id)
                _contatto.delete()

                return DeleteContatto(success=True, uuid=_id)
            except BaseException as e:
                tb = traceback.format_exc()
                logger.error(tb)
                return GraphQLError(e, code=500)

        return DeleteContatto(success=False)
Esempio n. 5
0
    def mutate(self, info, **input):
        if info.context.user and is_RUP(info.context.user):

            # Fetching input arguments
            _id = input['codice_piano']
            try:
                _piano = Piano.objects.get(codice=_id)
                if 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):
                    _piano.delete()

                    return DeletePiano(success=True, codice_piano=_id)
            except BaseException as e:
                tb = traceback.format_exc()
                logger.error(tb)
                return GraphQLError(e, code=500)

        return DeletePiano(success=False)
Esempio n. 6
0
    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)
Esempio n. 7
0
    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)
Esempio n. 8
0
    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)