add internal inclusion options for Dispositivo

compilacao/migrations/0010_auto_20151105_1532.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0009_auto_20151007_1635'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TipoDispositivoRelationship',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', auto_created=True, primary_key=True, serialize=False)),
+                ('filho_permitido', models.ForeignKey(related_name='filho_permitido', to='compilacao.TipoDispositivo')),
+                ('pai', models.ForeignKey(related_name='pai', to='compilacao.TipoDispositivo')),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='relacoes_diretas_pai_filho',
+            field=models.ManyToManyField(related_name='filhos_permitidos', through='compilacao.TipoDispositivoRelationship', to='compilacao.TipoDispositivo'),
+        ),
+    ]

compilacao/migrations/0011_auto_20151105_1540.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0010_auto_20151105_1532'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='tipodispositivorelationship',
+            options={'verbose_name': 'Relação Direta Permitida', 'verbose_name_plural': 'Relaçõe Diretas Permitidas', 'ordering': ['pai', 'filho_permitido']},
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivorelationship',
+            name='filho_permitido',
+            field=models.ForeignKey(null=True, to='compilacao.TipoDispositivo', blank=True, default=None, related_name='filho_permitido'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='tipodispositivorelationship',
+            unique_together=set([('pai', 'filho_permitido')]),
+        ),
+    ]

compilacao/migrations/0012_auto_20151105_1658.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0011_auto_20151105_1540'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tipodispositivorelationship',
+            name='filho_de_insercao_automatica',
+            field=models.BooleanField(choices=[(True, 'Sim'), (False, 'Não')], default=False, verbose_name='Filho de Inserção Automática'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='relacoes_diretas_pai_filho',
+            field=models.ManyToManyField(to='compilacao.TipoDispositivo', related_name='possiveis_pais', through='compilacao.TipoDispositivoRelationship'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivorelationship',
+            name='filho_permitido',
+            field=models.ForeignKey(blank=True, default=None, null=True, related_name='pais', to='compilacao.TipoDispositivo'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivorelationship',
+            name='pai',
+            field=models.ForeignKey(to='compilacao.TipoDispositivo', related_name='filhos_permitidos'),
+        ),
+    ]

compilacao/migrations/0013_auto_20151106_1843.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0012_auto_20151105_1658'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='relacoes_diretas_pai_filho',
+            field=models.ManyToManyField(to='compilacao.TipoDispositivo', related_name='_relacoes_diretas_pai_filho_+', through='compilacao.TipoDispositivoRelationship'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivorelationship',
+            name='filho_permitido',
+            field=models.ForeignKey(null=True, blank=True, related_name='possiveis_pais', to='compilacao.TipoDispositivo', default=None),
+        ),
+    ]

compilacao/models.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from django.contrib.auth.models import User
 from django.db import models
-from django.db.models import F
+from django.db.models import F, Q
 from django.db.models.aggregates import Max
 from django.utils.translation import ugettext_lazy as _
 
@@ -75,7 +75,7 @@ class TipoVide(models.Model):
         return '%s: %s' % (self.sigla, self.nome)
 
 
