import sys from collections import OrderedDict from datetime import datetime, timedelta from braces.views import FormMessagesMixin from django import forms from django.contrib.auth.decorators import login_required from django.contrib.contenttypes.models import ContentType from django.core.signing import Signer from django.core.urlresolvers import reverse_lazy from django.db import transaction from django.db.models import Q from django.http.response import (HttpResponse, HttpResponseRedirect, JsonResponse) from django.shortcuts import get_object_or_404, redirect from django.utils.dateparse import parse_date from django.utils.decorators import method_decorator from django.utils.translation import ugettext_lazy as _ from django.views.generic.base import TemplateView from django.views.generic.detail import DetailView from django.views.generic.edit import (CreateView, DeleteView, FormView, UpdateView) from django.views.generic.list import ListView from compilacao.forms import (DispositivoDefinidorVigenciaForm, DispositivoEdicaoAlteracaoForm, DispositivoEdicaoBasicaForm, DispositivoEdicaoVigenciaForm, DispositivoSearchModalForm, NotaForm, PublicacaoForm, TaForm, TipoTaForm, VideForm) from compilacao.models import (Dispositivo, Nota, PerfilEstruturalTextoArticulado, Publicacao, TextoArticulado, TipoDispositivo, TipoNota, TipoPublicacao, TipoTextoArticulado, TipoVide, VeiculoPublicacao, Vide) from compilacao.utils import DISPOSITIVO_SELECT_RELATED from crud.base import Crud, CrudListView, make_pagination TipoNotaCrud = Crud.build(TipoNota, 'tipo_nota') TipoVideCrud = Crud.build(TipoVide, 'tipo_vide') TipoPublicacaoCrud = Crud.build(TipoPublicacao, 'tipo_publicacao') VeiculoPublicacaoCrud = Crud.build(VeiculoPublicacao, 'veiculo_publicacao') class IntegracaoTaView(TemplateView): def get(self, *args, **kwargs): item = get_object_or_404(self.model, pk=kwargs['pk']) related_object_type = ContentType.objects.get_for_model(item) ta = TextoArticulado.objects.filter( object_id=item.pk, content_type=related_object_type) if not ta.exists(): ta = TextoArticulado() tipo_ta = TipoTextoArticulado.objects.filter( content_type=related_object_type)[:1] if tipo_ta.exists(): ta.tipo_ta = tipo_ta[0] ta.content_object = item else: ta = ta[0] if hasattr(item, 'ementa') and item.ementa: ta.ementa = item.ementa else: ta.ementa = _('Integração com %s sem ementa.') % item if hasattr(item, 'observacao') and item.observacao: ta.observacao = item.observacao else: ta.observacao = _('Integração com %s sem observacao.') % item if hasattr(item, 'numero') and item.numero: ta.numero = item.numero else: ta.numero = int('%s%s%s' % ( int(datetime.now().year), int(datetime.now().month), int(datetime.now().day))) if hasattr(item, 'ano') and item.ano: ta.ano = item.ano else: ta.ano = datetime.now().year if hasattr(item, 'data_apresentacao'): ta.data = item.data_apresentacao elif hasattr(item, 'data'): ta.data = item.data else: ta.data = datetime.now() ta.save() return redirect(to=reverse_lazy('compilacao:ta_text', kwargs={'ta_id': ta.pk})) class Meta: abstract = True def get_integrations_view_names(): result = [] modules = sys.modules for key, value in modules.items(): if key.endswith('.views'): for v in value.__dict__.values(): if hasattr(v, '__bases__'): for base in v.__bases__: if base == IntegracaoTaView: result.append(v) return result def choice_models_in_extenal_views(): integrations_view_names = get_integrations_view_names() result = [(None, '-------------'), ] for item in integrations_view_names: if hasattr(item, 'model') and hasattr(item, 'model_type_foreignkey'): ct = ContentType.objects.filter( model=item.model.__name__.lower(), app_label=item.model._meta.app_label) if ct.exists(): result.append(( ct[0].pk, item.model._meta.verbose_name_plural)) return result class CompMixin: @property def title(self): try: return self.get_object() except: return self.object class TipoTaListView(ListView): model = TipoTextoArticulado paginate_by = 10 verbose_name = model._meta.verbose_name @property def title(self): return self.model._meta.verbose_name_plural @property def create_url(self): return reverse_lazy('compilacao:tipo_ta_create') class TipoTaCreateView(FormMessagesMixin, CreateView): model = TipoTextoArticulado form_class = TipoTaForm template_name = "crud/form.html" form_valid_message = _('Registro criado com sucesso!') form_invalid_message = _('O registro não foi criado.') def get(self, request, *args, **kwargs): self.object = None form = self.get_form() form.fields['content_type'] = forms.ChoiceField( choices=choice_models_in_extenal_views(), label=_('Modelo Integrado'), required=False) return self.render_to_response(self.get_context_data(form=form)) def get_success_url(self): return reverse_lazy('compilacao:tipo_ta_detail', kwargs={'pk': self.object.id}) @property def cancel_url(self): return reverse_lazy('compilacao:tipo_ta_list') class TipoTaDetailView(CompMixin, DetailView): model = TipoTextoArticulado class TipoTaUpdateView(CompMixin, UpdateView): model = TipoTextoArticulado form_class = TipoTaForm template_name = "crud/form.html" def get(self, request, *args, **kwargs): self.object = self.get_object() form = self.get_form() form.fields['content_type'] = forms.ChoiceField( choices=choice_models_in_extenal_views(), label=_('Modelo Integrado'), required=False) return self.render_to_response(self.get_context_data(form=form)) def get_success_url(self): return reverse_lazy('compilacao:tipo_ta_detail', kwargs={'pk': self.kwargs['pk']}) @property def cancel_url(self): return reverse_lazy('compilacao:tipo_ta_detail', kwargs={'pk': self.kwargs['pk']}) class TipoTaDeleteView(CompMixin, DeleteView): model = TipoTextoArticulado template_name = "crud/confirm_delete.html" @property def detail_url(self): return reverse_lazy('compilacao:tipo_ta_detail', kwargs={'pk': self.kwargs['pk']}) def get_success_url(self): return reverse_lazy('compilacao:tipo_ta_list') class TaListView(ListView): model = TextoArticulado paginate_by = 10 verbose_name = model._meta.verbose_name @property def title(self): return self.model._meta.verbose_name_plural @property def create_url(self): return reverse_lazy('compilacao:ta_create') def get_context_data(self, **kwargs): context = super(TaListView, self).get_context_data(**kwargs) paginator = context['paginator'] page_obj = context['page_obj'] context['page_range'] = make_pagination( page_obj.number, paginator.num_pages) return context class TaDetailView(DetailView): model = TextoArticulado @property def title(self): if self.get_object().content_object: return _( 'Metadados para o Texto Articulado de %s\n' '%s') % ( self.get_object().content_object._meta.verbose_name_plural, self.get_object().content_object) else: return self.get_object() class TaCreateView(FormMessagesMixin, CreateView): model = TextoArticulado form_class = TaForm template_name = "crud/form.html" form_valid_message = _('Registro criado com sucesso!') form_invalid_message = _('O registro não foi criado.') def get_success_url(self): return reverse_lazy('compilacao:ta_detail', kwargs={'pk': self.object.id}) @property def cancel_url(self): return reverse_lazy('compilacao:ta_list') class TaUpdateView(CompMixin, UpdateView): model = TextoArticulado form_class = TaForm template_name = "crud/form.html" def get(self, request, *args, **kwargs): self.object = self.get_object() form = self.get_form() # if self.object and self.object.content_object: # form.fields['tipo_ta'].required = False # form.fields['tipo_ta'].widget.attrs['disabled'] = 'disabled' return self.render_to_response(self.get_context_data(form=form)) def get_success_url(self): return reverse_lazy('compilacao:ta_detail', kwargs={'pk': self.kwargs['pk']}) @property def cancel_url(self): return reverse_lazy('compilacao:ta_detail', kwargs={'pk': self.kwargs['pk']}) class TaDeleteView(CompMixin, DeleteView): model = TextoArticulado template_name = "crud/confirm_delete.html" @property def detail_url(self): return reverse_lazy('compilacao:ta_detail', kwargs={'pk': self.kwargs['pk']}) def get_success_url(self): return reverse_lazy('compilacao:ta_list') class DispositivoSuccessUrlMixin: def get_success_url(self): return reverse_lazy( 'compilacao:dispositivo', kwargs={ 'ta_id': self.kwargs[ 'ta_id'], 'dispositivo_id': self.kwargs[ 'dispositivo_id']}) class NotaMixin(DispositivoSuccessUrlMixin): def get_modelo_nota(self, request): if 'action' in request.GET and request.GET['action'] == 'modelo_nota': tn = TipoNota.objects.get(pk=request.GET['id_tipo']) return True, tn.modelo return False, '' def get_initial(self): dispositivo = get_object_or_404( Dispositivo, pk=self.kwargs.get('dispositivo_id')) initial = {'dispositivo': dispositivo} if 'pk' in self.kwargs: initial['pk'] = self.kwargs.get('pk') return initial @method_decorator(login_required) def dispatch(self, *args, **kwargs): return super(NotaMixin, self).dispatch(*args, **kwargs) class NotasCreateView(NotaMixin, CreateView): template_name = 'compilacao/ajax_form.html' form_class = NotaForm def get(self, request, *args, **kwargs): flag_action, modelo_nota = self.get_modelo_nota(request) if flag_action: return HttpResponse(modelo_nota) return super(NotasCreateView, self).get(request, *args, **kwargs) def post(self, request, *args, **kwargs): self.object = None try: ta_id = kwargs.pop('ta_id') dispositivo_id = kwargs.pop('dispositivo_id') form = NotaForm(request.POST, request.FILES, **kwargs) kwargs['ta_id'] = ta_id kwargs['dispositivo_id'] = dispositivo_id if form.is_valid(): nt = form.save(commit=False) nt.owner_id = request.user.pk nt.save() self.kwargs['pk'] = nt.pk return self.form_valid(form) else: return self.form_invalid(form) except Exception as e: print(e) return HttpResponse("error post") class NotasEditView(NotaMixin, UpdateView): model = Nota template_name = 'compilacao/ajax_form.html' form_class = NotaForm def get(self, request, *args, **kwargs): flag_action, modelo_nota = self.get_modelo_nota(request) if flag_action: return HttpResponse(modelo_nota) return super(NotasEditView, self).get(request, *args, **kwargs) class NotasDeleteView(NotaMixin, TemplateView): def get(self, request, *args, **kwargs): nt = Nota.objects.get(pk=self.kwargs['pk']) nt.delete() return HttpResponseRedirect(self.get_success_url()) class VideMixin(DispositivoSuccessUrlMixin): def get_initial(self): dispositivo_base = get_object_or_404( Dispositivo, pk=self.kwargs.get('dispositivo_id')) initial = {'dispositivo_base': dispositivo_base, } if 'pk' in self.kwargs: initial['pk'] = self.kwargs.get('pk') return initial @method_decorator(login_required) def dispatch(self, *args, **kwargs): return super(VideMixin, self).dispatch(*args, **kwargs) def choice_model_type_foreignkey_in_extenal_views(id_tipo_ta=None): yield None, '-------------' if not id_tipo_ta: return tipo_ta = TipoTextoArticulado.objects.get(pk=id_tipo_ta) integrations_view_names = get_integrations_view_names() for item in integrations_view_names: if hasattr(item, 'model_type_foreignkey'): if (tipo_ta.content_type.model == item.model.__name__.lower() and tipo_ta.content_type.app_label == item.model._meta.app_label): for i in item.model_type_foreignkey.objects.all(): yield i.pk, i class VideCreateView(VideMixin, CreateView): model = Vide template_name = 'compilacao/ajax_form.html' form_class = VideForm def get(self, request, *args, **kwargs): self.object = None form = self.get_form() return self.render_to_response(self.get_context_data(form=form)) """ def get_form_kwargs(self): kwargs = super(VideCreateView, self).get_form_kwargs() if 'choice_model_type_foreignkey_in_extenal_views' not in kwargs: kwargs.update({ 'choice_model_type_foreignkey_in_extenal_views': choice_model_type_foreignkey_in_extenal_views }) return kwargs""" class VideEditView(VideMixin, UpdateView): model = Vide template_name = 'compilacao/ajax_form.html' form_class = VideForm class VideDeleteView(VideMixin, TemplateView): def get(self, request, *args, **kwargs): vd = Vide.objects.get(pk=self.kwargs['pk']) vd.delete() return HttpResponseRedirect(self.get_success_url()) class PublicacaoListView(ListView): model = Publicacao verbose_name = model._meta.verbose_name @property def title(self): return _('%s de %s' % ( self.model._meta.verbose_name_plural, self.ta)) @property def ta(self): ta = TextoArticulado.objects.get(pk=self.kwargs['ta_id']) return ta @property def create_url(self): return reverse_lazy( 'compilacao:ta_pub_create', kwargs={'ta_id': self.kwargs['ta_id']}) def get_queryset(self): pubs = Publicacao.objects.filter(ta_id=self.kwargs['ta_id']) return pubs def get_context_data(self, **kwargs): context = super(PublicacaoListView, self).get_context_data(**kwargs) context['NO_ENTRIES_MSG'] = CrudListView.no_entries_msg return context class PublicacaoCreateView(FormMessagesMixin, CreateView): model = Publicacao form_class = PublicacaoForm template_name = "crud/form.html" form_valid_message = _('Registro criado com sucesso!') form_invalid_message = _('O registro não foi criado.') def get_success_url(self): return reverse_lazy( 'compilacao:ta_pub_detail', kwargs={ 'pk': self.object.id, 'ta_id': self.kwargs['ta_id']}) @property def cancel_url(self): return reverse_lazy( 'compilacao:ta_pub_list', kwargs={'ta_id': self.kwargs['ta_id']}) def get_initial(self): return {'ta': self.kwargs['ta_id']} class PublicacaoDetailView(CompMixin, DetailView): model = Publicacao class PublicacaoUpdateView(CompMixin, UpdateView): model = Publicacao form_class = PublicacaoForm template_name = "crud/form.html" def get(self, request, *args, **kwargs): self.object = self.get_object() form = self.get_form() # if self.object and self.object.content_object: # form.fields['tipo_ta'].required = False # form.fields['tipo_ta'].widget.attrs['disabled'] = 'disabled' return self.render_to_response(self.get_context_data(form=form)) def get_success_url(self): return reverse_lazy('compilacao:ta_pub_detail', kwargs={ 'pk': self.object.id, 'ta_id': self.kwargs['ta_id']}) @property def cancel_url(self): return self.get_success_url() class PublicacaoDeleteView(CompMixin, DeleteView): model = Publicacao template_name = "crud/confirm_delete.html" @property def detail_url(self): return reverse_lazy('compilacao:ta_pub_detail', kwargs={ 'pk': self.object.id, 'ta_id': self.kwargs['ta_id']}) def get_success_url(self): return reverse_lazy('compilacao:ta_pub_list', kwargs={'ta_id': self.kwargs['ta_id']}) class TextView(ListView, CompMixin): template_name = 'compilacao/text_list.html' flag_alteradora = -1 flag_nivel_ini = 0 flag_nivel_old = -1 itens_de_vigencia = {} inicio_vigencia = None fim_vigencia = None ta_vigencia = None def get(self, request, *args, **kwargs): ta = TextoArticulado.objects.get(pk=self.kwargs['ta_id']) self.object = ta if ta.content_object: item = ta.content_object self.object = item if hasattr(item, 'ementa') and item.ementa: ta.ementa = item.ementa else: ta.ementa = _('Integração com %s sem ementa.') % item if hasattr(item, 'observacao') and item.observacao: ta.observacao = item.observacao else: ta.observacao = _('Integração com %s sem observacao.') % item if hasattr(item, 'numero') and item.numero: ta.numero = item.numero else: ta.numero = int('%s%s%s' % ( int(datetime.now().year), int(datetime.now().month), int(datetime.now().day))) if hasattr(item, 'ano') and item.ano: ta.ano = item.ano else: ta.ano = datetime.now().year if hasattr(item, 'data_apresentacao'): ta.data = item.data_apresentacao elif hasattr(item, 'data'): ta.data = item.data else: ta.data = datetime.now() ta.save() return super(TextView, self).get(request, *args, **kwargs) def get_context_data(self, **kwargs): context = super(TextView, self).get_context_data(**kwargs) context['object'] = TextoArticulado.objects.get( pk=self.kwargs['ta_id']) cita = Vide.objects.filter( Q(dispositivo_base__ta_id=self.kwargs['ta_id'])).\ select_related( 'dispositivo_ref', 'dispositivo_ref__ta', 'dispositivo_ref__dispositivo_pai', 'dispositivo_ref__dispositivo_pai__ta', 'tipo') context['cita'] = {} for c in cita: if c.dispositivo_base_id not in context['cita']: context['cita'][c.dispositivo_base_id] = [] context['cita'][c.dispositivo_base_id].append(c) citado = Vide.objects.filter( Q(dispositivo_ref__ta_id=self.kwargs['ta_id'])).\ select_related( 'dispositivo_base', 'dispositivo_base__ta', 'dispositivo_base__dispositivo_pai', 'dispositivo_base__dispositivo_pai__ta', 'tipo') context['citado'] = {} for c in citado: if c.dispositivo_ref_id not in context['citado']: context['citado'][c.dispositivo_ref_id] = [] context['citado'][c.dispositivo_ref_id].append(c) notas = Nota.objects.filter( dispositivo__ta_id=self.kwargs['ta_id']).select_related( 'owner', 'tipo') context['notas'] = {} for n in notas: if n.dispositivo_id not in context['notas']: context['notas'][n.dispositivo_id] = [] context['notas'][n.dispositivo_id].append(n) tas_pub = [d.ta_publicado for d in self.object_list if d.ta_publicado] tas_pub = set(tas_pub) ta_pub_list = {} for ta in tas_pub: ta_pub_list[ta.pk] = str(ta) context['ta_pub_list'] = ta_pub_list # context['vigencias'] = self.get_vigencias() return context def get_queryset(self): self.flag_alteradora = -1 self.flag_nivel_ini = 0 self.flag_nivel_old = -1 self.inicio_vigencia = None self.fim_vigencia = None self.ta_vigencia = None if 'sign' in self.kwargs: signer = Signer() try: string = signer.unsign(self.kwargs['sign']).split(',') self.ta_vigencia = int(string[0]) self.inicio_vigencia = parse_date(string[1]) self.fim_vigencia = parse_date(string[2]) except: return Dispositivo.objects.filter( ordem__gt=0, ta_id=self.kwargs['ta_id'], ).select_related(*DISPOSITIVO_SELECT_RELATED) return Dispositivo.objects.filter( inicio_vigencia__lte=self.fim_vigencia, ordem__gt=0, ta_id=self.kwargs['ta_id'], ).select_related(*DISPOSITIVO_SELECT_RELATED) else: r = Dispositivo.objects.filter( ordem__gt=0, ta_id=self.kwargs['ta_id'], ).select_related(*DISPOSITIVO_SELECT_RELATED) return r def get_vigencias(self): itens = Dispositivo.objects.filter( ta_id=self.kwargs['ta_id'], ).order_by( 'inicio_vigencia' ).distinct( 'inicio_vigencia' ).select_related( 'ta_publicado', 'ta', 'ta_publicado__tipo_ta', 'ta__tipo_ta',) ajuste_datas_vigencia = [] for item in itens: ajuste_datas_vigencia.append(item) lenLista = len(ajuste_datas_vigencia) for i in range(lenLista): if i + 1 < lenLista: ajuste_datas_vigencia[ i].fim_vigencia = ajuste_datas_vigencia[ i + 1].inicio_vigencia - timedelta(days=1) else: ajuste_datas_vigencia[i].fim_vigencia = None self.itens_de_vigencia = {} idx = -1 length = len(ajuste_datas_vigencia) for item in ajuste_datas_vigencia: idx += 1 if idx == 0: self.itens_de_vigencia[0] = [item, ] continue if idx + 1 < length: ano = item.ta_publicado.ano if item.ta_publicado else\ item.ta.ano if ano in self.itens_de_vigencia: self.itens_de_vigencia[ano].append(item) else: self.itens_de_vigencia[ano] = [item, ] else: self.itens_de_vigencia[9999] = [item, ] if len(self.itens_de_vigencia.keys()) <= 1: return {} self.itens_de_vigencia = OrderedDict( sorted(self.itens_de_vigencia.items(), key=lambda t: t[0])) return self.itens_de_vigencia def is_ta_alterador(self): if self.flag_alteradora == -1: self.flag_alteradora = Dispositivo.objects.select_related( 'dispositivos_alterados_pelo_texto_articulado_set' ).filter(ta_id=self.kwargs['ta_id']).count() return self.flag_alteradora > 0 class DispositivoView(TextView): # template_name = 'compilacao/index.html' template_name = 'compilacao/text_list_bloco.html' def get_queryset(self): self.flag_alteradora = -1 self.flag_nivel_ini = 0 self.flag_nivel_old = -1 try: bloco = Dispositivo.objects.get(pk=self.kwargs['dispositivo_id']) except Dispositivo.DoesNotExist: return [] self.flag_nivel_old = bloco.nivel - 1 self.flag_nivel_ini = bloco.nivel proximo_bloco = Dispositivo.objects.filter( ordem__gt=bloco.ordem, nivel__lte=bloco.nivel, ta_id=self.kwargs['ta_id'])[:1] if proximo_bloco.count() == 0: itens = Dispositivo.objects.filter( ordem__gte=bloco.ordem, ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) else: itens = Dispositivo.objects.filter( ordem__gte=bloco.ordem, ordem__lt=proximo_bloco[0].ordem, ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) return itens class TextEditView(ListView, CompMixin): template_name = 'compilacao/text_edit.html' flag_alteradora = -1 flag_nivel_ini = 0 flag_nivel_old = -1 pk_edit = 0 pk_view = 0 def get(self, request, *args, **kwargs): return ListView.get(self, request, *args, **kwargs) def get_context_data(self, **kwargs): context = super(TextEditView, self).get_context_data(**kwargs) ta = TextoArticulado.objects.get(pk=self.kwargs['ta_id']) self.object = ta context['object'] = self.object tas_pub = [d.ta_publicado for d in self.object_list if d.ta_publicado] tas_pub = set(tas_pub) ta_pub_list = {} for ta in tas_pub: ta_pub_list[ta.pk] = str(ta) context['ta_pub_list'] = ta_pub_list return context def get_queryset(self): self.pk_edit = 0 self.pk_view = 0 self.flag_alteradora = -1 self.flag_nivel_ini = 0 self.flag_nivel_old = -1 result = Dispositivo.objects.filter( ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) if not result.exists(): ta = TextoArticulado.objects.get(pk=self.kwargs['ta_id']) td = TipoDispositivo.objects.filter(class_css='articulacao')[0] a = Dispositivo() a.nivel = 0 a.ordem = Dispositivo.INTERVALO_ORDEM a.ordem_bloco_atualizador = 0 a.set_numero_completo([1, 0, 0, 0, 0, 0, ]) a.ta = ta a.tipo_dispositivo = td a.inicio_vigencia = ta.data a.inicio_eficacia = ta.data a.save() td = TipoDispositivo.objects.filter(class_css='ementa')[0] e = Dispositivo() e.nivel = 1 e.ordem = a.ordem + Dispositivo.INTERVALO_ORDEM e.ordem_bloco_atualizador = 0 e.set_numero_completo([1, 0, 0, 0, 0, 0, ]) e.ta = ta e.tipo_dispositivo = td e.inicio_vigencia = ta.data e.inicio_eficacia = ta.data e.texto = ta.ementa e.dispositivo_pai = a e.save() a.pk = None a.nivel = 0 a.ordem = e.ordem + Dispositivo.INTERVALO_ORDEM a.ordem_bloco_atualizador = 0 a.set_numero_completo([2, 0, 0, 0, 0, 0, ]) a.save() result = Dispositivo.objects.filter( ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) return result def set_perfil_in_session(self, request=None, perfil_id=0): if not request: return None if perfil_id: perfil = PerfilEstruturalTextoArticulado.objects.get( pk=perfil_id) request.session['perfil_estrutural'] = perfil.pk else: perfis = PerfilEstruturalTextoArticulado.objects.filter( padrao=True)[:1] if not perfis.exists(): request.session.pop('perfil_estrutural') else: request.session['perfil_estrutural'] = perfis[0].pk class DispositivoSimpleEditView(TextEditView): template_name = 'compilacao/text_edit_bloco.html' def post(self, request, *args, **kwargs): d = Dispositivo.objects.get( pk=self.kwargs['dispositivo_id']) texto = request.POST['texto'] if d.texto != '': d.texto = texto d.save() return self.get(request, *args, **kwargs) d.texto = texto.strip() d.save() if texto != '': dnext = Dispositivo.objects.filter( ta_id=d.ta_id, ordem__gt=d.ordem, texto='', tipo_dispositivo__dispositivo_de_articulacao=False)[:1] if not dnext.exists(): dnext = [] dnext.append(d) pais = [d.dispositivo_pai_id, ] else: if dnext[0].nivel > d.nivel: pais = [d.pk, ] else: if dnext[0].dispositivo_pai_id == d.dispositivo_pai_id: pais = [dnext[0].dispositivo_pai_id, ] else: pais = [ dnext[0].dispositivo_pai_id, d.dispositivo_pai_id] data = {'pk': dnext[0].pk, 'pai': pais} else: data = {'pk': d.pk, 'pai': [d.pk, ]} return JsonResponse(data, safe=False) def get_queryset_perfil_estrutural(self): perfis = PerfilEstruturalTextoArticulado.objects.all() return perfis def get(self, request, *args, **kwargs): try: if 'perfil_pk' in request.GET: self.set_perfil_in_session( request, request.GET['perfil_pk']) elif 'perfil_estrutural' not in request.session: self.set_perfil_in_session(request=request) self.object_list = self.get_queryset() self.perfil_estrutural_list = self.get_queryset_perfil_estrutural() context = self.get_context_data( object_list=self.object_list, perfil_estrutural_list=self.perfil_estrutural_list ) except Exception as e: print(e) return self.render_to_response(context) def get_queryset(self): self.flag_alteradora = -1 self.flag_nivel_ini = 0 self.flag_nivel_old = -1 try: self.pk_edit = int(self.request.GET['edit']) except: self.pk_edit = 0 self.pk_view = int(self.kwargs['dispositivo_id']) try: if self.pk_edit == self.pk_view: bloco = Dispositivo.objects.get( pk=self.kwargs['dispositivo_id']) else: bloco = Dispositivo.objects.get( pk=self.kwargs['dispositivo_id']) except Dispositivo.DoesNotExist: return [] self.flag_nivel_old = bloco.nivel - 1 self.flag_nivel_ini = bloco.nivel if self.pk_edit == self.pk_view: return [bloco, ] proximo_bloco = Dispositivo.objects.filter( ordem__gt=bloco.ordem, nivel__lte=bloco.nivel, ta_id=self.kwargs['ta_id'])[:1] if proximo_bloco.count() == 0: itens = Dispositivo.objects.filter( ordem__gte=bloco.ordem, ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) else: itens = Dispositivo.objects.filter( ordem__gte=bloco.ordem, ordem__lt=proximo_bloco[0].ordem, ta_id=self.kwargs['ta_id'] ).select_related(*DISPOSITIVO_SELECT_RELATED) return itens def select_provaveis_inserts(self, request=None): try: if request and 'perfil_estrutural' not in request.session: self.set_perfil_in_session(request) perfil_pk = request.session['perfil_estrutural'] # Não salvar d_base if self.pk_edit == 0: base = Dispositivo.objects.get(pk=self.pk_view) else: base = Dispositivo.objects.get(pk=self.pk_edit) prox_possivel = Dispositivo.objects.filter( ordem__gt=base.ordem, nivel__lte=base.nivel, ta_id=base.ta_id)[:1] if prox_possivel.exists(): prox_possivel = prox_possivel[0] else: prox_possivel = None result = [{'tipo_insert': _('Inserir Depois'), 'icone': '↷ ', 'action': 'add_next', 'itens': []}, {'tipo_insert': _('Inserir Dentro'), 'icone': '⇲ ', 'action': 'add_in', 'itens': []}, {'tipo_insert': _('Inserir Antes'), 'icone': '↶ ', 'action': 'add_prior', 'itens': []} ] # Possíveis inserções sequenciais já existentes parents = base.get_parents() parents.insert(0, base) nivel = sys.maxsize for dp in parents: if dp.nivel >= nivel: continue if dp.is_relative_auto_insert(perfil_pk): continue if prox_possivel and \ dp.tipo_dispositivo != base.tipo_dispositivo and\ dp.nivel < prox_possivel.nivel and\ not prox_possivel.tipo_dispositivo.permitido_inserir_in( dp.tipo_dispositivo, perfil_pk=perfil_pk): if dp.tipo_dispositivo != prox_possivel.tipo_dispositivo: continue nivel = dp.nivel # um do mesmo para inserção antes if dp == base: result[2]['itens'].append({ 'class_css': dp.tipo_dispositivo.class_css, 'tipo_pk': dp.tipo_dispositivo.pk, 'variacao': 0, 'provavel': '%s (%s)' % ( dp.rotulo_padrao(local_insert=1), dp.tipo_dispositivo.nome,), 'dispositivo_base': base.pk}) if dp.dispositivo_pai: flag_pv = dp.tipo_dispositivo.permitido_variacao( dp.dispositivo_pai.tipo_dispositivo, perfil_pk=perfil_pk) else: flag_pv = False r = [] flag_direcao = 1 flag_variacao = 0 while True: if dp.dispositivo0 == 0: local_insert = 1 else: local_insert = 0 rt = dp.transform_in_next(flag_direcao) if not rt[0]: break flag_variacao += rt[1] r.append({'class_css': dp.tipo_dispositivo.class_css, 'tipo_pk': dp.tipo_dispositivo.pk, 'variacao': flag_variacao, 'provavel': '%s (%s)' % ( dp.rotulo_padrao(local_insert), dp.tipo_dispositivo.nome,), 'dispositivo_base': base.pk}) flag_direcao = -1 r.reverse() if not flag_pv: r = [r[0], ] if len(r) > 0 and dp.tipo_dispositivo.formato_variacao0 == \ TipoDispositivo.FNCN: r = [r[0], ] if dp.tipo_dispositivo == base.tipo_dispositivo: result[0]['itens'] += r else: result[0]['itens'] += r result[2]['itens'] += r if nivel == 0: break # tipo do dispositivo base tipb = base.tipo_dispositivo for paradentro in [1, 0]: if paradentro: # Outros Tipos de Dispositivos PARA DENTRO otds = TipoDispositivo.objects.order_by( '-contagem_continua', 'id').all() else: # Outros Tipos de Dispositivos PARA FORA classes_ja_inseridas = [] for c in result[0]['itens']: if c['class_css'] not in classes_ja_inseridas: classes_ja_inseridas.append(c['class_css']) for c in result[1]['itens']: if c['class_css'] not in classes_ja_inseridas: classes_ja_inseridas.append(c['class_css']) otds = TipoDispositivo.objects.order_by( '-contagem_continua', 'id').all().exclude( class_css__in=classes_ja_inseridas) for td in otds: if paradentro and not td.permitido_inserir_in( tipb, include_relative_autos=False, perfil_pk=perfil_pk): continue base.tipo_dispositivo = td if not paradentro: flag_insercao = False for possivelpai in parents: if td.permitido_inserir_in( possivelpai.tipo_dispositivo, include_relative_autos=False, perfil_pk=perfil_pk): flag_insercao = True break if not flag_insercao: continue if possivelpai.is_relative_auto_insert(perfil_pk): continue if prox_possivel: if prox_possivel.nivel == base.nivel: if prox_possivel.tipo_dispositivo != td and\ not prox_possivel.tipo_dispositivo.\ permitido_inserir_in( td, perfil_pk=perfil_pk): continue else: if possivelpai.tipo_dispositivo != \ prox_possivel.tipo_dispositivo and\ not prox_possivel.tipo_dispositivo.\ permitido_inserir_in( possivelpai.tipo_dispositivo, perfil_pk=perfil_pk) and \ possivelpai.nivel < \ prox_possivel.nivel: continue base.dispositivo_pai = possivelpai Dispositivo.set_numero_for_add_in( possivelpai, base, td) else: Dispositivo.set_numero_for_add_in(base, base, td) r = [{'class_css': td.class_css, 'tipo_pk': td.pk, 'variacao': 0, 'provavel': '%s (%s)' % ( base.rotulo_padrao(1, paradentro), td.nome,), 'dispositivo_base': base.pk}] if paradentro == 1: """if (tipb.class_css == 'caput' and td.class_css == 'paragrafo'): result[0]['itens'].insert(0, r[0]) else:""" result[1]['itens'] += r else: result[2]['itens'] += r result[0]['itens'] += r # if len(result[0]['itens']) < len(result[1]['itens']): # r = result[0] # result.remove(result[0]) # result.insert(1, r) # remover temporariamente a opção inserir antes # confirmar falta de necessidade if len(result) > 2: result.pop() except Exception as e: print(e) return result class ActionsEditMixin: def render_to_json_response(self, context, **response_kwargs): action = getattr(self, context['action']) return JsonResponse(action(context), safe=False) def set_dvt(self, context): # Dispositivo de Vigência do Texto Original e de Dpts Alterados dvt = Dispositivo.objects.get(pk=context['dispositivo_id']) if dvt.is_relative_auto_insert(): dvt = dvt.dispositivo_pai try: Dispositivo.objects.filter( (Q(ta=dvt.ta) & Q(ta_publicado__isnull=True)) | Q(ta_publicado=dvt.ta) ).update( dispositivo_vigencia=dvt, inicio_vigencia=dvt.inicio_vigencia, inicio_eficacia=dvt.inicio_eficacia) dps = Dispositivo.objects.filter(dispositivo_vigencia_id=dvt.pk, ta_publicado_id=dvt.ta_id) with transaction.atomic(): for d in dps: if d.dispositivo_substituido: ds = d.dispositivo_substituido ds.fim_vigencia = d.inicio_vigencia - timedelta(days=1) ds.fim_eficacia = d.inicio_eficacia - timedelta(days=1) d.save() if d.dispositivo_subsequente: ds = d.dispositivo_subsequente d.fim_vigencia = ds.inicio_vigencia - timedelta(days=1) d.fim_eficacia = ds.inicio_eficacia - timedelta(days=1) d.save() return {'message': str(_('Dispositivo de Vigência atualizado ' 'com sucesso!!!'))} except: return {'message': str(_('Ocorreu um erro na atualização do ' 'Dispositivo de Vigência'))} def delete_item_dispositivo(self, context): return self.delete_bloco_dispositivo(context, bloco=False) def delete_bloco_dispositivo(self, context, bloco=True): base = Dispositivo.objects.get(pk=context['dispositivo_id']) base_anterior = Dispositivo.objects.order_by('-ordem').filter( ta_id=base.ta_id, ordem__lt=base.ordem ).first() data = {} if base_anterior: data = self.get_json_for_refresh(base_anterior) else: base_anterior = Dispositivo.objects.order_by('ordem').filter( ta_id=base.ta_id, ordem__lt=base.ordem ).first() if base_anterior: data = self.get_json_for_refresh(base_anterior) else: data['pk'] = '' ta_base = base.ta # TODO: a linha abaixo causa atualização da tela inteira... # retirar a linha abaixo e identificar atualizações pontuais data['pai'] = [-1, ] try: with transaction.atomic(): data['message'] = str(self.remover_dispositivo(base, bloco)) ta_base.organizar_ordem_de_dispositivos() except Exception as e: print(e) data['pk'] = context['dispositivo_id'] data['message'] = str(_('Ocorreu um erro ao ' 'excluir esse Dispositivo')) return data def remover_dispositivo(self, base, bloco): base_ordem = base.ordem if base.dispositivo_subsequente or base.dispositivo_substituido: p = base.dispositivo_substituido n = base.dispositivo_subsequente if n: # print(n.id, n) n.dispositivo_substituido = p n.save() if p: # print(p.id, p) p.dispositivo_subsequente = n if n: p.fim_vigencia = n.ini_vigencia - timedelta(days=1) p.fim_eficacia = n.ini_eficacia - timedelta(days=1) else: p.fim_vigencia = None p.fim_eficacia = None for d in base.dispositivos_filhos_set.all(): if d.is_relative_auto_insert(): self.remover_dispositivo(d, bloco) elif not bloco: p.dispositivos_filhos_set.add(d) p.save() base.delete() else: proxima_articulacao = base.get_proximo_nivel_zero() if not bloco: # tranferir filhos para primeiro pai possível acima da base # de exclusão for d in base.dispositivos_filhos_set.all(): # inserções automáticas são excluidas junto com sua base, # independente da escolha do usuário """ TODO: Criar possibilidade de transferência de filhos de dispositivos automáticos ex: na exclusão de artigos, na versão atual, os caputs serão excluidos automáticamente mesmo que a exclusão não seja em bloco. O que fazer com os incisos? transferir para o caput imediatamente acima visto se tratar de uma exclusão de item?""" d_nivel_old = d.nivel if d.is_relative_auto_insert(): d.delete() continue # encontrar possível pai que será o primeiro parent # possível dos parents do dispostivo # imediatamente anterior ao dispositivo base anterior = Dispositivo.objects.order_by('-ordem').filter( ta_id=base.ta_id, ordem__lt=d.ordem).exclude( pk=base.pk).exclude( dispositivo_pai=base).first() if not anterior: return _('Não é possível excluir este Dispositivo sem' ' excluir toda a sua estrutura!!!') if anterior.tipo_dispositivo == d.tipo_dispositivo: d.dispositivo_pai = anterior.dispositivo_pai d.nivel = anterior.nivel if not d.tipo_dispositivo.contagem_continua: d.set_numero_completo( anterior.get_numero_completo()) if d.dispositivo_substituido != anterior: d.transform_in_next() d.rotulo = d.rotulo_padrao() else: parents = [anterior, ] + anterior.get_parents() for candidato in parents: if candidato == base: return _('Não é possível excluir este ' 'Dispositivo sem ' 'excluir toda a sua estrutura!!!') if (candidato.tipo_dispositivo == d.tipo_dispositivo): d.dispositivo_pai = candidato.dispositivo_pai d.nivel = candidato.nivel if not d.tipo_dispositivo.contagem_continua: d.set_numero_completo( candidato.get_numero_completo()) if d.dispositivo_substituido != candidato: d.transform_in_next() d.rotulo = d.rotulo_padrao() break elif (candidato.tipo_dispositivo == d.dispositivo_pai.tipo_dispositivo): d.dispositivo_pai = candidato d.nivel = candidato.nivel + 1 break elif d.tipo_dispositivo.possiveis_pais.filter( pai=candidato.tipo_dispositivo, perfil__padrao=True).exists(): d.dispositivo_pai = candidato if ';' in d.tipo_dispositivo.\ rotulo_prefixo_texto: d.set_numero_completo([0, 0, 0, 0, 0, 0, ]) else: d.set_numero_completo([1, 0, 0, 0, 0, 0, ]) d.nivel = candidato.nivel + 1 d.rotulo = d.rotulo_padrao() break if not parents: d.dispositivo_pai = anterior d.nivel = anterior.nivel + 1 d.save(clean=False) if d.nivel != d_nivel_old: d.organizar_niveis() pai_base = base.dispositivo_pai if pai_base: # Localizar irmaos posteriores do mesmo tipo de base # se não DCC if not base.tipo_dispositivo.contagem_continua: irmaos_posteriores = pai_base.dispositivos_filhos_set.\ filter( ordem__gt=base_ordem, tipo_dispositivo=base.tipo_dispositivo) # se DCC else: irmaos_posteriores = Dispositivo.objects.order_by( 'ordem').filter( ta_id=base.ta_id, ordem__gt=base_ordem, tipo_dispositivo_id=base.tipo_dispositivo_id) if proxima_articulacao: irmaos_posteriores = irmaos_posteriores.exclude( ordem__gte=proxima_articulacao.ordem) # excluir e renumerar irmaos profundidade_base = base.get_profundidade() base.delete() for irmao in irmaos_posteriores: irmao.transform_in_prior( profundidade=profundidade_base) irmao.rotulo = irmao.rotulo_padrao() irmao.save() irmaos = pai_base.dispositivos_filhos_set.\ filter(tipo_dispositivo=base.tipo_dispositivo) if (irmaos.count() == 1 and ';' in irmaos[0]. tipo_dispositivo.rotulo_prefixo_texto): i = irmaos[0] i.set_numero_completo([0, 0, 0, 0, 0, 0, ]) i.rotulo = i.rotulo_padrao(local_insert=1) i.save() else: # Renumerar Dispostivos de Contagem Contínua # de dentro da base se pai dcc = Dispositivo.objects.order_by('ordem').filter( ta_id=base.ta_id, ordem__gt=base.ordem, tipo_dispositivo__contagem_continua=True) if proxima_articulacao: dcc = dcc.exclude( ordem__gte=proxima_articulacao.ordem) base_adicao = {} nivel_zero_anterior = base.get_nivel_zero_anterior() if nivel_zero_anterior: nivel_zero_anterior = nivel_zero_anterior.ordem else: nivel_zero_anterior = 0 dcc = list(dcc) for d in dcc: # ultimo DCC do tipo encontrado if d.tipo_dispositivo.class_css not in base_adicao: ultimo_dcc = Dispositivo.objects.order_by( 'ordem').filter( ta_id=base.ta_id, ordem__lt=base.ordem, ordem__gt=nivel_zero_anterior, tipo_dispositivo__contagem_continua=True, tipo_dispositivo=d.tipo_dispositivo).last() if not ultimo_dcc: break base_adicao[ d.tipo_dispositivo.class_css] = ultimo_dcc.\ dispositivo0 d.dispositivo0 += base_adicao[ d.tipo_dispositivo.class_css] d.rotulo = d.rotulo_padrao() dcc.reverse() for d in dcc: d.save() base.delete() # em Bloco else: # Religar numeração de dispositivos de contagem contínua # que serão excluidos # pbi - proxima base independente pbi = Dispositivo.objects.\ order_by('ordem').filter( ta_id=base.ta_id, ordem__gt=base_ordem, nivel__lte=base.nivel).first() if not pbi: base.delete() else: dcc_a_excluir = Dispositivo.objects.order_by( 'ordem').filter( ta_id=base.ta_id, ordem__gte=base_ordem, ordem__lt=pbi.ordem, tipo_dispositivo__contagem_continua=True) if proxima_articulacao: dcc_a_excluir = dcc_a_excluir.exclude( ordem__gte=proxima_articulacao.ordem) religado = {} for d in dcc_a_excluir: if d.tipo_dispositivo.class_css in religado: continue religado[ d.tipo_dispositivo.class_css] = d.dispositivo0 dcc_a_religar = Dispositivo.objects.filter( ta_id=d.ta_id, ordem__gte=pbi.ordem, tipo_dispositivo=d.tipo_dispositivo) if proxima_articulacao: dcc_a_religar = dcc_a_religar.exclude( ordem__gte=proxima_articulacao.ordem) primeiro_a_religar = 0 for dr in dcc_a_religar: if not primeiro_a_religar: primeiro_a_religar = dr.dispositivo0 base.delete() dr.dispositivo0 = ( dr.dispositivo0 - primeiro_a_religar + d.dispositivo0) dr.rotulo = dr.rotulo_padrao() dr.save(clean=base != dr) if base.pk: base.delete() return '' def add_prior(self, context): return {} def add_in(self, context): return self.add_next(context, local_add='add_in') def add_next(self, context, local_add='add_next'): try: dp_auto_insert = None base = Dispositivo.objects.get(pk=context['dispositivo_id']) tipo = TipoDispositivo.objects.get(pk=context['tipo_pk']) pub_last = Publicacao.objects.order_by( 'data', 'hora').filter(ta=base.ta).last() variacao = int(context['variacao']) parents = [base, ] + base.get_parents() if 'perfil_pk' not in context: perfil_padrao = PerfilEstruturalTextoArticulado.objects.filter( padrao=True).first() if perfil_padrao: context['perfil_pk'] = perfil_padrao.pk else: raise Exception('Não existe perfil padrão!') tipos_dp_auto_insert = tipo.filhos_permitidos.filter( filho_de_insercao_automatica=True, perfil_id=context['perfil_pk']) count_auto_insert = 0 for tipoauto in tipos_dp_auto_insert: qtdp = tipoauto.quantidade_permitida if qtdp >= 0: qtdp -= Dispositivo.objects.filter( ta_id=base.ta_id, tipo_dispositivo_id=tipoauto.filho_permitido.pk ).count() if qtdp > 0: count_auto_insert += 1 else: count_auto_insert += 1 dp_irmao = None dp_pai = None for dp in parents: if dp.tipo_dispositivo == tipo: dp_irmao = dp break if tipo.permitido_inserir_in( dp.tipo_dispositivo, perfil_pk=context['perfil_pk']): dp_pai = dp break dp_pai = dp if dp_irmao is not None: dp = Dispositivo.new_instance_based_on(dp_irmao, tipo) dp.transform_in_next(variacao) else: # Inserção sem precedente dp = Dispositivo.new_instance_based_on(dp_pai, tipo) dp.dispositivo_pai = dp_pai dp.nivel += 1 if tipo.contagem_continua: ultimo_irmao = Dispositivo.objects.order_by( '-ordem').filter( ordem__lte=base.ordem, ordem__gte=parents[-1].ordem, tipo_dispositivo_id=tipo.pk, ta_id=base.ta_id)[:1] if not ultimo_irmao.exists(): dp.set_numero_completo([1, 0, 0, 0, 0, 0, ]) else: ultimo_irmao = ultimo_irmao[0] dp.set_numero_completo( ultimo_irmao.get_numero_completo()) dp.transform_in_next() else: if ';' in tipo.rotulo_prefixo_texto: dp.set_numero_completo([0, 0, 0, 0, 0, 0, ]) else: dp.set_numero_completo([1, 0, 0, 0, 0, 0, ]) # verificar se existe restrição de quantidade de itens if dp.dispositivo_pai: pp = dp.tipo_dispositivo.possiveis_pais.filter( pai_id=dp.dispositivo_pai.tipo_dispositivo_id, perfil_id=context['perfil_pk']) if pp.exists() and pp[0].quantidade_permitida >= 0: qtd_existente = Dispositivo.objects.filter( ta_id=dp.ta_id, tipo_dispositivo_id=dp.tipo_dispositivo_id).count() if qtd_existente >= pp[0].quantidade_permitida: return {'pk': base.pk, 'pai': [base.dispositivo_pai.pk, ], 'message': str(_('Limite de inserções de ' 'dispositivos deste tipo ' 'foi excedido.')) } ordem = base.criar_espaco( espaco_a_criar=1 + count_auto_insert, local=local_add) dp.rotulo = dp.rotulo_padrao() dp.ordem = ordem dp.incrementar_irmaos(variacao, [local_add, ], force=False) dp.publicacao = pub_last dp.save() # Inserção automática if count_auto_insert: dp_pk = dp.pk dp.nivel += 1 for tipoauto in tipos_dp_auto_insert: dp.dispositivo_pai_id = dp_pk dp.pk = None dp.tipo_dispositivo = tipoauto.filho_permitido if ';' in dp.tipo_dispositivo.rotulo_prefixo_texto: dp.set_numero_completo([0, 0, 0, 0, 0, 0, ]) else: dp.set_numero_completo([1, 0, 0, 0, 0, 0, ]) dp.rotulo = dp.rotulo_padrao() dp.texto = '' dp.ordem = dp.ordem + Dispositivo.INTERVALO_ORDEM dp.publicacao = pub_last dp.save() dp_auto_insert = dp dp = Dispositivo.objects.get(pk=dp_pk) ''' Reenquadrar todos os dispositivos que possuem pai antes da inserção atual e que são inferiores a dp, redirecionando para o novo pai''' nivel = sys.maxsize flag_niveis = False if not dp.tipo_dispositivo.dispositivo_de_alteracao: possiveis_filhos = Dispositivo.objects.filter( ordem__gt=dp.ordem, ta_id=dp.ta_id) for filho in possiveis_filhos: if filho.nivel > nivel: continue if not filho.dispositivo_pai or\ filho.dispositivo_pai.ordem >= dp.ordem: continue nivel = filho.nivel if not filho.tipo_dispositivo.permitido_inserir_in( dp.tipo_dispositivo, perfil_pk=context['perfil_pk']): continue filho.dispositivo_pai = dp filho.save() flag_niveis = True if flag_niveis: dp.organizar_niveis() numtipos = {} ''' Renumerar filhos imediatos que não possuam contagem continua''' if flag_niveis: filhos = Dispositivo.objects.filter( dispositivo_pai_id=dp.pk) for filho in filhos: if filho.tipo_dispositivo.contagem_continua: continue if filho.tipo_dispositivo.class_css in numtipos: if filho.dispositivo_substituido is None: numtipos[filho.tipo_dispositivo.class_css] += 1 else: t = filho.tipo_dispositivo prefixo = t.rotulo_prefixo_texto.split(';') if len(prefixo) > 1: count_irmaos_m_tipo = Dispositivo.objects.filter( ~Q(pk=filho.pk), tipo_dispositivo=t, dispositivo_pai=filho.dispositivo_pai)[:1] if count_irmaos_m_tipo.exists(): numtipos[filho.tipo_dispositivo.class_css] = 1 else: numtipos[filho.tipo_dispositivo.class_css] = 0 else: numtipos[filho.tipo_dispositivo.class_css] = 1 filho.dispositivo0 = numtipos[ filho.tipo_dispositivo.class_css] filho.rotulo = filho.rotulo_padrao() filho.save() ''' Renumerar dispositivos de contagem continua, caso a inserção seja uma articulação''' if dp.nivel == 0: proxima_articulacao = dp.get_proximo_nivel_zero() if not proxima_articulacao: filhos_continuos = list(Dispositivo.objects.filter( ordem__gt=dp.ordem, ta_id=dp.ta_id, tipo_dispositivo__contagem_continua=True)) else: filhos_continuos = list(Dispositivo.objects.filter( ordem__gt=dp.ordem, ordem__lt=proxima_articulacao.ordem, ta_id=dp.ta_id, tipo_dispositivo__contagem_continua=True)) base_reducao = {} for filho in filhos_continuos: if filho.tipo_dispositivo.class_css not in base_reducao: base_reducao[filho.tipo_dispositivo.class_css] = \ filho.dispositivo0 - 1 filho.dispositivo0 -= base_reducao[ filho.tipo_dispositivo.class_css] filho.rotulo = filho.rotulo_padrao() filho.save() except Exception as e: print(e) if dp_auto_insert is None: data = self.get_json_for_refresh(dp) else: data = self.get_json_for_refresh(dp=dp, dpauto=dp_auto_insert) return data def get_json_for_refresh(self, dp, dpauto=None): if dp.tipo_dispositivo.contagem_continua: pais = [] if dp.dispositivo_pai is None: data = {'pk': dp.pk, 'pai': [-1, ]} else: pkfilho = dp.pk dp = dp.dispositivo_pai proxima_articulacao = dp.get_proximo_nivel_zero() if proxima_articulacao is not None: parents = Dispositivo.objects.filter( ta_id=dp.ta_id, ordem__gte=dp.ordem, ordem__lt=proxima_articulacao.ordem, nivel__lte=dp.nivel) else: parents = Dispositivo.objects.filter( ta_id=dp.ta_id, ordem__gte=dp.ordem, nivel__lte=dp.nivel) nivel = sys.maxsize for p in parents: if p.nivel > nivel: continue pais.append(p.pk) nivel = p.nivel data = { 'pk': pkfilho if not dpauto else dpauto.pk, 'pai': pais} else: data = {'pk': dp.pk if not dpauto else dpauto.pk, 'pai': [ dp.dispositivo_pai.pk, ]} return data class ActionsEditView(ActionsEditMixin, TemplateView): def render_to_response(self, context, **response_kwargs): context['action'] = self.request.GET['action'] if 'tipo_pk' in self.request.GET: context['tipo_pk'] = self.request.GET['tipo_pk'] if 'variacao' in self.request.GET: context['variacao'] = self.request.GET['variacao'] if 'perfil_estrutural' in self.request.session: context['perfil_pk'] = self.request.session['perfil_estrutural'] if 'herancas' in self.request.session: del self.request.session['herancas'] del self.request.session['herancas_fila'] return self.render_to_json_response(context, **response_kwargs) class DispositivoSearchFragmentFormView(ListView): template_name = 'compilacao/dispositivo_form_search_fragment.html' def get(self, request, *args, **kwargs): if 'action' in request.GET and request.GET['action'] == 'get_tipos': result = choice_model_type_foreignkey_in_extenal_views( id_tipo_ta=request.GET['tipo_ta']) itens = [] for i in result: item = {} item[i[0] if i[0] else ''] = str(i[1]) itens.append(item) return JsonResponse(itens, safe=False) return ListView.get(self, request, *args, **kwargs) def get_queryset(self): try: n = 10 if 'max_results' in self.request.GET: n = int(self.request.GET['max_results']) q = Q() if 'initial_ref' in self.request.GET: initial_ref = self.request.GET['initial_ref'] if initial_ref: q = q & Q(pk=initial_ref) result = Dispositivo.objects.filter(q).select_related( 'ta').exclude( tipo_dispositivo__dispositivo_de_alteracao=True) return result[:n] str_texto = '' texto = '' rotulo = '' num_ta = '' ano_ta = '' if 'texto' in self.request.GET: str_texto = self.request.GET['texto'] texto = str_texto.split(' ') if 'rotulo' in self.request.GET: rotulo = self.request.GET['rotulo'] if rotulo: q = q & Q(rotulo__icontains=rotulo) for item in texto: if not item: continue if q: q = q & (Q(texto__icontains=item) | Q(texto_atualizador__icontains=item)) else: q = (Q(texto__icontains=item) | Q(texto_atualizador__icontains=item)) if 'tipo_ta' in self.request.GET: tipo_ta = self.request.GET['tipo_ta'] if tipo_ta: q = q & Q(ta__tipo_ta_id=tipo_ta) if 'num_ta' in self.request.GET: num_ta = self.request.GET['num_ta'] if num_ta: q = q & Q(ta__numero=num_ta) if 'ano_ta' in self.request.GET: ano_ta = self.request.GET['ano_ta'] if ano_ta: q = q & Q(ta__ano=ano_ta) if not q.children and not n: n = 10 q = q & Q(nivel__gt=0) result = Dispositivo.objects.order_by( '-ta__data', '-ta__ano', '-ta__numero', 'ta', 'ordem').filter(q).select_related('ta') if 'data_type_selection' in self.request.GET and\ self.request.GET['data_type_selection'] == 'checkbox': result = result.exclude( tipo_dispositivo__dispositivo_de_alteracao=True) else: if 'data_function' in self.request.GET and\ self.request.GET['data_function'] == 'alterador': result = result.exclude( tipo_dispositivo__dispositivo_de_alteracao=False, ) result = result.exclude( tipo_dispositivo__dispositivo_de_articulacao=False, ) print(str(result.query)) def resultados(r): if n: return r[:n] else: return r """if num_ta and ano_ta and not rotulo and not str_texto and\ 'data_type_selection' in self.request.GET and\ self.request.GET['data_type_selection'] == 'checkbox': return r else: return r[:n]""" if 'tipo_model' not in self.request.GET: return resultados(result) tipo_model = self.request.GET['tipo_model'] if not tipo_model: return resultados(result) integrations_view_names = get_integrations_view_names() tipo_ta = TipoTextoArticulado.objects.get(pk=tipo_ta) model_class = None for item in integrations_view_names: if hasattr(item, 'model_type_foreignkey') and\ hasattr(item, 'model'): if (tipo_ta.content_type.model == item.model.__name__.lower() and tipo_ta.content_type.app_label == item.model._meta.app_label): model_class = item.model model_type_class = item.model_type_foreignkey tipo_model = item.model_type_foreignkey.objects.get( pk=tipo_model) break if not model_class: return resultados(result) column_field = '' for field in model_class._meta.fields: if field.related_model == model_type_class: column_field = field.column break if not column_field: return resultados(result) r = [] for d in result: if not d.ta.content_object or\ not hasattr(d.ta.content_object, column_field): continue if tipo_model.pk == getattr(d.ta.content_object, column_field): r.append(d) if (len(r) == n and (not num_ta or not ano_ta or rotulo or str_texto)): break return r except Exception as e: print(e) class DispositivoSearchModalView(FormView): template_name = 'compilacao/dispositivo_form_search.html' form_class = DispositivoSearchModalForm class DispositivoEdicaoBasicaView(FormMessagesMixin, UpdateView): model = Dispositivo template_name = 'compilacao/dispositivo_form_edicao_basica.html' form_class = DispositivoEdicaoBasicaForm form_valid_message = _('Alterações no Dispositivo realizadas com sucesso!') form_invalid_message = _('Houve erro em registrar ' 'as alterações no Dispositivo') @property def cancel_url(self): return reverse_lazy( 'compilacao:ta_text_edit', kwargs={'ta_id': self.kwargs['ta_id']}) + '#' + str(self.object.pk) def get_success_url(self): return reverse_lazy( 'compilacao:dispositivo_edit', kwargs={'ta_id': self.kwargs['ta_id'], 'pk': self.kwargs['pk']}) def get_url_this_view(self): return 'compilacao:dispositivo_edit' def run_actions(self, request): if 'action' in request.GET and\ request.GET['action'] == 'atualiza_rotulo': try: d = Dispositivo.objects.get(pk=self.kwargs['pk']) d.dispositivo0 = int(request.GET['dispositivo0']) d.dispositivo1 = int(request.GET['dispositivo1']) d.dispositivo2 = int(request.GET['dispositivo2']) d.dispositivo3 = int(request.GET['dispositivo3']) d.dispositivo4 = int(request.GET['dispositivo4']) d.dispositivo5 = int(request.GET['dispositivo5']) d.rotulo = d.rotulo_padrao() numero = d.get_numero_completo()[1:] zerar = False for i in range(len(numero)): if not numero[i]: zerar = True if zerar: numero[i] = 0 if zerar: d.set_numero_completo([d.dispositivo0, ] + numero) d.rotulo = d.rotulo_padrao() except: return True, JsonResponse({'message': str( _('Ocorreu erro na atualização do rótulo'))}, safe=False) return True, JsonResponse({ 'rotulo': d.rotulo, 'dispositivo0': d.dispositivo0, 'dispositivo1': d.dispositivo1, 'dispositivo2': d.dispositivo2, 'dispositivo3': d.dispositivo3, 'dispositivo4': d.dispositivo4, 'dispositivo5': d.dispositivo5}, safe=False) return False, '' def get(self, request, *args, **kwargs): flag_action, render_json_response = self.run_actions(request) if flag_action: return render_json_response return UpdateView.get(self, request, *args, **kwargs) class DispositivoEdicaoVigenciaView(FormMessagesMixin, UpdateView): model = Dispositivo template_name = 'compilacao/dispositivo_form_vigencia.html' form_class = DispositivoEdicaoVigenciaForm form_valid_message = _('Alterações no Dispositivo realizadas com sucesso!') form_invalid_message = _('Houve erro em registrar ' 'as alterações no Dispositivo') @property def cancel_url(self): return reverse_lazy( 'compilacao:ta_text_edit', kwargs={'ta_id': self.kwargs['ta_id']}) + '#' + str(self.object.pk) def get_url_this_view(self): return 'compilacao:dispositivo_edit_vigencia' def get_success_url(self): return reverse_lazy( 'compilacao:dispositivo_edit_vigencia', kwargs={'ta_id': self.kwargs['ta_id'], 'pk': self.kwargs['pk']}) class DispositivoDefinidorVigenciaView(FormMessagesMixin, FormView): model = Dispositivo template_name = 'compilacao/dispositivo_form_definidor_vigencia.html' form_class = DispositivoDefinidorVigenciaForm form_valid_message = _('Alterações no Dispositivo realizadas com sucesso!') form_invalid_message = _('Houve erro em registrar ' 'as alterações no Dispositivo') def get_form_kwargs(self): kwargs = FormView.get_form_kwargs(self) kwargs.update({ 'pk': self.kwargs['pk'], }) return kwargs @property def cancel_url(self): return reverse_lazy( 'compilacao:ta_text_edit', kwargs={'ta_id': self.kwargs['ta_id']}) + '#' + str(self.object.pk) def get_url_this_view(self): return 'compilacao:dispositivo_edit_definidor_vigencia' def get_success_url(self): return reverse_lazy( 'compilacao:dispositivo_edit_definidor_vigencia', kwargs={'ta_id': self.kwargs['ta_id'], 'pk': self.kwargs['pk']}) def get(self, request, *args, **kwargs): self.object = get_object_or_404(Dispositivo, pk=kwargs['pk']) return FormView.get(self, request, *args, **kwargs) def get_context_data(self, **kwargs): context = FormView.get_context_data(self, **kwargs) context.update({'object': self.object}) return context def post(self, request, *args, **kwargs): self.object = get_object_or_404(Dispositivo, pk=kwargs['pk']) form = self.get_form() if form.is_valid(): dvs = form.cleaned_data['dispositivo_vigencia'] try: with transaction.atomic(): self.object.dispositivos_vigencias_set.clear() for item in dvs: d = Dispositivo.objects.get(pk=item) self.object.dispositivos_vigencias_set.add(d) return self.form_valid(form) except: return self.form_invalid(form) else: return self.form_invalid(form) class DispositivoEdicaoAlteracaoView(FormMessagesMixin, UpdateView): model = Dispositivo template_name = 'compilacao/dispositivo_form_alteracao.html' form_class = DispositivoEdicaoAlteracaoForm form_valid_message = _('Alterações no Dispositivo realizadas com sucesso!') form_invalid_message = _('Houve erro em registrar ' 'as alterações no Dispositivo') @property def cancel_url(self): return reverse_lazy( 'compilacao:ta_text_edit', kwargs={'ta_id': self.kwargs['ta_id']}) + '#' + str(self.object.pk) def get_url_this_view(self): return 'compilacao:dispositivo_edit_alteracao' def get_success_url(self): return reverse_lazy( 'compilacao:dispositivo_edit_alteracao', kwargs={'ta_id': self.kwargs['ta_id'], 'pk': self.kwargs['pk']}) def post(self, request, *args, **kwargs): self.object = get_object_or_404(Dispositivo, pk=kwargs['pk']) form = self.get_form() if form.is_valid(): try: with transaction.atomic(): return self.form_valid(form) except: return self.form_invalid(form) else: return self.form_invalid(form)