-class TipoDispositivo(models.Model):
+class TipoDispositivo(BaseModel):
     """
     - ids fazem parte da lógica do desenvolvimento quanto a
       simulação de hierarquia
@@ -237,6 +237,13 @@ class TipoDispositivo(models.Model):
         default=FNC1,
         verbose_name=_('Formato da Variação 5'))
 
+    relacoes_diretas_pai_filho = models.ManyToManyField(
+        'self',
+        through='TipoDispositivoRelationship',
+        through_fields=('pai', 'filho_permitido'),
+        symmetrical=False,
+        related_name='+')
+
     class Meta:
         verbose_name = _('Tipo de Dispositivo')
         verbose_name_plural = _('Tipos de Dispositivo')
@@ -245,6 +252,38 @@ class TipoDispositivo(models.Model):
     def __str__(self):
         return self.nome
 
+    def permitido_inserir_in(self, base, excluir_autos=False):
+        pp = self.possiveis_pais.filter(pai=base)
+        if pp.exists():
+            if excluir_autos:
+                if pp[0].filho_de_insercao_automatica:
+                    return False
+            return True
+        return False
+
+
+class TipoDispositivoRelationship(BaseModel):
+    pai = models.ForeignKey(TipoDispositivo, related_name='filhos_permitidos')
+    filho_permitido = models.ForeignKey(
+        TipoDispositivo,
+        blank=True, null=True, default=None,
+        related_name='possiveis_pais')
+    filho_de_insercao_automatica = models.BooleanField(
+        default=False,
+        choices=YES_NO_CHOICES, verbose_name=_('Filho de Inserção Automática'))
+
+    class Meta:
+        verbose_name = _('Relação Direta Permitida')
+        verbose_name_plural = _('Relaçõe Diretas Permitidas')
+        ordering = ['pai', 'filho_permitido']
+        unique_together = (
+            ('pai', 'filho_permitido',),)
+
+    def __str__(self):
+        return '%s - %s' % (
+            self.pai.nome,
+            self.filho_permitido.nome if self.filho_permitido else '')
+
 
 class TipoPublicacao(models.Model):
     sigla = models.CharField(
@@ -445,65 +484,65 @@ class Dispositivo(BaseModel):
             'rotulo': (self.rotulo if self.rotulo else self.tipo_dispositivo),
             'norma': self.norma}
 
-    def rotulo_padrao(self, for_insertion=False,
-                      d_base_for_insertion=None,
-                      insert_next=False):
+    def rotulo_padrao(self, local_insert=0, for_insert_in=0):
+        """
+        0 = Sem inserção - com nomeclatura padrao
+        1 = Inserção com transformação de parágrafo único para §1º """
+
         r = ''
         t = self.tipo_dispositivo
-
         prefixo = t.rotulo_prefixo_texto.split(';')
 
         if len(prefixo) > 1:
 
-            if (for_insertion and
-                    d_base_for_insertion is not None and
-                    d_base_for_insertion.pk != self.pk and
-                    d_base_for_insertion.tipo_dispositivo.pk <= t.pk) or \
-                    for_insertion and d_base_for_insertion is None:
-
-                count_irmaos_mesmo_tipo = Dispositivo.objects.filter(
+            if for_insert_in:
+                irmaos_mesmo_tipo = Dispositivo.objects.filter(
                     tipo_dispositivo=self.tipo_dispositivo,
-                    dispositivo_pai=self).count()
+                    dispositivo_pai=self)
             else:
-                count_irmaos_mesmo_tipo = Dispositivo.objects.filter(
+                irmaos_mesmo_tipo = Dispositivo.objects.filter(
                     tipo_dispositivo=self.tipo_dispositivo,
-                    dispositivo_pai=self.dispositivo_pai).count()
-
-            if count_irmaos_mesmo_tipo > 1 or (
-                    self.dispositivo0 != 0 and not for_insertion):
-                r += prefixo[0]
-                r += self.get_nomenclatura_completa()
-            elif count_irmaos_mesmo_tipo == 1 and for_insertion:
-                numero = self.get_numero_completo()
-
-                if not insert_next:
-                    self.transform_in_next()
-                    self.transform_in_next()
-                    r += 'Transformar %s em %s%s e criar %s 1%s' % (
-                        prefixo[1].strip(),
-                        prefixo[0],
-                        self.get_nomenclatura_completa(),
-                        prefixo[0],
-                        'º' if
-                        self.tipo_dispositivo.rotulo_ordinal >= 0 else '',)
+                    dispositivo_pai=self.dispositivo_pai)
+
+            if not irmaos_mesmo_tipo.exists():
+                r += prefixo[1]
+            else:
+                if self.dispositivo0 == 0:
+                    if for_insert_in:
+                        if irmaos_mesmo_tipo.count() == 0:
+                            r += prefixo[0]
+                            r += self.get_nomenclatura_completa()
+                        elif irmaos_mesmo_tipo.count() == 1:
+                            self.transform_in_next()
+                            self.transform_in_next()
+                            r += 'Transformar %s em %s%s e criar %s1%s' % (
+                                prefixo[1].strip(),
+                                prefixo[0],
+                                self.get_nomenclatura_completa(),
+                                prefixo[0],
+                                'º' if
+                                self.tipo_dispositivo.rotulo_ordinal >= 0
+                                else '',)
+                        else:
+                            self.dispositivo0 = 1
+                            r += prefixo[0]
+                            r += self.get_nomenclatura_completa()
+
+                    else:
+                        r += prefixo[1].strip()
+                        r += self.get_nomenclatura_completa()
                 else:
-                    if numero[0] != 0:
-                        self.transform_in_next()
-                        r += 'Transformar %s em %s 1%s e criar %s%s' % (
+                    if local_insert == 1 and irmaos_mesmo_tipo.count() == 1:
+                        r += 'Transformar %s em %s%s e criar %s 2%s' % (
                             prefixo[1].strip(),
                             prefixo[0],
-                            'º' if
-                            self.tipo_dispositivo.rotulo_ordinal >= 0 else '',
+                            self.get_nomenclatura_completa(),
                             prefixo[0],
-                            self.get_nomenclatura_completa())
+                            'º' if
+                            self.tipo_dispositivo.rotulo_ordinal >= 0 else '',)
                     else:
-                        r += '%s%s' % (
-                            prefixo[1].strip(),
-                            self.get_nomenclatura_completa())
-
-                self.set_numero_completo(numero)
-            else:
-                r += prefixo[1].strip() + self.get_nomenclatura_completa()
+                        r += prefixo[0]
+                        r += self.get_nomenclatura_completa()
         else:
             r += prefixo[0]
             r += self.get_nomenclatura_completa()
@@ -655,18 +694,34 @@ class Dispositivo(BaseModel):
 
         return result
 
-    def criar_espaco_apos(self, espaco_a_criar):
-
-        proximo_bloco = Dispositivo.objects.filter(
-            ordem__gt=self.ordem,
-            nivel__lte=self.nivel,
-            norma_id=self.norma_id)[:1]
+    def criar_espaco(self, espaco_a_criar, local):
+        """
+        -1 = Imediatamente antes
+        0 = Imediatamente Depois
+        1 = Depois - antes do proximo bloco do mesmo tipo"""
+
+        if local == 1:
+            proximo_bloco = Dispositivo.objects.filter(
+                ordem__gt=self.ordem,
+                nivel__lte=self.nivel,
+                norma_id=self.norma_id)[:1]
+        elif local == 0:
+            proximo_bloco = Dispositivo.objects.filter(
+                ordem__gt=self.ordem,
+                nivel__lte=self.nivel + 1,
+                norma_id=self.norma_id).exclude(
+                    tipo_dispositivo__class_css='caput')[:1]
+        else:
+            proximo_bloco = Dispositivo.objects.filter(
+                ordem__gte=self.ordem,
+                norma_id=self.norma_id)[:1]
 
-        if proximo_bloco.count() != 0:
+        if proximo_bloco.exists():
             ordem = proximo_bloco[0].ordem
             proximo_bloco = Dispositivo.objects.order_by('-ordem').filter(
                 ordem__gte=ordem,
                 norma_id=self.norma_id)
+
             proximo_bloco.update(ordem=F('ordem') + 1)
             proximo_bloco.update(
                 ordem=F('ordem') + (
@@ -712,7 +767,8 @@ class Dispositivo(BaseModel):
         return self.get_parents(ordem='asc')
 
     def recalcular_ordem(self):
-        try:
+        pass
+        """try:
             dispositivos = Dispositivo.objects.order_by('-ordem').filter(
                 norma_id=self.norma_id)
         except:
@@ -721,7 +777,131 @@ class Dispositivo(BaseModel):
         for d in dispositivos:
             d.ordem = ordem
             d.save()
-            ordem -= 1000
+            ordem -= 1000"""
+
+    def incrementar_irmaos(self, variacao=0, tipo=[]):
+
+        if not self.tipo_dispositivo.contagem_continua:
+            irmaos = list(Dispositivo.objects.filter(
+                Q(ordem__gt=self.ordem) | Q(dispositivo0=0),
+                dispositivo_pai_id=self.dispositivo_pai_id,
+                tipo_dispositivo_id=self.tipo_dispositivo.pk))
+
+        elif self.tipo_dispositivo.class_css == 'articulacao':
+            irmaos = list(Dispositivo.objects.filter(
+                ordem__gt=self.ordem,
+                norma_id=self.norma_id,
+                tipo_dispositivo_id=self.tipo_dispositivo.pk))
+
+        else:  # contagem continua restrita a articulacao
+            proxima_articulacao = self.get_proxima_articulacao()
+
+            if proxima_articulacao is None:
+                irmaos = list(Dispositivo.objects.filter(
+                    ordem__gt=self.ordem,
+                    norma_id=self.norma_id,
+                    tipo_dispositivo_id=self.tipo_dispositivo.pk))
+            else:
+                irmaos = list(Dispositivo.objects.filter(
+                    Q(ordem__gt=self.ordem) &
+                    Q(ordem__lt=proxima_articulacao.ordem),
+                    norma_id=self.norma_id,
+                    tipo_dispositivo_id=self.tipo_dispositivo.pk))
+
+        dp_profundidade = self.get_profundidade()
+
+        irmaos_a_salvar = []
+        ultimo_irmao = None
+        for irmao in irmaos:
+
+            if irmao.ordem <= self.ordem or irmao.dispositivo0 == 0:
+                irmaos_a_salvar.append(irmao)
+                continue
+
+            irmao_profundidade = irmao.get_profundidade()
+            if irmao_profundidade < dp_profundidade:
+                break
+
+            if irmao.get_numero_completo() < self.get_numero_completo():
+                if irmao_profundidade > dp_profundidade:
+                    if ultimo_irmao is None:
+                        irmao.transform_in_next(
+                            dp_profundidade - irmao_profundidade)
+                        irmao.transform_in_next(
+                            irmao_profundidade - dp_profundidade)
+                    else:
+                        irmao.set_numero_completo(
+                            ultimo_irmao.get_numero_completo())
+
+                        irmao.transform_in_next(
+                            irmao_profundidade -
+                            ultimo_irmao.get_profundidade())
+
+                    ultimo_irmao = irmao
+                else:
+                    irmao.transform_in_next()
+                irmao.rotulo = irmao.rotulo_padrao()
+                irmaos_a_salvar.append(irmao)
+            else:
+                if dp_profundidade == irmao_profundidade and \
+                        dp_profundidade > 0 and \
+                        self.get_numero_completo()[:dp_profundidade] < \
+                        irmao.get_numero_completo()[:dp_profundidade]:
+                    break
+                else:
+                    irmao_numero = irmao.get_numero_completo()
+                    irmao_numero[dp_profundidade] += 1
+                    irmao.set_numero_completo(irmao_numero)
+                    irmao.rotulo = irmao.rotulo_padrao()
+                    irmaos_a_salvar.append(irmao)
+
+        irmaos_a_salvar.reverse()
+        for irmao in irmaos_a_salvar:
+            if (irmao.dispositivo0 == 0 or
+                    irmao.ordem <= self.ordem) and variacao == 0:
+
+                if 'add_in' in tipo:
+                    irmao.dispositivo0 = 2
+                    irmao.rotulo = irmao.rotulo_padrao()
+                    self.dispositivo0 = 1
+                    self.rotulo = self.rotulo_padrao()
+                else:
+                    irmao.dispositivo0 = 1
+                    irmao.rotulo = irmao.rotulo_padrao()
+                    self.dispositivo0 = 2
+                    self.rotulo = self.rotulo_padrao()
+            irmao.clean()
+            irmao.save()
+
+    def get_proxima_articulacao(self):
+        proxima_articulacao = Dispositivo.objects.filter(
+            ordem__gt=self.ordem,
+            nivel=0,
+            norma_id=self.norma_id)[:1]
+
+        if not proxima_articulacao.exists():
+            return None
+
+        return proxima_articulacao[0]
+
+    def is_relative_auto_insert(self):
+        if self.dispositivo_pai is not None:
+            # pp possiveis_pais
+            pp = self.tipo_dispositivo.possiveis_pais.filter(
+                pai=self.dispositivo_pai.tipo_dispositivo)
+
+            if pp.exists():
+                if pp[0].filho_de_insercao_automatica:
+                    return True
+        return False
+
+    def get_raiz(self):
+        raiz = self.get_parents_asc()
+        if len(raiz) > 0:
+            raiz = raiz[0]
+        else:
+            raiz = self
+        return raiz
 
     @staticmethod
     def init_with_base(dispositivo_base, tipo_base):
@@ -739,9 +919,45 @@ class Dispositivo(BaseModel):
         dp.inicio_vigencia = dispositivo_base.inicio_vigencia
         dp.publicacao = dispositivo_base.publicacao
         dp.timestamp = datetime.now()
+        dp.ordem = dispositivo_base.ordem
 
         return dp
 
+    @staticmethod
+    def set_numero_for_add_in(dispositivo_base, dispositivo, tipo_base):
+
+        if tipo_base.contagem_continua:
+            raiz = dispositivo_base.get_raiz()
+
+            disps = Dispositivo.objects.order_by('-ordem').filter(
+                tipo_dispositivo_id=tipo_base.pk,
+                ordem__lte=dispositivo_base.ordem,
+                ordem__gt=raiz.ordem,
+                norma_id=dispositivo_base.norma_id)[:1]
+
+            if disps.exists():
+                dispositivo.set_numero_completo(
+                    disps[0].get_numero_completo())
+                dispositivo.transform_in_next()
+            else:
+                dispositivo.set_numero_completo([1, 0, 0, 0, 0, 0, ])
+        else:
+            if ';' in tipo_base.rotulo_prefixo_texto:
+
+                if dispositivo != dispositivo_base:
+                    irmaos_mesmo_tipo = Dispositivo.objects.filter(
+                        tipo_dispositivo=tipo_base,
+                        dispositivo_pai=dispositivo_base)
+
+                    dispositivo.set_numero_completo([
+                        1 if irmaos_mesmo_tipo.exists() else 0,
+                        0, 0, 0, 0, 0, ])
+                else:
+                    dispositivo.set_numero_completo([0, 0, 0, 0, 0, 0, ])
+
+            else:
+                dispositivo.set_numero_completo([1, 0, 0, 0, 0, 0, ])
+
 
 class Vide(models.Model):
     data_criacao = models.DateTimeField(verbose_name=_('Data de Criação'))

compilacao/views.py

@@ -2,10 +2,8 @@ from collections import OrderedDict
 from datetime import datetime, timedelta
 from os.path import sys
 
-from django import forms
 from django.core.signing import Signer
 from django.db.models import Q
-from django.db.models.aggregates import Max
 from django.http.response import JsonResponse
 from django.utils.dateparse import parse_date
 from django.utils.translation import ugettext_lazy as _
@@ -313,13 +311,8 @@ class CompilacaoEditView(CompilacaoView):
         return result
 
 
-class DispositivoSimpleEditForm(forms.Form):
-    texto = forms.CharField(required=False, widget=forms.Textarea)
-
-
 class DispositivoEditView(CompilacaoEditView, FormMixin):
     template_name = 'compilacao/edit_bloco.html'
-    form_class = DispositivoSimpleEditForm
 
     def post(self, request, *args, **kwargs):
 
@@ -327,10 +320,37 @@ class DispositivoEditView(CompilacaoEditView, FormMixin):
             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
         d.save()
 
-        return self.get(request, *args, **kwargs)
+        if texto != '':
+            dnext = Dispositivo.objects.filter(
+                norma_id=d.norma_id,
+                ordem__gt=d.ordem,
+                texto='',
+                tipo_dispositivo__dispositivo_de_articulacao=False)[:1]
+
+            if not dnext.exists():
+                return self.get(request, *args, **kwargs)
+
+            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(self):
         self.flag_alteradora = -1
@@ -379,183 +399,159 @@ class DispositivoEditView(CompilacaoEditView, FormMixin):
 
     def select_provaveis_inserts(self):
 
-        # Não salvar d_base
-        if self.pk_add == 0:
-            d_base = Dispositivo.objects.get(pk=self.pk_view)
-        else:
-            d_base = Dispositivo.objects.get(pk=self.pk_add)
-
-        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': []}
-                  ]
-
-        disps = Dispositivo.objects.order_by(
-            '-ordem').filter(
-                ordem__lte=d_base.ordem,
-                norma_id=d_base.norma_id)
-
-        nivel = sys.maxsize
-        for d in disps:
-
-            if d.nivel >= nivel:
-                continue
-
-            if d.tipo_dispositivo.class_css == 'caput':
-                continue
+        try:
+            # Não salvar d_base
+            if self.pk_add == 0:
+                base = Dispositivo.objects.get(pk=self.pk_view)
+            else:
+                base = Dispositivo.objects.get(pk=self.pk_add)
+
+            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
+            dps = base.get_parents()
+            dps.insert(0, base)
+            nivel = sys.maxsize
+            for dp in dps:
 
-            nivel = d.nivel
-
-            r = []
-
-            if d == d_base:
-                result[2]['itens'].append({
-                    'class_css': d.tipo_dispositivo.class_css,
-                    'tipo_pk': d.pk,
-                    'variacao': 0,
-                    'provavel': '%s (%s)' % (
-                        d.rotulo_padrao(True, d, False),
-                        d.tipo_dispositivo.nome,),
-                    'dispositivo_base': d_base.pk})
-
-            flag_direcao = 1
-            flag_variacao = 0
-            while True:
-                # rt resultado da transformacao
-                rt = d.transform_in_next(flag_direcao)
-                if not rt[0]:
-                    break
-                flag_variacao += rt[1]
-                r.append({'class_css': d.tipo_dispositivo.class_css,
-                          'tipo_pk': d.tipo_dispositivo.pk,
-                          'variacao': flag_variacao,
-                          'provavel': '%s (%s)' % (
-                              d.rotulo_padrao(
-                                  True, d_base, True),
-                              d.tipo_dispositivo.nome,),
-                          'dispositivo_base': d_base.pk})
+                if dp.nivel >= nivel:
+                    continue
 
-                flag_direcao = -1
+                if dp.is_relative_auto_insert():
+                    continue
 
-            r.reverse()
+                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(),
+                            dp.tipo_dispositivo.nome,),
+                        'dispositivo_base': base.pk})
+
+                r = []
+                flag_direcao = 1
+                flag_variacao = 0
+                while True:
+                    if dp.dispositivo0 == 0:
+                        local_insert = 1
+                    else:
+                        local_insert = 0
 
-            if len(r) > 0 and d.tipo_dispositivo.class_css == 'articulacao':
-                r = [r[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 len(r) > 0 and dp.tipo_dispositivo.class_css in [
+                        'articulacao', 'ementa']:
+                    r = [r[0], ]
+
+                if dp.tipo_dispositivo == base.tipo_dispositivo:
+                    result[0]['itens'] += r
+                else:
+                    result[0]['itens'] += r
+                    result[2]['itens'] += r
 
-            if d.tipo_dispositivo == d_base.tipo_dispositivo:
-                result[0]['itens'] += r
-            else:
-                result[0]['itens'] += r
-                result[2]['itens'] += r
+                if nivel == 0:
+                    break
 
-            if nivel == 0:
-                break
+            # tipo do dispositivo base
+            tipb = base.tipo_dispositivo
+            raiz = base.get_raiz()
 
-        # tipo do dispositivo base
-        tipb = d_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'])
+                    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, excluir_autos=True):
+                        continue
 
-        for mudarnivel in [1, 0]:
-            if mudarnivel:
-                # Outros Tipos de Dispositivos PARA DENTRO
-                otds = TipoDispositivo.objects.order_by(
-                    '-contagem_continua', 'id').filter(
-                    Q(id__gt=100) & Q(id__gt=d_base.tipo_dispositivo_id))
-            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'])
-                otds = TipoDispositivo.objects.order_by(
-                    '-contagem_continua', 'id').filter(
-                    id__gt=100,
-                    id__lt=d_base.tipo_dispositivo_id).exclude(
-                        class_css__in=classes_ja_inseridas)
-
-            for td in otds:
-
-                if td.class_css == 'caput':
-                    continue
+                    base.tipo_dispositivo = td
 
-                d_base.tipo_dispositivo = td
+                    if not paradentro:
+                        if not td.permitido_inserir_in(
+                                raiz.tipo_dispositivo, excluir_autos=True):
+                            continue
 
-                if td.contagem_continua:
-                    disps = Dispositivo.objects.filter(
-                        tipo_dispositivo_id=td.pk,
-                        ordem__lte=d_base.ordem,
-                        norma_id=d_base.norma_id).aggregate(
-                        Max('dispositivo0'),
-                        Max('dispositivo1'),
-                        Max('dispositivo2'),
-                        Max('dispositivo3'),
-                        Max('dispositivo4'),
-                        Max('dispositivo5'))
+                    Dispositivo.set_numero_for_add_in(base, base, td)
 
-                else:
-                    disps = Dispositivo.objects.filter(
-                        tipo_dispositivo_id=td.pk,
-                        dispositivo_pai_id=d_base.pk).aggregate(
-                        Max('dispositivo0'),
-                        Max('dispositivo1'),
-                        Max('dispositivo2'),
-                        Max('dispositivo3'),
-                        Max('dispositivo4'),
-                        Max('dispositivo5'))
-
-                if disps['dispositivo0__max'] is not None:
-                    d_base.set_numero_completo([
-                        disps['dispositivo0__max'],
-                        disps['dispositivo1__max'],
-                        disps['dispositivo2__max'],
-                        disps['dispositivo3__max'],
-                        disps['dispositivo4__max'],
-                        disps['dispositivo5__max'],
-                    ])
-
-                    d_base.transform_in_next()
-                else:
-                    if ';' in td.rotulo_prefixo_texto:
-                        d_base.set_numero_completo([0, 0, 0, 0, 0, 0, ])
-                    else:
-                        d_base.set_numero_completo([1, 0, 0, 0, 0, 0, ])
-
-                r = [{'class_css': td.class_css,
-                      'tipo_pk': td.pk,
-                      'variacao': 0,
-                      'provavel': '%s (%s)' % (
-                          d_base.rotulo_padrao(True, None, True),
-                          td.nome,),
-                      'dispositivo_base': d_base.pk}]
-
-                if mudarnivel == 1:
-                    if (tipb.class_css == 'caput' and
-                            td.class_css == 'paragrafo'):
-                        result[0]['itens'].insert(0, r[0])
+                    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[1]['itens'] += r
-                else:
-                    if td.pk < tipb.pk:
-                        result[2]['itens'] += r
-                        result[0]['itens'] += r
+                        if td.pk < tipb.pk:
+                            result[2]['itens'] += r
+                            result[0]['itens'] += r
 
-        if tipb.class_css == 'caput':
-            result.pop()
-            # result.remove(result[0])
+            if tipb.class_css == 'caput':
+                result.pop()
 
-        # retira inserir após e inserir antes
-        if tipb.class_css == 'articulacao':
-            r = result[0]
-            result.remove(result[0])
-            result.insert(1, r)
+            # retira inserir após e inserir antes
+            if tipb.class_css == 'articulacao':
+                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
 
@@ -577,13 +573,53 @@ class ActionsEditMixin(object):
         pass
 
     def add_in(self, context):
-        # pai = Dispositivo.objects.get(pk=context['dispositivo_id'])
-        # dp = Dispositivo.objects.get(pk=context['dispositivo_id'])
 
-        # Tipo Filho
-        # tf = TipoDispositivo.objects.get(pk=context['tipo_pk'])
-        print("aqui")
-        return {}
+        try:
+            # Tipo do dispositivo a ser inserido
+            tipo = TipoDispositivo.objects.get(pk=context['tipo_pk'])
+
+            base = Dispositivo.objects.get(pk=context['dispositivo_id'])
+
+            dp = Dispositivo.init_with_base(base, tipo)
+
+            dp.nivel += 1
+            dp.dispositivo_pai = base
+            Dispositivo.set_numero_for_add_in(base, dp, tipo)
+            dp.rotulo = dp.rotulo_padrao()
+
+            if dp.tipo_dispositivo.class_css == 'artigo':
+                ordem = base.criar_espaco(espaco_a_criar=2, local=0)
+            else:
+                ordem = base.criar_espaco(espaco_a_criar=1, local=0)
+
+            dp.ordem = ordem
+
+            dp.incrementar_irmaos(tipo=['add_in'])
+
+            dp.clean()
+            dp.save()
+
+            # Inserção automática do caput para artigos
+            if dp.tipo_dispositivo.class_css == 'artigo':
+                tipocaput = TipoDispositivo.objects.filter(
+                    class_css='caput')
+                dp.dispositivo_pai_id = dp.pk
+                dp.pk = None
+                dp.nivel += 1
+                dp.tipo_dispositivo = tipocaput[0]
+                dp.set_numero_completo([1, 0, 0, 0, 0, 0, ])
+                dp.rotulo = dp.rotulo_padrao()
+                dp.texto = ''
+
+                dp.ordem = ordem + Dispositivo.INTERVALO_ORDEM
+                dp.clean()
+                dp.save()
+                dp = Dispositivo.objects.get(pk=dp.dispositivo_pai_id)
+        except Exception as e:
+            print(e)
+
+        data = self.get_json_for_refresh(dp)
+        return data
 
     def add_next(self, context):
         try:
@@ -608,95 +644,15 @@ class ActionsEditMixin(object):
                 dp.rotulo = dp.rotulo_padrao()
 
                 if dp.tipo_dispositivo.class_css == 'artigo':
-                    ordem = base.criar_espaco_apos(espaco_a_criar=2)
+                    ordem = base.criar_espaco(espaco_a_criar=2, local=1)
                 else:
-                    ordem = base.criar_espaco_apos(espaco_a_criar=1)
+                    ordem = base.criar_espaco(espaco_a_criar=1, local=1)
 
                 dp.ordem = ordem
 
                 # Incrementar irmãos
 
-                if not tipo.contagem_continua:
-                    irmaos = list(Dispositivo.objects.filter(
-                        Q(ordem__gt=dp.ordem) | Q(dispositivo0=0),
-                        dispositivo_pai_id=dp.dispositivo_pai_id,
-                        tipo_dispositivo_id=tipo.pk))
-
-                elif tipo.class_css == 'articulacao':
-                    irmaos = list(Dispositivo.objects.filter(
-                        ordem__gt=dp.ordem,
-                        norma_id=dp.norma_id,
-                        tipo_dispositivo_id=tipo.pk))
-
-                else:  # contagem continua restrita a articulacao
-                    proxima_articulacao = Dispositivo.objects.filter(
-                        ordem__gt=dp.ordem,
-                        nivel=0,
-                        norma_id=dp.norma_id)[:1]
-
-                    if not proxima_articulacao.exists():
-                        irmaos = list(Dispositivo.objects.filter(
-                            ordem__gt=dp.ordem,
-                            norma_id=dp.norma_id,
-                            tipo_dispositivo_id=tipo.pk))
-                    else:
-                        irmaos = list(Dispositivo.objects.filter(
-                            Q(ordem__gt=dp.ordem) &
-                            Q(ordem__lt=proxima_articulacao[0].ordem),
-                            norma_id=dp.norma_id,
-                            tipo_dispositivo_id=tipo.pk))
-
-                dp_profundidade = dp.get_profundidade()
-
-                irmaos_a_salvar = []
-                ultimo_irmao = None
-                for irmao in irmaos:
-
-                    if irmao.ordem <= dp.ordem:
-                        irmaos_a_salvar.append(irmao)
-                        continue
-
-                    irmao_profundidade = irmao.get_profundidade()
-                    if irmao_profundidade < dp_profundidade:
-                        break
-
-                    if irmao.get_numero_completo() < dp.get_numero_completo():
-                        if irmao_profundidade > dp_profundidade:
-                            if ultimo_irmao is None:
-                                irmao.transform_in_next(
-                                    dp_profundidade - irmao_profundidade)
-                                irmao.transform_in_next(
-                                    irmao_profundidade - dp_profundidade)
-                            else:
-                                irmao.set_numero_completo(
-                                    ultimo_irmao.get_numero_completo())
-
-                                irmao.transform_in_next(
-                                    irmao_profundidade -
-                                    ultimo_irmao.get_profundidade())
-
-                            ultimo_irmao = irmao
-                        else:
-                            irmao.transform_in_next()
-                        irmao.rotulo = irmao.rotulo_padrao()
-                        irmaos_a_salvar.append(irmao)
-                    else:
-                        irmao_numero = irmao.get_numero_completo()
-                        irmao_numero[dp_profundidade] += 1
-                        irmao.set_numero_completo(irmao_numero)
-                        irmao.rotulo = irmao.rotulo_padrao()
-                        irmaos_a_salvar.append(irmao)
-
-                irmaos_a_salvar.reverse()
-                for irmao in irmaos_a_salvar:
-                    if irmao.dispositivo0 == 0 and \
-                            irmao.ordem <= dp.ordem and variacao == 0:
-                        irmao.dispositivo0 = 1
-                        irmao.rotulo = irmao.rotulo_padrao()
-                        dp.dispositivo0 = 2
-                        dp.rotulo = dp.rotulo_padrao()
-                    irmao.clean()
-                    irmao.save()
+                dp.incrementar_irmaos(variacao)
 
                 dp.clean()
                 dp.save()
@@ -736,9 +692,9 @@ class ActionsEditMixin(object):
                 if tipo.contagem_continua:
                     ultimo_irmao = Dispositivo.objects.order_by(
                         '-ordem').filter(
-                        ordem__lte=dp.ordem,
+                        ordem__lte=base.ordem,
                         tipo_dispositivo_id=tipo.pk,
-                        norma_id=dp.norma_id)[:1]
+                        norma_id=base.norma_id)[:1]
 
                     if not ultimo_irmao.exists():
                         dp.set_numero_completo([1, 0, 0, 0, 0, 0, ])
@@ -754,7 +710,7 @@ class ActionsEditMixin(object):
                         dp.set_numero_completo([1, 0, 0, 0, 0, 0, ])
                 dp.rotulo = dp.rotulo_padrao()
                 dp.texto = ''
-                dp.ordem = base.criar_espaco_apos(espaco_a_criar=1)
+                dp.ordem = base.criar_espaco(espaco_a_criar=1, local=1)
 
                 # Incrementar irmãos
                 irmaos = Dispositivo.objects.order_by('-ordem').filter(
@@ -900,42 +856,44 @@ class ActionsEditMixin(object):
         except Exception as e:
             print(e)
 
-        # data = serializers.serialize('json',  dp)
-        if tipo.contagem_continua:
-            # pais a atualizar
+        data = self.get_json_for_refresh(dp)
 
-            pais = []
+        return data
 
-            if dp.dispositivo_pai is None:
-                data = {'pk': dp.pk, 'pai': [-1, ]}
+    def get_json_for_refresh(self, dispositivo):
+
+        if dispositivo.tipo_dispositivo.contagem_continua:
+            pais = []
+            if dispositivo.dispositivo_pai is None:
+                data = {'pk': dispositivo.pk, 'pai': [-1, ]}
             else:
-                pkfilho = dp.pk
-                dp = dp.dispositivo_pai
+                pkfilho = dispositivo.pk
+                dispositivo = dispositivo.dispositivo_pai
 
-                if proxima_articulacao is not None and \
-                        proxima_articulacao.exists():
+                proxima_articulacao = dispositivo.get_proxima_articulacao()
+
+                if proxima_articulacao is not None:
                     parents = Dispositivo.objects.filter(
-                        norma_id=dp.norma_id,
-                        ordem__gte=dp.ordem,
-                        ordem__lt=proxima_articulacao[0].ordem,
-                        nivel__lte=dp.nivel)
+                        norma_id=dispositivo.norma_id,
+                        ordem__gte=dispositivo.ordem,
+                        ordem__lt=proxima_articulacao.ordem,
+                        nivel__lte=dispositivo.nivel)
                 else:
                     parents = Dispositivo.objects.filter(
-                        norma_id=dp.norma_id,
-                        ordem__gte=dp.ordem,
-                        nivel__lte=dp.nivel)
+                        norma_id=dispositivo.norma_id,
+                        ordem__gte=dispositivo.ordem,
+                        nivel__lte=dispositivo.nivel)
 
                 nivel = sys.maxsize
                 for p in parents:
-
                     if p.nivel > nivel:
                         continue
-
                     pais.append(p.pk)
                     nivel = p.nivel
                 data = {'pk': pkfilho, 'pai': pais}
         else:
-            data = {'pk': dp.pk, 'pai': [dp.dispositivo_pai.pk, ]}
+            data = {'pk': dispositivo.pk, 'pai': [
+                dispositivo.dispositivo_pai.pk, ]}
 
         return data
 

static/js/compilacao.js

@@ -1,210 +1,261 @@
 
-var flag_add_next = false;
-var flag_add_next_pk = 0;
-var flag_add_next_pai = 0;
-
 var editortype = "textarea";
-
+var gets = 0;
 var onSubmitEditForm = function(event) {
 
-    var texto = '';
-    var editorTiny = tinymce.get('editdi_texto');
-
-    if (editorTiny != null)
-       texto = editorTiny.getContent();
-    else
-       texto = $('#editdi_texto').val();
-
-    var formData = {
-        'csrfmiddlewaretoken' : $('input[name=csrfmiddlewaretoken]').val(),
-        'texto'               : texto
-    };
-
-    var url = $('.csform form').attr( "action_ajax" );
-    $("#message_block").css("display", "block");
-    $.post(url,formData)
-        .done(function(data) {
-            $('.dpt-selected').html(data);
-            clearEditSelected();
-            reloadFunctionClicks();
-        }).always(function() {
-            $("#message_block").css("display", "none");
-        });
-    if (event != null)
-    	event.preventDefault();
+	var texto = '';
+	var editorTiny = tinymce.get('editdi_texto');
+
+	if (editorTiny != null)
+		texto = editorTiny.getContent();
+	else
+		texto = $('#editdi_texto').val();
+
+	var formData = {
+			'csrfmiddlewaretoken' : $('input[name=csrfmiddlewaretoken]').val(),
+			'texto'               : texto
+	};
+
+	var url = $('.csform form').attr( "action_ajax" );
+	$("#message_block").css("display", "block");
+
+	$.post(url, formData)
+	.done(function(data) {
+
+		if (typeof data == "string") {
+			$('.dpt-selected').html(data);
+			clearEditSelected();
+			reloadFunctionClicks();
+			return;
+		}
+
+		clearEditSelected();
+
+		if (data.pk != null)
+			refreshScreenFocusPk(data);
+		else {
+			alert('Erro na inserção!');
+			flag_refresh_all = false;
+		}
+
+	}).always(function() {
+		$("#message_block").css("display", "none");
+	});
+	if (event != null)
+		event.preventDefault();
 }
 
+
 var clickEditDispositivo = function(event) {
-    var _pk = event.currentTarget.getAttribute('pk');
-    if ($('#dpt'+_pk).hasClass("dpt-selected")) {
-        clearEditSelected();
-        return;
-    }
-    clearEditSelected();
-    clickUpdateDispositivo(event);
+	var _pk = event.currentTarget.getAttribute('pk');
+	if ($('#dpt'+_pk).hasClass("dpt-selected")) {
+		clearEditSelected();
+		return;
+	}
+	clearEditSelected();
+	clickUpdateDispositivo(event);
 }
 
-var clickUpdateDispositivo = function(event, __pk, __action, addeditselected) {
-
-    var _pk = __pk;
-    var _action = __action;
-    var _variacao = '';
-    var _tipo_pk = '';
-
-    if (event != null) {
-        _pk = event.currentTarget.getAttribute('pk');
-        _action = $(this).attr('action');
-        _variacao = $(this).attr('variacao');
-        _tipo_pk = $(this).attr('tipo_pk');
-    }
-
-    if (flag_add_next_pk == 0)
-        flag_add_next_pk = _pk
-
-    var url = ''
-    if (_action == '')
-        return
-    else if ( _action == null)
-        url = _pk+'/refresh?pkadd='+flag_add_next_pk;
-    else if (_action.startsWith('refresh')) {
-
-        var str = _action.split(':');
-        if (str.length > 1) {
-            editortype = str[1];
-        }
-
-        url = _pk+'/refresh?pkadd='+flag_add_next_pk+url;
-        }
-    else {
-        url = _pk+'/actions?action='+_action;
-        url += '&tipo_pk='+_tipo_pk;
-        url += '&variacao='+_variacao;
-        if (addeditselected == null || addeditselected) {
-            $("#message_block").css("display", "block");
-        }
-    }
-
-    $.get(url).done(function( data ) {
-
-        if ( _action == null || _action.startsWith('refresh')) {
-
-            if (flag_add_next) {
-
-                if (addeditselected)
+var clickUpdateDispositivo = function(event, __pk_refresh, __pk_edit, __action, flag_actions_vibible, flag_refresh_all) {
+
+	var pk_refresh = __pk_refresh;
+	var pk_edit = __pk_edit;
+	var _action = __action;
+	var _variacao = '';
+	var _tipo_pk = '';
+
+	if (event != null) {
+		pk_refresh = event.currentTarget.getAttribute('pk');
+		_action = $(this).attr('action');
+		_variacao = $(this).attr('variacao');
+		_tipo_pk = $(this).attr('tipo_pk');
+	}
+
+	if (pk_edit == null)
+		pk_edit = pk_refresh;
+
+	var url = '';
+	if (_action == '')
+		return;
+	else if ( _action == null) {
+		url = pk_refresh+'/refresh?pkadd='+pk_edit;
+	}
+	else if (_action.startsWith('refresh')) {
+
+		var str = _action.split(':');
+		if (str.length > 1) {
+			editortype = str[1];
+			SetCookie("editortype", editortype, 30)
+
+		}
+		url = pk_refresh+'/refresh?pkadd='+pk_edit+url;
+	}
+	else {
+
+		url = pk_refresh+'/actions?action='+_action;
+		url += '&tipo_pk='+_tipo_pk;
+		url += '&variacao='+_variacao;
+
+		$("#message_block").css("display", "block");
+
+	}
+
+	$.get(url).done(function( data ) {
+		if ( _action == null || _action.startsWith('refresh')) {
+
+
+			if (flag_refresh_all) {
+                if (flag_actions_vibible)
                     clearEditSelected();
 
-                $( '#dpt' + _pk ).html( data);
-                flag_add_next = false
-            }
-            else {
-                clearEditSelected();
-                $( '#dpt' + _pk ).prepend( data );
-            }
-            reloadFunctionClicks();
- 
-            if ( editortype == 'tinymce' ) {
-                initTinymce();
-            }
-            else if (editortype == 'textarea') {
-            	$('.csform form').submit(onSubmitEditForm);
-            }
-            else if (editortype == 'construct') {
-                $('.csform .btn-salvar').parent().remove();
-                $('.csform .btn-salvar, .csform textarea').remove();
-                $('#dpt'+flag_add_next_pk).css('min-height', $('.actions_right').height()*2);
-                $('.actions_inserts').removeClass('menu_flutuante');
-            }
-            $(".edt-"+editortype).addClass('selected');
-            //$(".container").addClass('class_color_container');
-
-            if (addeditselected == null || addeditselected) {
-                $('html, body').animate({
-                    scrollTop: $('#dpt' + flag_add_next_pk ).offset().top - window.innerHeight / 10
-                    }, 300);
-                $('#dpt'+flag_add_next_pk).addClass('dpt-selected');
-                flag_add_next_pk = 0;
-            }
-        }
-
-        else if (_action == 'add_next') {
-
-            clearEditSelected();
-
-            flag_add_next_pk = data.pk;
-            flag_add_next_pai = data.pai;
-
-            if (flag_add_next_pk != null)
-                for (var pai = 0; pai < flag_add_next_pai.length; pai++)
-                     if (flag_add_next_pai[pai] != -1) {
-                          flag_add_next = true;
-                          flag_add_next_pk = data.pk;
-                          clickUpdateDispositivo(null, flag_add_next_pai[pai], 'refresh', pai == 0);
-                     }
-                     else {
-                         href = location.href.split('#')[0]
-                         location.href = href+'#'+flag_add_next_pk
-                         location.reload(true)
-                     }
-            else {
-                alert('Erro na inserção!');
-                flag_add_next_pk = 0;
-                flag_add_next = false;
-                }
-        }
-        else {
-            clearEditSelected();
-            reloadFunctionClicks();
-            flag_add_next_pk = 0;
-        }
-    }).always(function() {
-        $("#message_block").css("display", "none");
-    });
+				$( '#dpt' + pk_refresh ).html( data);
+			}
+			else {
+				//console.log(pk_refresh + ' - '+pk_edit)
+				if (flag_actions_vibible == null || flag_actions_vibible)
+                	clearEditSelected();
+
+				$( '#dpt' + pk_refresh ).prepend( data );
+			}
+
+			reloadFunctionClicks();
+			
+			var _editortype = editortype;
+			if ( $('.edt-'+_editortype).length == 0) {
+				_editortype = 'construct';
+			}
+
+			if ( _editortype == 'tinymce' ) {
+				initTinymce();
+			}
+			else if (_editortype == 'textarea') {
+				$('.csform form').submit(onSubmitEditForm);
+			}
+			else if (_editortype == 'construct') {
+				$('.csform .btn-salvar').parent().addClass("displaynone");
+				$('.csform .btn-salvar, .csform .fields').addClass("displaynone");
+				$('#dpt'+pk_refresh).css('min-height', $('.actions_right').height()*2);
+				$('.actions_inserts').removeClass('menu_flutuante');
+			}
+			else if (_editortype == 'detail') {
+				$('.csform .btn-salvar').parent().removeClass("displaynone");
+				$('.csform .btn-salvar,  .csform .fields').removeClass("displaynone");
+				$('#dpt'+pk_refresh).css('min-height', $('.actions_right').height()*2);
+				$('.actions_inserts').addClass('menu_flutuante');
+			}
+
+			$(".edt-"+_editortype).addClass('selected');
+			//$(".container").addClass('class_color_container');
+
+			if (flag_actions_vibible == null || flag_actions_vibible) {
+				$('html, body').animate({
+					scrollTop: $('#dpt' + pk_edit ).offset().top - window.innerHeight / 10
+				}, 300);
+				$('#dpt'+pk_edit).addClass('dpt-selected');
+			}
+		}
+
+		else if (_action == 'add_next' || _action == 'add_in') {
+			clearEditSelected();
+			if (data.pk != null) {
+				refreshScreenFocusPk(data);
+			}
+			else {
+				alert('Erro na inserção!');
+			}
+		}
+		else {
+			clearEditSelected();
+			reloadFunctionClicks();
+		}
+	}).always(function() {
+		$("#message_block").css("display", "none");
+	});
 }
 
+function refreshScreenFocusPk(data) {
+
+	for (var pai = 0; pai < data.pai.length; pai++)
+		if (data.pai[pai] != -1) {
+			clickUpdateDispositivo(null, data.pai[pai], data.pk, 'refresh', pai == 0, true);
+		}
+		else {
+			href = location.href.split('#')[0]
+			location.href = href+'#'+data.pk
+			location.reload(true)
+		}
+}
 
 function clearEditSelected() {
-    $(".container").removeClass('class_color_container');
-    tinymce.remove();
-    $('.dpt-selected').removeClass('dpt-selected');
-    $('.dpt').css('min-height', '');
-    $('.csform').remove();
+	$(".container").removeClass('class_color_container');
+	tinymce.remove();
+	$('.dpt-selected').removeClass('dpt-selected');
+	$('.dpt').css('min-height', '');
+	$('.csform').remove();
 }
 
 function reloadFunctionClicks() {
-    $('.dpt .de, .btn-action, .btn-inserts, .btn-edit').off();
-
-    $('.dpt .de, .btn-edit').on('click', clickEditDispositivo);
+	$('.dpt .de, .btn-action, .btn-inserts, .btn-edit').off();
 
-    $('.btn-action, .btn-inserts').on(
-			'click', clickUpdateDispositivo);
+	$('.dpt .de, .btn-edit').on('click', clickEditDispositivo);
 
+	$('.btn-action, .btn-inserts').on('click', clickUpdateDispositivo);
 
-    $('#editdi_texto').focus();
+	$('#editdi_texto').focus();
 }
 
 function initTinymce() {
 
 	tinymce.init({
-        mode : "textareas",
-        force_br_newlines : false,
-        force_p_newlines : false,
-        forced_root_block : '',
-        plugins: ["table save code"],
-        menubar: "edit format table tools",
-        toolbar: "save | undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent",
-        tools: "inserttable",
-        save_onsavecallback: onSubmitEditForm,
-        border_css: "/static/styles/compilacao_tinymce.css",
-        content_css: "/static/styles/compilacao_tinymce.css"
-    });
+		mode : "textareas",
+		force_br_newlines : false,
+		force_p_newlines : false,
+		forced_root_block : '',
+		plugins: ["table save code"],
+		menubar: "edit format table tools",
+		toolbar: "save | undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent",
+		tools: "inserttable",
+		save_onsavecallback: onSubmitEditForm,
+		border_css: "/static/styles/compilacao_tinymce.css",
+		content_css: "/static/styles/compilacao_tinymce.css"
+	});
 }
 
+//cookies
+function SetCookie(cookieName,cookieValue,nDays) {
+	var today = new Date();
+	var expire = new Date();
+	if (nDays==null || nDays==0) nDays=1;
+	expire.setTime(today.getTime() + 3600000*24*nDays);
+	document.cookie = cookieName+"="+escape(cookieValue)
+	+ ";expires="+expire.toGMTString();
+}
+
+function ReadCookie(cookieName) {
+	var theCookie=" "+document.cookie;
+	var ind=theCookie.indexOf(" "+cookieName+"=");
+	if (ind==-1) ind=theCookie.indexOf(";"+cookieName+"=");
+	if (ind==-1 || cookieName=="") return "";
+	var ind1=theCookie.indexOf(";",ind+1);
+	if (ind1==-1) ind1=theCookie.length;
+	return unescape(theCookie.substring(ind+cookieName.length+2,ind1));
+}
 
 $(document).ready(function() {
 
+	editortype = ReadCookie("editortype")
+
+	if (editortype == null || editortype == "") {
+		editortype = "construct"
+		SetCookie("editortype", editortype, 30)
+	}
+
 	reloadFunctionClicks();
 	$("#message_block").css("display", "none");
 
-	 clickUpdateDispositivo(null, 60933, 'refresh', true);
+	href = location.href.split('#')
+	if (href.length == 2) {
+		clickUpdateDispositivo(null, href[1], href[1], 'refresh', true);
+	}
 
 });

static/styles/compilacao.scss

@@ -8,6 +8,7 @@ $color_actions_border: #CCC;
     background-image: -o-linear-gradient(top, $top, $bottom);
     background-image: linear-gradient(to bottom, $top, $bottom);
 }
+
 @mixin border-radius($radius) {
     -webkit-border-radius: $radius;
     -moz-border-radius: $radius;
@@ -16,6 +17,7 @@ $color_actions_border: #CCC;
 }
 
 @mixin li_flutuante() {
+
     & > ul {
         transform: translateY(30px);
         transition: transform 0.1s linear,
@@ -279,14 +281,15 @@ $color_actions_border: #CCC;
         text-decoration: none;
     }
 
-    .semtexto {
-        font-weight: bold;
-        color: #8DA6D8;
-    }
-
     .dpt {
         position: relative;
         display:block;
+
+        .semtexto {
+            font-weight: bold;
+            color: #cedefe;
+        }
+
         .artigo {
             float: none;
         }
@@ -373,6 +376,10 @@ $color_actions_border: #CCC;
             padding: 0;
         }
 
+        .semtexto {
+            color: #fff;
+        }
+        
         .bloco {
             opacity: 0.5;
             &:hover {
@@ -655,6 +662,7 @@ $color_actions_border: #CCC;
                 &::-webkit-input-placeholder {
                     color: #c70808;
                     opacity: 0.6;
+                    font-size: 80%;
                 }
                 &:-moz-placeholder { /* Firefox 18- */
                     color: #c70808;

templates/compilacao/edit_bloco.html

@@ -21,9 +21,9 @@
 		    	{% if not dpt.tipo_dispositivo.dispositivo_de_articulacao %}
 		        	<li class="edt-textarea"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:textarea" title="{% trans 'Edição simples apenas do texto'%}">E</a></li>
 		        	<li class="edt-tinymce"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:tinymce" title="{% trans 'Editar o texto com TinyMCE'%}">E+</a></li>
-		        	<li class="edt-detail"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:detail" title="{% trans 'TODO: Edição detalhada'%}">E*</a></li>
 		        {%endif%}
-		        	<li class="edt-construct"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:construct" title="{% trans 'Construçao da estrutura da Norma'%}">C</a></li>
+	        	<li class="edt-detail"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:detail" title="{% trans 'TODO: Edição detalhada'%}">E*</a></li>
+	        	<li class="edt-construct"><a class="btn-top btn-action" pk="{{dpt.pk}}" action="refresh:construct" title="{% trans 'Construçao da estrutura da Norma'%}">C</a></li>
 			</ul>
 			<ul class="btns-action actions_right">
 				<li><a class="btn-right btn-action" pk="{{dpt.pk}}" action="refresh" title="{% trans 'TODO: Reduzir nível do Dispositivo'%}">&#10092;</a></li>
@@ -34,7 +34,6 @@
 				<li><a class="btn-right btn-action" pk="{{dpt.pk}}" action="refresh" title="{% trans 'TODO: Descer uma posição com todos os subniveis'%}">&#8650;</a></li>
 			</ul>
 
-
 	        <ul class="btns-action actions_left">
 	        	<li><a class="btn-left btn-action" pk="{{dpt.pk}}"  title="Button Left">BL</a></li>
 	        	<li><a class="btn-left btn-action" pk="{{dpt.pk}}"  title="Button Left">BL</a></li>
@@ -59,16 +58,18 @@
 	        	{%endif%}
 
 				<li><a href="#" class="btn-excluir">&nbsp;<span>Excluir</span></a></li>
-	        	{% if not dpt.tipo_dispositivo.dispositivo_de_articulacao %}
 	            	<li><a onclick="onSubmitEditForm()" class="btn-salvar">&nbsp<span>Salvar</span></a></li>
-	        	{%endif%}
 	        </ul>
 
-            {% if not dpt.tipo_dispositivo.dispositivo_de_articulacao %}
-	            {% csrf_token %}
-	            <textarea id="editdi_texto" placeholder="{% trans "Insirir o texto do dispositivo aqui... Use, nos menus das bordas de edição, 'E+' ou 'E*' para outras opções de editores."%}" name="texto" rows="7">{{ dpt.texto|safe }}</textarea>
-	        {%endif%}
+			<div class="fields">
+                {% csrf_token %}
+
+
+				{% if not dpt.tipo_dispositivo.dispositivo_de_articulacao %}
+					<textarea id="editdi_texto" placeholder="{% trans "Insirir o texto do dispositivo aqui... Use, nos menus das bordas de edição, 'E+' ou 'E*' para outras opções de editores."%}" name="texto" rows="7">{{ dpt.texto|safe }}</textarea>
+	        	{%endif%}
 
+	    	</div>
 
 	        <div class="label_status" >
 	        	<div>Ordem: {{dpt.ordem}}, Nivel: {{dpt.nivel}}, Número: {{dpt.get_numero_completo}}</div>