Construction and structural editing norms

compilacao/insert_inicial_TipoDispositivo.sql

@@ -1,27 +1,27 @@
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (1, 'Articulação', 'articulacao', '', '', 0, '.....', '', '', '', '', '', '', True, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (19, 'Artigo', 'artigo', '', 'Art.', 9, '', ' – ', '', '', '', '', true, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (2, 'Ementa', 'ementa', '', '', 0, '.....', '', '', '', '', '', '', False, 'N', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (21, 'Parágrafo', 'paragrafo', '', '§;Parágrafo Único', 9, '', ' – ', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (3, 'Bloco Alteração', 'bloco_alteracao', '', '', 0, '.....', '', '', '', '', '', '', True, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (22, 'Inciso', 'inciso', '', '', 0, '', ' – ', '', '', '', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (4, 'Omissis', 'omissis', '', '', 0, '.....', '', '', '', '', '', '', False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (23, 'Alinea', 'alinea', '', '', 0, '', ' – ', '', '', '', '', false, 'a', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (11, 'Anexo', 'anexo', '', 'Anexo', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (24, 'Item', 'item', '', '', 0, '', '&nbsp;&ndash;&nbsp;', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (12, 'Parte', 'parte', '', 'Parte', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (25, 'Disposições Preliminares', 'disp_preliminares', '', 'Disposições Preliminares', 0, '', '<br>', '', '<br>', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (13, 'Livro', 'livro', '', 'Livro', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (26, 'Disposições Gerais', 'disp_gerais', '', 'Disposições Gerais', 0, '', '<br>', '', '<br>', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (14, 'Título', 'titulo', '', 'Título', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (27, 'Disposições Transitórias', 'disp_transitorias', '', 'Disposições Transitórias', 0, '', '<br>', '', '<br>', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (15, 'Capítulo', 'capitulo', '', 'Capítulo', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (28, 'Disposições Finais', 'disp_finais', '', 'Disposições Finais', 0, '', '<br>', '', '<br>', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (16, 'Seção', 'secao', '', 'Seção', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (1, 'Articulação', 'articulacao', '', '', 0, '', '', '', '', '', '', true, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (17, 'SubSeção', 'subsecao', '', 'SubSeção', 0, '-----', '', '<br>', '', '<br>', '', '', False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (2, 'Ementa', 'ementa', '', '', 0, '', '', '', '', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (18, 'Item de Seção', 'itemsecao', '', 'Item', 0, '-----', '', '<br>', '', '<br>', '', '', False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (20, 'Caput', 'caput', '', '', 0, '', '', '', '', '', '', false, 'N', 'N', 'N', 'N', 'N', 'N', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (19, 'Artigo', 'artigo', '', 'Art.', 9, '-----', '', '&nbsp;&ndash;&nbsp;', '', '', '', '', True, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (29, 'Texto Não Estruturado', 'texto_n_estruturado', '', '', 0, '', '', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (20, 'Caput', 'caput', '', '', 0, '', '', '', '', '', '', '', False, 'N', 'N', 'N', 'N', 'N', 'N');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (3, 'Bloco Alteração', 'bloco_alteracao', '', '', 0, '', '', '', '', '', '', true, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (21, 'Parágrafo', 'paragrafo', '', '§;Parágrafo Único', 9, '-----', '', '&nbsp;&ndash;&nbsp;', '', '', '', '', False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (4, 'Omissis', 'omissis', '', '', 0, '', '', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (22, 'Inciso', 'inciso', '', '', 0, '.....', '', '&nbsp;&ndash;&nbsp;', '', '', '', '', False, 'I', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (14, 'Título', 'titulo', '', 'Título', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (23, 'Alinea', 'alinea', '', '', 0, '.....', '', '&nbsp;&ndash;&nbsp;', '', '', '', '', False, 'a', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (13, 'Livro', 'livro', '', 'Livro', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (24, 'Item', 'item', '', '', 0, '.....', '', '&nbsp;&ndash;&nbsp;', '', '', '', '', False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (12, 'Parte', 'parte', '', 'Parte', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (25, 'Disposições Preliminares', 'disp_preliminares', '', 'Disposições Preliminares', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'N', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (11, 'Anexo', 'anexo', '', 'Anexo', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (26, 'Disposições Gerais', 'disp_gerais', '', 'Disposições Gerais', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'N', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (16, 'Seção', 'secao', '', 'Seção', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (27, 'Disposições Transitórias', 'disp_transitorias', '', 'Disposições Transitórias', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'N', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (17, 'SubSeção', 'subsecao', '', 'SubSeção', 0, '', '<br>', '', '<br>', '<br>', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (28, 'Disposições Finais', 'disp_finais', '', 'Disposições Finais', 0, '-----', '', '<br>', '', '<br>', '', '', False, 'N', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (18, 'Item de Seção', 'itemsecao', '', 'Item', 0, '', '<br>', '', '<br>', '<br>', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
-insert INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_separadores_variacao, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5) VALUES (29, 'Texto Não Estruturado', 'texto_n_estruturado', '', '', 0, '.....', '', '', '', '', '', '',False, '1', '1', '1', '1', '1', '1');
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45) VALUES (15, 'Capítulo', 'capitulo', '', 'Capítulo', -1, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-');
 
 
+SELECT pg_catalog.setval('compilacao_tipodispositivo_id_seq', 28, true);
 
-select setval('compilacao_tipodispositivo_id_seq'::regclass, (select max(id) from compilacao_tipodispositivo));

compilacao/migrations/0005_auto_20150924_1012.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0004_auto_20150914_0842'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='tipodispositivo',
+            options={'verbose_name_plural': 'Tipos de Dispositivo', 'verbose_name': 'Tipo de Dispositivo', 'ordering': ['id']},
+        ),
+        migrations.RemoveField(
+            model_name='tipodispositivo',
+            name='rotulo_separadores_variacao',
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao01',
+            field=models.CharField(max_length=1, default='-', verbose_name='Separadores entre Numeração e Variação 1', blank=True),
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao12',
+            field=models.CharField(max_length=1, default='-', verbose_name='Separadores entre Variação 1 e Variação 2', blank=True),
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao23',
+            field=models.CharField(max_length=1, default='-', verbose_name='Separadores entre Variação 2 e Variação 3', blank=True),
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao34',
+            field=models.CharField(max_length=1, default='-', verbose_name='Separadores entre Variação 3 e Variação 4', blank=True),
+        ),
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao45',
+            field=models.CharField(max_length=1, default='-', verbose_name='Separadores entre Variação 4 e Variação 5', blank=True),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao0',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Numeração'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao1',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Variação 1'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao2',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Variação 2'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao3',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Variação 3'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao4',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Variação 4'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='formato_variacao5',
+            field=models.CharField(max_length=1, default='1', choices=[('1', '1-Numérico'), ('I', 'I-Romano Maiúsculo'), ('i', 'i-Romano Minúsculo'), ('A', 'A-Alfabético Maiúsculo'), ('a', 'a-Alfabético Minúsculo'), ('*', 'Tópico - Sem contagem'), ('N', 'Sem renderização')], verbose_name='Formato da Variação 5'),
+        ),
+    ]

compilacao/migrations/0006_auto_20150924_1121.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0005_auto_20150924_1012'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_ordinal',
+            field=models.IntegerField(choices=[(-1, 'Numeração Cardinal.'), (0, 'Numeração Ordinal.'), (9, 'Numeração Ordinal até o item nove.')], verbose_name='Tipo de número do rótulo'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_prefixo_texto',
+            field=models.CharField(blank=True, max_length=30, verbose_name='Prefixo de Edição do rótulo'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao01',
+            field=models.CharField(blank=True, default='-', max_length=1, verbose_name='Separador entre Numeração e Variação 1'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao12',
+            field=models.CharField(blank=True, default='-', max_length=1, verbose_name='Separador entre Variação 1 e Variação 2'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao23',
+            field=models.CharField(blank=True, default='-', max_length=1, verbose_name='Separador entre Variação 2 e Variação 3'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao34',
+            field=models.CharField(blank=True, default='-', max_length=1, verbose_name='Separador entre Variação 3 e Variação 4'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao45',
+            field=models.CharField(blank=True, default='-', max_length=1, verbose_name='Separador entre Variação 4 e Variação 5'),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_sufixo_texto',
+            field=models.CharField(blank=True, max_length=30, verbose_name='Sufixo de Edição do rótulo'),
+        ),
+    ]

compilacao/migrations/0007_auto_20150924_1131.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0006_auto_20150924_1121'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='class_css',
+            field=models.CharField(max_length=20, blank=True, verbose_name='Classe CSS'),
+        ),
+    ]

compilacao/migrations/0008_auto_20151005_1023.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0007_auto_20150924_1131'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tipodispositivo',
+            name='dispositivo_de_articulacao',
+            field=models.BooleanField(verbose_name='Dispositivo de Articulação (Sem Texto)', default=False, choices=[
+                                      (True, 'Sim'), (False, 'Não')]),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao01',
+            field=models.CharField(
+                verbose_name='Separador entre Numeração e Variação 1', default='-', max_length=1),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao12',
+            field=models.CharField(
+                verbose_name='Separador entre Variação 1 e Variação 2', default='-', max_length=1),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao23',
+            field=models.CharField(
+                verbose_name='Separador entre Variação 2 e Variação 3', default='-', max_length=1),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao34',
+            field=models.CharField(
+                verbose_name='Separador entre Variação 3 e Variação 4', default='-', max_length=1),
+        ),
+        migrations.AlterField(
+            model_name='tipodispositivo',
+            name='rotulo_separador_variacao45',
+            field=models.CharField(
+                verbose_name='Separador entre Variação 4 e Variação 5', default='-', max_length=1),
+        ),
+    ]

compilacao/models.py

@@ -1,11 +1,50 @@
 from django.contrib.auth.models import User
 from django.db import models
+from django.db.models import F
+from django.db.models.aggregates import Max
 from django.utils.translation import ugettext_lazy as _
 
 from norma.models import NormaJuridica
+from sapl import utils
 from sapl.utils import YES_NO_CHOICES
 
 
+class BaseModel(models.Model):
+
+    class Meta:
+        abstract = True
+
+    def clean(self):
+        """
+        Check for instances with null values in unique_together fields.
+        """
+        from django.core.exceptions import ValidationError
+
+        super(BaseModel, self).clean()
+
+        for field_tuple in self._meta.unique_together[:]:
+            unique_filter = {}
+            unique_fields = []
+            null_found = False
+            for field_name in field_tuple:
+                field_value = getattr(self, field_name)
+                if getattr(self, field_name) is None:
+                    unique_filter['%s__isnull' % field_name] = True
+                    null_found = True
+                else:
+                    unique_filter['%s' % field_name] = field_value
+                    unique_fields.append(field_name)
+            if null_found:
+                unique_queryset = self.__class__.objects.filter(
+                    **unique_filter)
+                if self.pk:
+                    unique_queryset = unique_queryset.exclude(pk=self.pk)
+                if unique_queryset.exists():
+                    msg = self.unique_error_message(
+                        self.__class__, tuple(unique_fields))
+                    raise ValidationError(msg)
+
+
 class TipoNota(models.Model):
     sigla = models.CharField(
         max_length=10, unique=True, verbose_name=_('Sigla'))
@@ -35,6 +74,34 @@ class TipoVide(models.Model):
 
 
 class TipoDispositivo(models.Model):
+    """
+    - ids fazem parte da lógica do desenvolvimento quanto a
+      simulação de hierarquia
+    - ids de 1 a 100 são reservados.
+    - São registros inseridos e usados no desenvolvimento
+
+
+    - para class_css articulacao, omissis, ementa,
+                     bloco_alteracao, artigo, caput e paragrafo
+      são palavras chaves usadas no código e de existência obrigatória.
+
+    - apenas articulacao recebe nivel zero
+
+    - no attributo rotulo_prefixo_texto, caso haja um ';' (ponto e vírgula), e
+      só pode haver 1 ';', o método [def rotulo_padrao] considerará que o
+      rótulo do dispositivo deverá ser escrito com o contéudo após o ';'
+      caso para o pai do dispositivo em processamento exista apenas
+      o próprio como filho
+
+    - ao o usuário trocar manualmente o rotulo para a opção após o ';'
+      necessáriamente o numeração do dispositivo deve ser redusida a 0,
+      podendo manter as variações
+
+    -tipo de dispositivos com contagem continua são continua porém encapsuladas
+      em articulação... mudando articulação, reinicia-se a contagem
+
+    - revogação de dispositivo_de_articulacao revogam todo o conteúdo
+    """
     FNC1 = '1'
     FNCI = 'I'
     FNCi = 'i'
@@ -43,18 +110,32 @@ class TipoDispositivo(models.Model):
     FNC8 = '*'
     FNCN = 'N'
     FORMATO_NUMERACAO_CHOICES = (
-        (FNC1, _('(1) Numérico')),
+        (FNC1, _('1-Numérico')),
-        (FNCI, _('(I) Romano Maiúsculo')),
+        (FNCI, _('I-Romano Maiúsculo')),
-        (FNCi, _('(i) Romano Minúsculo')),
+        (FNCi, _('i-Romano Minúsculo')),
-        (FNCA, _('(A) Alfabético Maiúsculo')),
+        (FNCA, _('A-Alfabético Maiúsculo')),
-        (FNCa, _('(a) Alfabético Minúsculo')),
+        (FNCa, _('a-Alfabético Minúsculo')),
         (FNC8, _('Tópico - Sem contagem')),
         (FNCN, _('Sem renderização')),
     )
 
+    # Choice básico. Porém pode ser melhorado dando a opção de digitar outro
+    # valor maior que zero e diferente de nove. A App de edição de rótulo,
+    # entenderá que deverá colocar ordinal até o valor armazenado ou em tudo
+    # se for igual -1.
+    TNRT = -1
+    TNRN = 0
+    TNR9 = 9
+    TIPO_NUMERO_ROTULO = (
+        (TNRN, _('Numeração Cardinal.')),
+        (TNRT, _('Numeração Ordinal.')),
+        (TNR9, _('Numeração Ordinal até o item nove.')),
+    )
+
     nome = models.CharField(
         max_length=50, unique=True, verbose_name=_('Nome'))
     class_css = models.CharField(
+        blank=True,
         max_length=20,
         verbose_name=_('Classe CSS'))
     rotulo_prefixo_html = models.CharField(
@@ -64,17 +145,39 @@ class TipoDispositivo(models.Model):
     rotulo_prefixo_texto = models.CharField(
         blank=True,
         max_length=30,
-        verbose_name=_('Prefixo de construção do rótulo'))
+        verbose_name=_('Prefixo de Edição do rótulo'))
     rotulo_ordinal = models.IntegerField(
+        choices=TIPO_NUMERO_ROTULO,
         verbose_name=_('Tipo de número do rótulo'))
-    rotulo_separadores_variacao = models.CharField(
+    rotulo_separador_variacao01 = models.CharField(
-        blank=True,
+        blank=False,
-        max_length=5,
+        max_length=1,
-        verbose_name=_('Separadores das Variações'))
+        default="-",
+        verbose_name=_('Separador entre Numeração e Variação 1'))
+    rotulo_separador_variacao12 = models.CharField(
+        blank=False,
+        max_length=1,
+        default="-",
+        verbose_name=_('Separador entre Variação 1 e Variação 2'))
+    rotulo_separador_variacao23 = models.CharField(
+        blank=False,
+        max_length=1,
+        default="-",
+        verbose_name=_('Separador entre Variação 2 e Variação 3'))
+    rotulo_separador_variacao34 = models.CharField(
+        blank=False,
+        max_length=1,
+        default="-",
+        verbose_name=_('Separador entre Variação 3 e Variação 4'))
+    rotulo_separador_variacao45 = models.CharField(
+        blank=False,
+        max_length=1,
+        default="-",
+        verbose_name=_('Separador entre Variação 4 e Variação 5'))
     rotulo_sufixo_texto = models.CharField(
         blank=True,
         max_length=30,
-        verbose_name=_('Sufixo de construção do rótulo'))
+        verbose_name=_('Sufixo de Edição do rótulo'))
     rotulo_sufixo_html = models.CharField(
         blank=True,
         max_length=100,
@@ -97,6 +200,10 @@ class TipoDispositivo(models.Model):
         verbose_name=_('Sufixo html da nota automática'))
     contagem_continua = models.BooleanField(
         choices=YES_NO_CHOICES, verbose_name=_('Contagem contínua'))
+    dispositivo_de_articulacao = models.BooleanField(
+        choices=YES_NO_CHOICES,
+        default=False,
+        verbose_name=_('Dispositivo de Articulação (Sem Texto)'))
     formato_variacao0 = models.CharField(
         max_length=1,
         choices=FORMATO_NUMERACAO_CHOICES,
@@ -131,6 +238,7 @@ class TipoDispositivo(models.Model):
     class Meta:
         verbose_name = _('Tipo de Dispositivo')
         verbose_name_plural = _('Tipos de Dispositivo')
+        ordering = ['id']
 
     def __str__(self):
         return self.nome
@@ -184,14 +292,17 @@ class Publicacao(models.Model):
         return '%s: %s' % (self.veiculo_publicacao, self.publicacao)
 
 
-class Dispositivo(models.Model):
+class Dispositivo(BaseModel):
     TEXTO_PADRAO_DISPOSITIVO_REVOGADO = _('(Revogado)')
+    INTERVALO_ORDEM = 1000
     ordem = models.PositiveIntegerField(
         default=0,
         verbose_name=_('Ordem de Renderização'))
     ordem_bloco_atualizador = models.PositiveIntegerField(
         default=0,
         verbose_name=_('Ordem de Renderização no Bloco Atualizador'))
+
+    # apenas articulacao recebe nivel zero
     nivel = models.PositiveIntegerField(
         default=0,
         blank=True,
@@ -323,6 +434,7 @@ class Dispositivo(models.Model):
              'dispositivo5',
              'tipo_dispositivo',
              'dispositivo_pai',
+             'norma_publicada',
              'publicacao',),
         )
 
@@ -331,6 +443,277 @@ class Dispositivo(models.Model):
             '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):
+        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:
+
+                count_irmaos_mesmo_tipo = Dispositivo.objects.filter(
+                    tipo_dispositivo=self.tipo_dispositivo,
+                    dispositivo_pai=self).count()
+            else:
+                count_irmaos_mesmo_tipo = Dispositivo.objects.filter(
+                    tipo_dispositivo=self.tipo_dispositivo,
+                    dispositivo_pai=self.dispositivo_pai).count()
+
+            if count_irmaos_mesmo_tipo > 1 and self.dispositivo0 != 0:
+                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 '',)
+                else:
+                    if numero[0] != 0:
+                        self.transform_in_next()
+                        r += 'Transformar %s em %s 1%s e criar %s%s' % (
+                            prefixo[1].strip(),
+                            prefixo[0],
+                            'º' if
+                            self.tipo_dispositivo.rotulo_ordinal >= 0 else '',
+                            prefixo[0],
+                            self.get_nomenclatura_completa())
+                    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()
+        else:
+            r += prefixo[0]
+            r += self.get_nomenclatura_completa()
+
+        r += t.rotulo_sufixo_texto
+
+        return r
+
+    def get_profundidade(self):
+        numero = self.get_numero_completo()
+        for i in range(len(numero)):
+            if numero[i] != 0 or i == 0:
+                continue
+            return i - 1
+        return i
+
+    def transform_in_next(self, direcao_variacao=0):
+        """
+        direcao_variacao é lida da seguinte forma:
+            -1 = reduza 1 variacao e incremente 1
+            1  = aumente 1 variacao e incremente 1
+            -2 = reduza 2 variacoes e incremente 1
+            2 = aumente 2 variacoes e incremente 1
+
+        """
+        numero = self.get_numero_completo()
+
+        flag_variacao = 0
+        flag_direcao = False
+
+        if direcao_variacao <= 0:
+            numero.reverse()
+            for i in range(len(numero)):
+                if not flag_direcao and numero[i] == 0 and i < len(numero) - 1:
+                    continue
+
+                if direcao_variacao < 0:
+                    numero[i] = 0
+                    direcao_variacao += 1
+                    flag_variacao -= 1
+
+                    if i == len(numero) - 1:
+                        flag_direcao = False
+                    else:
+                        flag_direcao = True
+                    continue
+                break
+            numero[i] += 1
+            numero.reverse()
+
+        elif direcao_variacao > 0:
+            for i in range(len(numero)):
+                if numero[i] != 0 or i == 0:
+                    continue
+
+                if direcao_variacao > 0:
+                    numero[i] = 1
+                    direcao_variacao -= 1
+                    flag_variacao += 1
+
+                    flag_direcao = True
+                    if direcao_variacao == 0:
+                        break
+                    continue
+            if not flag_direcao:
+                flag_direcao = True
+                numero[i] += 1
+
+        self.set_numero_completo(numero)
+
+        return (flag_direcao, flag_variacao)
+
+    def set_numero_completo(self, *numero):
+        numero = numero[0]
+        self.dispositivo0 = numero[0]
+        self.dispositivo1 = numero[1]
+        self.dispositivo2 = numero[2]
+        self.dispositivo3 = numero[3]
+        self.dispositivo4 = numero[4]
+        self.dispositivo5 = numero[5]
+
+    def get_numero_completo(self):
+        return [
+            self.dispositivo0,
+            self.dispositivo1,
+            self.dispositivo2,
+            self.dispositivo3,
+            self.dispositivo4,
+            self.dispositivo5]
+
+    def get_nomenclatura_completa(self):
+
+        numero = self.get_numero_completo()
+
+        formato = [
+            self.tipo_dispositivo.formato_variacao0,
+            self.tipo_dispositivo.formato_variacao1,
+            self.tipo_dispositivo.formato_variacao2,
+            self.tipo_dispositivo.formato_variacao3,
+            self.tipo_dispositivo.formato_variacao4,
+            self.tipo_dispositivo.formato_variacao5]
+
+        separadores = [
+            '',
+            self.tipo_dispositivo.rotulo_separador_variacao01,
+            self.tipo_dispositivo.rotulo_separador_variacao12,
+            self.tipo_dispositivo.rotulo_separador_variacao23,
+            self.tipo_dispositivo.rotulo_separador_variacao34,
+            self.tipo_dispositivo.rotulo_separador_variacao45]
+
+        numero.reverse()
+        formato.reverse()
+        separadores.reverse()
+
+        result = ''
+
+        flag_obrigatorio = False
+        for i in range(len(numero)):
+            if not flag_obrigatorio and numero[i] == 0:
+                continue
+            flag_obrigatorio = True
+
+            if i + 1 == len(numero) and numero[i] == 0:
+                continue
+
+            if i + 1 == len(numero) and \
+                (self.tipo_dispositivo.rotulo_ordinal == -1 or
+                 0 < numero[i] <= self.tipo_dispositivo.rotulo_ordinal):
+                result = 'º' + result
+
+            if formato[i] == TipoDispositivo.FNC1:
+                result = separadores[i] + str(numero[i]) + result
+            elif formato[i] == TipoDispositivo.FNCI:
+                result = separadores[i] + \
+                    utils.int_to_roman(numero[i]) + result
+            elif formato[i] == TipoDispositivo.FNCi:
+                result = separadores[i] + \
+                    utils.int_to_roman(numero[i]).lower() + result
+            elif formato[i] == TipoDispositivo.FNCA:
+                result = separadores[i] + \
+                    utils.int_to_letter(numero[i]) + result
+            elif formato[i] == TipoDispositivo.FNCa:
+                result = separadores[i] + \
+                    utils.int_to_letter(numero[i]).lower() + result
+            elif formato[i] == TipoDispositivo.FNC8:
+                result = separadores[i] + '*' + result
+            elif formato[i] == TipoDispositivo.FNCN:
+                result = separadores[i] + result
+
+        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]
+
+        if proximo_bloco.count() != 0:
+            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') + (
+                    Dispositivo.INTERVALO_ORDEM * espaco_a_criar - 1))
+        else:
+            # inserção no fim da norma
+            ordem_max = Dispositivo.objects.order_by(
+                'ordem').filter(norma_id=self.norma_id).aggregate(
+                Max('ordem'))
+            if ordem_max['ordem__max'] is None:
+                raise Exception(
+                    'Não existem registros base nesta Norma')
+            ordem = ordem_max['ordem__max'] + Dispositivo.INTERVALO_ORDEM
+        return ordem
+
+    def organizar_niveis(self):
+        if self.dispositivo_pai is None:
+            self.nivel = 0
+        else:
+            self.nivel = self.dispositivo_pai.nivel + 1
+
+        filhos = Dispositivo.objects.filter(
+            dispositivo_pai_id=self.pk)
+
+        for filho in filhos:
+            filho.nivel = self.nivel + 1
+            filho.save()
+            filho.organizar_niveis()
+
+    def get_parents(self):
+        dp = self
+        p = []
+        while dp.dispositivo_pai is not None:
+            dp = dp.dispositivo_pai
+            p.append(dp)
+
+        return p
+
+    def recalcular_ordem(self):
+        try:
+            dispositivos = Dispositivo.objects.order_by('-ordem').filter(
+                norma_id=self.norma_id)
+        except Exception as e:
+            a = 1
+            a += 1
+        ordem = dispositivos.count() * 1000
+        for d in dispositivos:
+            d.ordem = ordem
+            d.save()
+            ordem -= 1000
+
 
 class Vide(models.Model):
     data_criacao = models.DateTimeField(verbose_name=_('Data de Criação'))

compilacao/templatetags/compilacao_filters.py

@@ -2,21 +2,28 @@ from django import template
 from django.core.signing import Signer
 from django.db.models import Q
 
-from compilacao.models import Dispositivo
+from compilacao.models import Dispositivo, TipoDispositivo
 
 register = template.Library()
 
 
 @register.filter
-def get_bloco(pk_atualizador):
+def get_bloco_atualizador(pk_atualizador):
     return Dispositivo.objects.order_by('ordem_bloco_atualizador').filter(
         Q(dispositivo_pai_id=pk_atualizador) |
         Q(dispositivo_atualizador_id=pk_atualizador)).select_related()
 
 
 @register.filter
-def get_field(value, key):
+def get_tipos_dispositivo(pk_atual):
-    return value[key]
+
+    return TipoDispositivo.objects.filter(
+        id__gte=pk_atual)
+
+
+@register.filter
+def get_field(value_dict, key):
+    return value_dict[key]
 
 
 @register.simple_tag
@@ -52,8 +59,8 @@ def set_nivel_old(view, value):
 
 
 @register.simple_tag
-def close_div(value_max, value_min):
+def close_div(value_max, value_min, varr):
-    return '</div>' * (int(value_max) - int(value_min) + 1)
+    return '</div>' * (int(value_max) - int(value_min) + 1 + varr)
 
 
 @register.filter
@@ -61,3 +68,47 @@ def get_sign_vigencia(value):
     string = "%s,%s" % (value.inicio_vigencia, value.fim_vigencia)
     signer = Signer()
     return signer.sign(str(string))
+
+
+@register.filter
+def isinst(value, class_str):
+    classe = value.__class__.__name__
+    return classe == class_str
+
+
+@register.filter
+def render_actions_head(view, d_atual):
+
+    if view.__class__.__name__ != 'DispositivoEditView':
+        return False
+
+    # Apenas Menu actions head
+    if view.pk_add == 0 and d_atual.pk == view.pk_view:
+        return True
+
+    # Menu e conteudo
+    if view.pk_view == view.pk_add and d_atual.pk == view.pk_view:
+        return True
+
+    # conteudo e menu no filho
+    if view.pk_view != view.pk_add and d_atual.pk == view.pk_add:
+        return True
+
+    return False
+
+
+@register.simple_tag
+def nomenclatura_heranca(d):
+    result = ''
+    while d is not None:
+        if d.rotulo != '':
+            if d.tipo_dispositivo.rotulo_prefixo_texto != '':
+                result = d.rotulo + ' ' + result
+            else:
+                result = '(' + d.tipo_dispositivo.nome + ' ' + \
+                    d.rotulo + ')' + ' ' + result
+        else:
+            result = '(' + d.tipo_dispositivo.nome + \
+                d.rotulo_padrao() + ')' + ' ' + result
+        d = d.dispositivo_pai
+    return result

compilacao/urls.py

@@ -1,16 +1,42 @@
-from django.conf.urls import url
+from django.conf.urls import url, include
+from django.contrib.auth.decorators import permission_required
 
 from compilacao import views
+from compilacao.views import (tipo_nota_crud, tipo_vide_crud,
+                              tipo_publicacao_crud, veiculo_publicacao_crud,
+                              tipo_dispositivo_crud)
 
-urlpatterns = [
+
-    url(r'^norma/(?P<norma_id>[0-9]+)/compilacao/$',
+urlpatterns_compilacao = [
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/$',
         views.CompilacaoView.as_view(), name='compilacao'),
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/(?P<dispositivo_id>[0-9]+)/$',
+        views.DispositivoView.as_view(), name='dispositivo'),
 
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/vigencia/(?P<sign>.+)/$',
+        views.CompilacaoView.as_view(), name='vigencia'),
 
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/edit',
+        views.CompilacaoEditView.as_view(), name='comp_edit'),
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/(?P<dispositivo_id>[0-9]+)/refresh',
+        views.DispositivoEditView.as_view(), name='dispositivo_edit'),
 
-    url(r'^norma/(?P<norma_id>[0-9]+)/compilacao/vigencia/(?P<sign>.+)/$',
+    url(r'^(?P<norma_id>[0-9]+)/compilacao/(?P<dispositivo_id>[0-9]+)/actions',
-        views.CompilacaoView.as_view(), name='vigencia'),
+        views.ActionsEditView.as_view(), name='dispositivo_actions'),
 
-    url(r'^norma/(?P<norma_id>[0-9]+)/compilacao/(?P<dispositivo_id>[0-9]+)/$',
+]
-        views.DispositivoView.as_view(), name='dispositivo'),
+
+urlpatterns = [
+    url(r'^norma/', include(urlpatterns_compilacao)),
+
+    url(r'^sistema/compilacao/tipo-nota/',
+        include(tipo_nota_crud.urls)),
+    url(r'^sistema/compilacao/tipo-vide/',
+        include(tipo_vide_crud.urls)),
+    url(r'^sistema/compilacao/tipo-publicacao/',
+        include(tipo_publicacao_crud.urls)),
+    url(r'^sistema/compilacao/tipo-dispositivo/',
+        include(tipo_dispositivo_crud.urls)),
+    url(r'^sistema/compilacao/veiculo-publicacao/',
+        include(veiculo_publicacao_crud.urls)),
 ]

compilacao/views.py

@@ -1,12 +1,21 @@
 from collections import OrderedDict
 from datetime import timedelta
+from os.path import sys
 
 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 _
+from django.views.generic.base import TemplateView
 from django.views.generic.list import ListView
 
-from compilacao.models import Dispositivo
+from compilacao.models import Dispositivo, TipoNota, TipoVide, TipoPublicacao,\
+    VeiculoPublicacao, TipoDispositivo
 from norma.models import NormaJuridica
+from sapl.crud import build_crud
+
 
 DISPOSITIVO_SELECT_RELATED = (
     'tipo_dispositivo',
@@ -16,7 +25,83 @@ DISPOSITIVO_SELECT_RELATED = (
     'dispositivo_atualizador__dispositivo_pai',
     'dispositivo_atualizador__dispositivo_pai__norma',
     'dispositivo_atualizador__dispositivo_pai__norma__tipo',
-    'dispositivo_pai')
+    'dispositivo_pai',
+    'dispositivo_pai__tipo_dispositivo')
+
+tipo_nota_crud = build_crud(
+    TipoNota, 'tipo_nota', [
+
+        [_('Tipo da Nota'),
+         [('sigla', 2), ('nome', 10)],
+         [('modelo', 12)]],
+    ])
+
+tipo_vide_crud = build_crud(
+    TipoVide, 'tipo_vide', [
+
+        [_('Tipo de Vide'),
+         [('sigla', 2), ('nome', 10)]],
+    ])
+
+tipo_publicacao_crud = build_crud(
+    TipoPublicacao, 'tipo_publicacao', [
+
+        [_('Tipo de Publicação'),
+         [('sigla', 2), ('nome', 10)]],
+    ])
+
+
+veiculo_publicacao_crud = build_crud(
+    VeiculoPublicacao, 'veiculo_publicacao', [
+
+        [_('Veículo de Publicação'),
+         [('sigla', 2), ('nome', 10)]],
+    ])
+
+tipo_dispositivo_crud = build_crud(
+    TipoDispositivo, 'tipo_dispositivo', [
+
+        [_('Dados Básicos'),
+         [('nome', 8), ('class_css', 4)]],
+
+        [_('Configurações para Edição do Rótulo'),
+         [('rotulo_prefixo_texto', 3),
+          ('rotulo_sufixo_texto', 3),
+          ('rotulo_ordinal', 3),
+          ('contagem_continua', 3)],
+
+         ],
+
+        [_('Configurações para Renderização de Rótulo e Texto'),
+
+
+
+         [('rotulo_prefixo_html', 6),
+          ('rotulo_sufixo_html', 6), ],
+
+         [('texto_prefixo_html', 4),
+          ('dispositivo_de_articulacao', 4),
+          ('texto_sufixo_html', 4)],
+         ],
+
+        [_('Configurações para Nota Automática'),
+         [('nota_automatica_prefixo_html', 6),
+          ('nota_automatica_sufixo_html', 6),
+          ],
+         ],
+
+        [_('Configurações para Variações Numéricas'),
+
+         [('formato_variacao0', 12)],
+         [('rotulo_separador_variacao01', 5), ('formato_variacao1', 7), ],
+         [('rotulo_separador_variacao12', 5), ('formato_variacao2', 7), ],
+         [('rotulo_separador_variacao23', 5), ('formato_variacao3', 7), ],
+         [('rotulo_separador_variacao34', 5), ('formato_variacao4', 7), ],
+         [('rotulo_separador_variacao45', 5), ('formato_variacao5', 7), ],
+
+         ],
+
+    ])
 
 
 class CompilacaoView(ListView):
@@ -127,7 +212,7 @@ class CompilacaoView(ListView):
 
 class DispositivoView(CompilacaoView):
     # template_name = 'compilacao/index.html'
-    template_name = 'compilacao/template_render_bloco.html'
+    template_name = 'compilacao/index_bloco.html'
 
     def get_queryset(self):
         self.flag_alteradora = -1
@@ -145,20 +230,616 @@ class DispositivoView(CompilacaoView):
         proximo_bloco = Dispositivo.objects.filter(
             ordem__gt=bloco.ordem,
             nivel__lte=bloco.nivel,
-            norma_publicada=None,
             norma_id=self.kwargs['norma_id'])[:1]
 
         if proximo_bloco.count() == 0:
             itens = Dispositivo.objects.filter(
                 ordem__gte=bloco.ordem,
-                norma_publicada=None,
                 norma_id=self.kwargs['norma_id']
             ).select_related(*DISPOSITIVO_SELECT_RELATED)
         else:
             itens = Dispositivo.objects.filter(
                 ordem__gte=bloco.ordem,
                 ordem__lt=proximo_bloco[0].ordem,
-                norma_publicada=None,
                 norma_id=self.kwargs['norma_id']
             ).select_related(*DISPOSITIVO_SELECT_RELATED)
         return itens
+
+
+class CompilacaoEditView(CompilacaoView):
+    template_name = 'compilacao/edit.html'
+
+    flag_alteradora = -1
+
+    flag_nivel_ini = 0
+    flag_nivel_old = -1
+
+    pk_add = 0
+    pk_view = 0
+
+    def get_queryset(self):
+        self.pk_add = 0
+        self.pk_view = 0
+
+        self.flag_alteradora = -1
+        self.flag_nivel_ini = 0
+        self.flag_nivel_old = -1
+
+        return Dispositivo.objects.filter(
+            ordem__gt=0,
+            norma_id=self.kwargs['norma_id']
+        ).select_related(*DISPOSITIVO_SELECT_RELATED)
+
+
+class DispositivoEditView(DispositivoView):
+    template_name = 'compilacao/edit_bloco.html'
+
+    def get_queryset(self):
+        self.flag_alteradora = -1
+        self.flag_nivel_ini = 0
+        self.flag_nivel_old = -1
+
+        try:
+            self.pk_add = int(self.request.GET['pkadd'])
+        except:
+            self.pk_add = 0
+        self.pk_view = int(self.kwargs['dispositivo_id'])
+
+        try:
+            if self.pk_add == 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_add == self.pk_view:
+            return [bloco, ]
+
+        proximo_bloco = Dispositivo.objects.filter(
+            ordem__gt=bloco.ordem,
+            nivel__lte=bloco.nivel,
+            norma_id=self.kwargs['norma_id'])[:1]
+
+        if proximo_bloco.count() == 0:
+            itens = Dispositivo.objects.filter(
+                ordem__gte=bloco.ordem,
+                norma_id=self.kwargs['norma_id']
+            ).select_related(*DISPOSITIVO_SELECT_RELATED)
+        else:
+            itens = Dispositivo.objects.filter(
+                ordem__gte=bloco.ordem,
+                ordem__lt=proximo_bloco[0].ordem,
+                norma_id=self.kwargs['norma_id']
+            ).select_related(*DISPOSITIVO_SELECT_RELATED)
+        return itens
+
+    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',
+                   'action': 'add_next',
+                   'itens': []},
+                  {'tipo_insert': 'TODO: Inserir Dentro',
+                   'action': 'add_in',
+                   'itens': []},
+                  {'tipo_insert': 'TODO: Inserir Antes',
+                   '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
+
+            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})
+
+                flag_direcao = -1
+
+            r.reverse()
+
+            if len(r) > 0 and d.tipo_dispositivo.class_css == 'articulacao':
+                r = [r[0], ]
+
+            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
+
+        # tipo do dispositivo base
+        tipb = d_base.tipo_dispositivo
+
+        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 (tipb.class_css == 'caput' and
+                        td.class_css == 'paragrafo'):
+                    continue
+
+                d_base.tipo_dispositivo = td
+
+                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:
+                    result[1]['itens'] += r
+                else:
+                    if td.pk < tipb.pk and td.class_css != 'caput':
+                        result[2]['itens'] += r
+                        result[0]['itens'] += r
+
+        # retira inserir após e inserir antes
+        if tipb.class_css == 'caput':
+            result.pop()
+            result.remove(result[0])
+
+        if tipb.class_css == 'articulacao':
+            r = result[0]
+            result.remove(result[0])
+            result.insert(1, r)
+
+        return result
+
+
+class ActionsEditMixin(object):
+
+    def render_to_json_response(self, context, **response_kwargs):
+
+        if context['action'] == 'add_next':
+            return JsonResponse(self.add_next(context), safe=False)
+        elif context['action'] == 'add_in':
+            return JsonResponse(self.add_in(context), safe=False)
+        elif context['action'] == 'add_prior':
+            return JsonResponse(self.add_prior(context), safe=False)
+        else:
+            return JsonResponse({}, safe=False)
+
+    def add_prior(self, context):
+        pass
+
+    def add_in(self, context):
+        pass
+
+    def add_next(self, context):
+        try:
+            base = Dispositivo.objects.get(pk=context['dispositivo_id'])
+            dp = Dispositivo.objects.get(pk=context['dispositivo_id'])
+
+            tipo = TipoDispositivo.objects.get(pk=context['tipo_pk'])
+
+            while dp.dispositivo_pai is not None and \
+                    dp.tipo_dispositivo_id != tipo.pk:
+                dp = dp.dispositivo_pai
+
+            # Inserção interna a uma articulação um tipo já existente
+            # ou de uma articulacao
+            if dp.dispositivo_pai is not None or \
+                    tipo.class_css == 'articulacao':
+
+                dp.transform_in_next(int(context['variacao']))
+                dp.rotulo = dp.rotulo_padrao()
+                dp.texto = ''
+                dp.pk = None
+                dp.norma_publicada = None
+
+                if dp.tipo_dispositivo.class_css == 'artigo':
+                    ordem = base.criar_espaco_apos(espaco_a_criar=2)
+                else:
+                    ordem = base.criar_espaco_apos(espaco_a_criar=1)
+
+                dp.ordem = ordem
+
+                # Incrementar irmãos
+
+                if not tipo.contagem_continua:
+                    irmaos = list(Dispositivo.objects.filter(
+                        dispositivo_pai_id=dp.dispositivo_pai_id,
+                        ordem__gt=dp.ordem,
+                        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:
+                    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:
+                    irmao.clean()
+                    irmao.save()
+
+                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)
+
+            # Inserção de dispositivo sem precedente de mesmo tipo
+            else:
+                dp = Dispositivo.objects.get(pk=context['dispositivo_id'])
+
+                # Encontrar primeiro irmão que contem um pai compativel
+                while True:
+                    if dp.dispositivo_pai is not None and \
+                            dp.dispositivo_pai.tipo_dispositivo_id > tipo.pk:
+                        dp = dp.dispositivo_pai
+                    else:
+                        break
+
+                dp.tipo_dispositivo = tipo
+
+                dp.pk = None
+                dp.norma_publicada = None
+
+                if tipo.contagem_continua:
+                    ultimo_irmao = Dispositivo.objects.order_by('-ordem').filter(
+                        ordem__lte=dp.ordem,
+                        tipo_dispositivo_id=tipo.pk,
+                        norma_id=dp.norma_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, ])
+                dp.rotulo = dp.rotulo_padrao()
+                dp.texto = ''
+                dp.ordem = base.criar_espaco_apos(espaco_a_criar=1)
+
+                # Incrementar irmãos
+                irmaos = Dispositivo.objects.order_by('-ordem').filter(
+                    dispositivo_pai_id=dp.dispositivo_pai_id,
+                    ordem__gt=dp.ordem,
+                    tipo_dispositivo_id=tipo.pk)
+
+                ''' inserção sem precedente é feita sem variação
+                portanto, não deve ser usado o transform_next() para
+                incrementar, e sim, apenas somar no atributo dispositivo0
+                dada a possibilidade de existir irmãos com viariação'''
+                for irmao in irmaos:
+                    irmao.dispositivo0 += 1
+                    irmao.rotulo = irmao.rotulo_padrao()
+                    irmao.clean()
+                    irmao.save()
+
+                dp.clean()
+                dp.save()
+
+            ''' Reenquadrar todos os dispositivos que possuem pai
+            antes da inserção atual e que são inferiores a dp,
+            redirecionando para o novo pai'''
+
+            possiveis_filhos = Dispositivo.objects.filter(
+                ordem__gt=dp.ordem,
+                norma_id=dp.norma_id)
+
+            nivel = sys.maxsize
+            flag_niveis = False
+            for filho in possiveis_filhos:
+
+                if filho.nivel > nivel:
+                    continue
+
+                if filho.tipo_dispositivo_id <= dp.tipo_dispositivo_id:
+                    break
+
+                if filho.dispositivo_pai.ordem >= dp.ordem:
+                    continue
+
+                nivel = filho.nivel
+
+                filho.dispositivo_pai = dp
+                filho.clean()
+                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.clean()
+                    filho.save()
+
+            ''' Renumerar dispositivos de 
+            contagem continua, caso a inserção seja uma articulação'''
+
+            numtipos = {}
+            if tipo.class_css == 'articulacao':
+
+                proxima_articulacao = Dispositivo.objects.filter(
+                    ordem__gt=dp.ordem,
+                    nivel=0,
+                    norma_id=dp.norma_id)[:1]
+
+                if not proxima_articulacao.exists():
+                    filhos_continuos = list(Dispositivo.objects.filter(
+                        ordem__gt=dp.ordem,
+                        norma_id=dp.norma_id,
+                        tipo_dispositivo__contagem_continua=True))
+                else:
+                    filhos_continuos = list(Dispositivo.objects.filter(
+                        Q(ordem__gt=dp.ordem) &
+                        Q(ordem__lt=proxima_articulacao[0].ordem),
+                        norma_id=dp.norma_id,
+                        tipo_dispositivo__contagem_continua=True))
+
+                for filho in filhos_continuos:
+
+                    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.clean()
+                    filho.save()
+
+        except Exception as e:
+            print(e)
+
+        # data = serializers.serialize('json',  dp)
+        if tipo.contagem_continua:
+            # pais a atualizar
+
+            pais = []
+
+            if dp.dispositivo_pai is None:
+                data = {'pk': dp.pk, 'pai': [-1, ]}
+            else:
+                pkfilho = dp.pk
+                dp = dp.dispositivo_pai
+
+                parents = Dispositivo.objects.filter(
+                    norma_id=dp.norma_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, 'pai': pais}
+        else:
+            data = {'pk': dp.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']
+        context['tipo_pk'] = self.request.GET['tipo_pk']
+        context['variacao'] = self.request.GET['variacao']
+        return self.render_to_json_response(context, **response_kwargs)

sapl/utils.py

@@ -1,7 +1,10 @@
+from builtins import TypeError
+
 from django.apps import apps
 from django.contrib import admin
 from django.utils.translation import ugettext_lazy as _
 
+
 # SAPL business apps
 #  This is a dependency order: each entry depends only on previous ones
 #  The order is important for migration code
@@ -37,3 +40,30 @@ def make_choices(*choice_pairs):
         yield key
 
 YES_NO_CHOICES = [(True, _('Sim')), (False, _('Não'))]
+
+
+def int_to_roman(int_value):
+    # if isinstance(int_value, type(1)):
+    #    raise TypeError("expected integer, got %s" % type(int_value))
+    if not 0 < int_value < 4000:
+        raise ValueError("Argument must be between 1 and 3999")
+    ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)
+    nums = ('M', 'CM', 'D', 'CD', 'C', 'XC',
+            'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')
+    result = ""
+    for i in range(len(ints)):
+        count = int(int_value / ints[i])
+        result += nums[i] * count
+        int_value -= ints[i] * count
+    return result
+
+
+def int_to_letter(int_value):
+    result = ''
+    int_value -= 1
+    while int_value >= 26:
+        rest = int_value % 26
+        int_value = int(int_value / 26) - 1
+        result = chr(rest + 65) + result
+    result = chr(int_value + 65) + result
+    return result

static/styles/compilacao.scss

@@ -1,28 +1,53 @@
 
 
-.articulacao div {
+#message_block {
-	background-color: #fff;
+    
+    display: none;
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background-color: rgba(220, 220, 220, 0.75);
+    z-index:99;
 }
 
+#message_block #msg{
+	position: relative;
+    margin: 25% auto;
+    padding: 1.2em 2em;
+    max-width: 600px;
+    text-align: center;
+    font-size: 1.5em;
+    color: #677;
 
-.dispositivo { 
+    border: 1px solid #eee; 
-	background-color: #ddd !important; 
+    background-color: #fff !important;
-	transition: all .4s ease-in-out;
+    box-shadow: 0 1px 2px #999;
-	display:inline;
+}
+
+.dispositivo {
+	font-size:1em;
+	transition: all 0.2s ease-in-out;
 }
 
 
 .dispositivo .ementa {
-	padding: 4em 0em 3em 50%;
+	padding: 4em 0em 3em 35%;
 	font-weight: bold;
 	
 } 
 
-.dispositivo .anexo {
+.dispositivo .anexo, 
-	font-size: 1.4em;
+.dispositivo .disp_preliminares, 
+.dispositivo .disp_gerais, 
+.dispositivo .disp_transitorias, 
+.dispositivo .disp_finais {
+	font-size: 1.5em;
 	text-align: center;
 	font-weight: bold;
 	margin-top: 3em;
+	margin-bottom: 1em;
 }
 
 .dispositivo .parte {
@@ -30,12 +55,14 @@
 	text-align: center;
 	font-weight: bold;
 	margin-top: 2em;
+	margin-bottom: 1em;
 }
 .dispositivo .livro {
 	font-size: 1.5em;
 	text-align: center;
 	font-weight: bold;
 	margin-top: 2em;
+	margin-bottom: 1em;
 }
 
 .dispositivo .titulo {
@@ -43,9 +70,11 @@
 	text-align: center;
 	font-weight: bold;
 	margin-top: 2em; 
+	margin-bottom: 1em;
 }
 
-.dispositivo .capitulo {
+.dispositivo .capitulo { 
+	margin-bottom: 1em;
 	margin-top: 1.5em;
 	font-size: 1.3em;
 	text-align: center;
@@ -53,14 +82,16 @@
 }
 
 .dispositivo .secao {
-	margin-top: 0.8em;
+	margin-top: 1.2em;
+	margin-bottom: 0.7em;
 	font-size: 1.2em;
 	text-align: center;
 	font-weight: bold;
 }
 
 .dispositivo .subsecao, .dispositivo .itemsecao {
-	margin-top: 0.8em;
+	margin-top: 1em;
+	margin-bottom: 0.6em;
 	font-size: 1.2em;
 	text-align: center;
 	font-style: italic;
@@ -69,43 +100,45 @@
 
 .dispositivo .artigo {  
 	font-size: 1.15em;
-	 float:left;
+	float:left;
 }
 .dispositivo .caput { 
-	font-size: 1.15em; 
+	margin-top: 0.3333em; 
-	margin-bottom: 0.5em; 
+	font-size: 1.15em;  
 	display: block;
 } 
  
 .dispositivo .paragrafo {
-	margin-left: 1.5em;
+	padding-left: 1.5em;
 	font-size: 1.1em;
-	margin-top: 5px;
+	margin-top: 0.2222em; 
-	margin-bottom: 3px;
 }
  
 .dispositivo .inciso {
 	font-size: 1.1em;
-	margin-left: 2.5em;
+	padding-left: 2.5em;
-	margin-top: 5px;
+	margin-top: 0.1667em;  
-	margin-bottom: 3px;
 }
 
 .dispositivo .alinea {
 	font-size: 1.0em;
-	margin-left: 3.5em;
+	padding-left: 3.5em;
+	margin-top: 2px;
 }
 
 .dispositivo .item {
 	font-size: 1.0em;
-	margin-left: 4.5em;
+	padding-left: 4.5em;
+	margin-top: 2px;
 }
 
-.dispositivo .desativado, .dispositivo .desativado * {
+.compilacaoedit .desativado, .compilacaoedit .desativado *,
+.compilacao .desativado, .compilacao .desativado * {
 	text-decoration: line-through;
 	color: #777 !important;
 } 
-.dispositivo .desativado table, .dispositivo .desativado table td {
+.compilacaoedit .desativado table, .compilacaoedit .desativado table td,
+.compilacao .desativado table, .compilacao .desativado table td {
 	border: 1px dotted #ccc;
 	text-decoration: line-through;
 }
@@ -115,11 +148,11 @@
 }
 .dispositivo a.link_alterador {
 	color: #2980B9 !important;
-	font-size: 0.9rem; 
+	font-size: 0.75em; 
 }
  
 .dispositivo .bloco_alteracao {
-	margin-left: 5em;
+	padding-left: 5em;
 	font-style: italic;
 }
 
@@ -134,6 +167,7 @@
 	color: #018 !important;  
 }
  
+ 
 .compilacao .top-bar-section li:not(.has-form) a:not(.button), 
 .compilacao .top-bar {
 	line-height: 1.6rem;
@@ -167,6 +201,7 @@
 	margin: 2.5em 0 0 0; 
 	transition: all .4s ease-in-out;
 	background: #2980B9;
+	clear:both;
 }
 
 .compilacao .fixed{ 	
@@ -175,4 +210,332 @@
 
 .displaynone {
 	display: none !important;
+}
+
+
+.compilacaoedit {
+    margin-left: 0.8em;
+    z-index: 1;
+}
+
+
+.compilacaoedit .articulacao{ 
+	
+    margin-left: -0.8em; 
+    margin-top: 2em;
+}
+
+.compilacaoedit .articulacao::before {
+    content: "Articulação";
+    background-color: #eee;
+    border-bottom: 1px solid #aaa; 
+    padding: 0.333em;
+    padding-left: 1em;
+    display:block;
+}
+
+.compilacaoedit .editclick .articulacao::before {
+    display: none;
+}
+.compilacaoedit .editdi {
+	display: block;
+	clear: left;
+}
+
+.compilacaoedit  .edit {
+	position: relative;
+	display:block;
+	background-color: transparent !important;
+	border: 0px none #fff;
+} 
+.compilacaoedit  .edit .artigo {
+	float: none;
+}
+
+.compilacaoedit  .edit > .actions {
+	color: #fff; 
+	position: absolute;
+	padding: 0 0.2em;
+	left: -2.1em;
+	opacity: 0;
+	transition: all 0.4s ease-in-out;
+}
+
+.compilacaoedit  .edit > .actions a.btn-action {
+  background: #3498db;
+  background-image: -webkit-linear-gradient(top, #3498db, #2980b9);
+  background-image: -moz-linear-gradient(top, #3498db, #2980b9);
+  background-image: -ms-linear-gradient(top, #3498db, #2980b9);
+  background-image: -o-linear-gradient(top, #3498db, #2980b9);
+  background-image: linear-gradient(to bottom, #3498db, #2980b9);
+  -webkit-border-radius: 7;
+  -moz-border-radius: 7;
+  border-radius: 7px;
+  color: #ffffff !important;
+  font-size: 18px;
+  font-weight: bold;
+  padding: 2px 6px 2px 7px;
+  text-decoration: none;
+}
+
+.compilacaoedit  .edit > .actions a.btn-action:hover {
+  background: #3cb0fd;
+  background-image: -webkit-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -moz-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -ms-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -o-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: linear-gradient(to bottom, #3cb0fd, #3498db);
+  text-decoration: none;
+}
+.compilacaoedit .edit:hover > .actions { 
+	z-index: 9;
+	opacity: 0.5; 
+	background-color: transparent !important
+}
+
+.compilacaoedit  .edit:hover > .actions:hover {
+	opacity: 1; 
+}
+
+.compilacaoedit  .edit:hover > .actions:hover::before {
+    
+    border-color: transparent transparent transparent #78F9FF; 
+}
+
+.compilacaoedit  .edit:hover > .actions::before {
+    border: inset 0.375rem;
+    content: "";
+    display: block;
+    height: 0;
+    width: 0;
+    border-color: transparent transparent transparent #78F9FF; 
+    position: absolute;
+    top: 0.53rem;
+    right: -0.51rem;
+} 
+
+.compilacaoedit .edit *:hover {
+  background-color: #eee;
+}
+
+.compilacaoedit .editclick > .label_pai {
+	position: absolute;
+	color: #999;
+	top: -1.7em;
+	left: 0;
+	right: 0; 
+	width: auto;
+	height: auto;
+}
+
+.compilacaoedit  .editclick {	
+	border: 2.1em solid #eee;
+	padding: 1em;
+	margin: 1em -2em 1em -2.8em;
+	z-index: 1;
+	background-color: #fff !important;
+	box-shadow: 0 1px 2px #aaa; 
+}
+
+.compilacaoedit .editclick > .actions {
+    display: none;
+}
+
+
+.compilacaoedit .actions_head {
+	color: #fff; 
+	position: relative;
+	opacity: 0;
+	transition: all 0.4s ease-in-out;
+	border-bottom: 1px solid #2980b9;
+	z-index: 9;
+	margin: -1em -1em 2em -1em; 
+}
+ 
+.compilacaoedit .actions_head ul {
+	margin-left: 0;
+	}
+	
+.compilacaoedit .actions_head li {
+    font-weight: normal !important;
+    display: inline-block;
+    position: relative;
+    white-space:nowrap; 
+    max-width:something;
+    }
+.compilacaoedit .actions_head > li.left {
+    border-left: 1px solid white;
+    }
+    
+    
+.compilacaoedit .actions_head > li.right{ 
+    width: 3em;
+    text-align: center;
+    clear:right;
+}
+    
+    
+	
+.compilacaoedit .actions_head li ul {
+	display: none;
+	position:absolute;
+	top: auto;
+	}
+	
+.compilacaoedit .actions_head li:hover ul{
+	display: block; 
+	}
+
+.compilacaoedit .actions_head li:hover ul li{
+	display: block;
+	background: #3498db;
+	background-image: none;
+}
+ 
+
+.compilacaoedit  .actions_head a.btn-action {
+  background: #3498db;
+  background-image: -webkit-linear-gradient(top, #3498db, #2980b9);
+  background-image: -moz-linear-gradient(top, #3498db, #2980b9);
+  background-image: -ms-linear-gradient(top, #3498db, #2980b9);
+  background-image: -o-linear-gradient(top, #3498db, #2980b9);
+  background-image: linear-gradient(to bottom, #3498db, #2980b9);
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0px;
+  color: #ffffff !important;
+  font-size: 0.8em; 
+  padding: 1px 6px 2px 7px;
+  text-decoration: none;
+  display: block;
+}
+
+.compilacaoedit .actions_head a.btn-action:hover {
+  background: #3cb0fd;
+  background-image: -webkit-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -moz-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -ms-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: -o-linear-gradient(top, #3cb0fd, #3498db);
+  background-image: linear-gradient(to bottom, #3cb0fd, #3498db);
+  text-decoration: none;
+}
+
+.compilacaoedit .actions_head > li > a.btn-action {
+  font-weight: bold;
+  font-size: 1em;
+}
+
+.compilacaoedit .actions_head { 
+	z-index: 99;
+	opacity: 0.5;
+}
+
+.compilacaoedit .actions_head:hover {
+    opacity: 1;
+} 
+
+.compilacaoedit .actions_insert {
+    opacity: 1;  
+    display: block;
+} 
+
+.compilacaoedit .actions_insert li {
+    opacity: 1;
+    display: block;
+}
+
+.compilacaoedit .actions_insert > li.right{
+    opacity: 1;
+    width: 3em;
+    text-align: center;
+    clear:right;
+}
+
+.compilacaoedit .actions_insert > li.left:nth-child(1),
+.compilacaoedit .actions_insert > li.left:nth-child(2) {
+    opacity: 1;
+    display: block;
+    min-width: 35%; 
+    max-width: 35%; 
+}
+.compilacaoedit .actions_insert li.left:nth-child(1) ul,
+.compilacaoedit .actions_insert li.left:nth-child(2) ul {
+
+    display: block; 
+    position: relative;
+    
+}
+
+.compilacaoedit .actions_insert li.left:nth-child(3):hover ul {
+	right: 0;
+    box-shadow: -3px 3px 1.5em #336;
+}
+ 
+
+
+
+
+
+
+.compilacaoedit .actions_footer {
+	color: #fff; 
+	position: absolute;
+	top: 100%;
+	left: -2em;
+	opacity: 0;
+	transition: all 0.4s ease-in-out;
+	clip: rect(0,0,0,0);
+}
+
+.compilacaoedit .actions_footer ul  {
+	margin-left: 0;
+	margin-bottom: 0;
+}
+
+.compilacaoedit .actions_footer li  {
+	display: block;
+    height: auto !important; 
+}
+
+.compilacaoedit  .editclick > .actions_footer a.btn-action {
+  background: #3498db;
+
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0px;
+  color: #ffffff !important;
+  font-size: 12px; 
+  padding: 1px 6px 1px 7px;
+  text-decoration: none;
+  display: block;
+}
+
+.compilacaoedit  .editclick > .actions_footer a.btn-action:hover {
+  background: #3cb0fd;
+
+  text-decoration: none;
+}
+.compilacaoedit  .editclick > .actions_footer { 
+	z-index: 99;
+	opacity: 0.5; 
+    clip: rect(0,0,0,0);
+}
+
+.compilacaoedit  .editclick > .actions_footer:hover {
+	opacity: 1; 
+	clip: auto
+}
+
+.clear {
+	 clear:both;
+	 height: 0;
+	 width: 0;
+}
+
+
+
+@media print {
+	.compilacao .vigencias {
+		display:none;
+	}
 }

templates/compilacao/edit.html

@@ -0,0 +1,154 @@
+{% extends "base.html" %}
+{% load i18n %}
+{% load compilacao_filters %}
+
+{% block title%}
+  <h1><b>Edição:</b> {{ view.get_norma }}</h1>
+{% endblock %}
+
+{% block base_content %}  
+
+<script type="text/javascript">
+
+$(document).ready(function() {
+
+	var flag_add_next = false
+	var flag_add_next_pk = 0
+	var flag_add_next_pai = 0
+
+	clickEditDispositivo = function(event) { 
+		var _pk = event.target.getAttribute('pk');
+		
+		
+		if ($('#de'+_pk).hasClass("editclick")) {
+            clearEditClick();
+			return;
+		}
+		
+        clearEditClick();
+
+		clickUpdateDispositivo(event)
+	}
+
+	clickUpdateDispositivo = function(event, __pk, __action, addeditclick) {
+
+		var _pk = __pk;
+		var _action = __action;
+		var _variacao = '';
+		var _tipo_pk = '';
+
+		if (event != null) {
+			_pk = event.target.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 == 'refresh' || typeof _action == 'undefined')
+		    url = _pk+'/refresh?pkadd='+flag_add_next_pk;
+		else {
+		    url = _pk+'/actions?action='+_action;
+		    url += '&tipo_pk='+_tipo_pk;
+		    url += '&variacao='+_variacao;
+		    
+		    
+	        if (typeof addeditclick == 'undefined' || addeditclick) {
+	            $("#message_block").css("display", "block");
+	        }
+		}
+        
+        
+		$.get(url).done(function( data ) { 
+
+            if (addeditclick)
+                clearEditClick();
+
+            if (_action == 'refresh' || typeof _action == 'undefined') { 
+
+
+                if (flag_add_next) {
+                    $( '#de' + _pk ).html( data); 
+                    flag_add_next = false
+                } 
+                else {
+                    clearEditClick();
+                    $( '#de' + _pk ).prepend( data );
+                    }
+
+                reloadFunctionClicks(); 
+
+                if (typeof addeditclick == 'undefined' || addeditclick) {
+                    $('#de'+flag_add_next_pk).addClass('editclick');
+                    $('html, body').animate({
+                        scrollTop: $('#de' + flag_add_next_pk ).offset().top - window.innerHeight / 3 
+                        }, 300);
+                    flag_add_next_pk = 0;
+                }
+            }
+
+            else if (_action == 'add_next') {
+ 
+                clearEditClick();
+            
+				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('TODO: Inserção com renumeração ');
+				    flag_add_next_pk = 0;
+				    flag_add_next = false;
+				    }
+		    }
+		}).always(function() {
+		    $("#message_block").css("display", "none");
+		});
+
+	}
+	
+
+function clearEditClick() {
+    $('.editclick').removeClass('editclick');
+    $('.editclick .label_pai, .edit .label_pai').remove();
+    $('.editclick .actions_head, .edit .actions_head').remove();
+    $('.editclick .actions_footer, .edit .actions_footer').remove();
+}
+
+function reloadFunctionClicks() { 
+	$('.dispositivo .edit .di').off();
+	$('.actions .btn-action').off();
+	$('.actions_head .btn-action').off();
+
+	$('.dispositivo .edit .di').on('click', clickEditDispositivo);
+	$('.actions .btn-action').on('click', clickEditDispositivo);
+	$('.actions_head .btn-action').on('click', clickUpdateDispositivo);
+}
+
+reloadFunctionClicks();
+
+});
+
+
+</script>
+<div id="message_block"><div id="msg">Aguarde... Atualizando informações!!!</div></div>
+<div class="compilacaoedit">
+	{% include 'compilacao/edit_bloco.html'%}
+</div>
+{% endblock base_content %}

templates/compilacao/edit_bloco.html

@@ -0,0 +1,94 @@
+{% load i18n %}
+{% load compilacao_filters %}  
+
+{% for dispositivo in object_list %}
+	{% if dispositivo.nivel == view.flag_nivel_old %} 
+			</div> 
+	{% elif dispositivo.nivel < view.flag_nivel_old %}	 
+			{% close_div view.flag_nivel_old dispositivo.nivel 0 %} 
+	{% endif%}
+
+	{% if forloop.first and view|isinst:'DispositivoEditView' %}
+	{% else %}
+		<div class="dispositivo edit {% dispositivo_desativado dispositivo view.inicio_vigencia view.fim_vigencia %}" id="de{{dispositivo.pk}}" pk="{{dispositivo.pk}}">
+	{% endif%}
+
+	{% if view|render_actions_head:dispositivo %}
+		<ul class="actions_head {% if dispositivo.texto == ''%}actions_insert{%endif%}">
+
+			{% for inserts in view.select_provaveis_inserts%}
+				<li class="left" ><a class="btn-action" action="" pk="{{dispositivo.pk}}">{{inserts|get_field:'tipo_insert'}}</a>
+					<ul id="afe{{dispositivo.id}}" >
+						{% for item in inserts|get_field:'itens' %}
+							<li><a class="btn-action" action="{{inserts|get_field:'action'}}" pk="{{item|get_field:'dispositivo_base'}}" variacao="{{item|get_field:'variacao'}}" tipo_pk="{{item|get_field:'tipo_pk'}}">{{item|get_field:'provavel'}}</a></li>
+						{% endfor %}
+					</ul> 
+				</li> 
+			{% endfor %}
+
+
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="Atualizar bloco...">A</a></li>
+			
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Aumentar nível do Dispositivo">&gt;</a></li>
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Reduzir nível do Dispositivo">&lt;</a></li>
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Descer uma posição">&#8595;</a></li>
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Subir uma posição">&#8593;</a></li>
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Descer uma posição com todos os subniveis">&#8595;&#8595;</a></li>
+			<li class="right"><a class="btn-action" pk="{{dispositivo.pk}}" action="refresh" title="TODO: Subir uma posição com todos os subniveis">&#8593;&#8593;</a></li>
+		</ul> 
+
+		<div class="actions_footer" >
+		
+			<ul class="left" id="afe{{dispositivo.pk}}" >
+				<li><a class="btn-action" >{{dispositivo.tipo_dispositivo}} - {ordem:{{dispositivo.ordem}}, nivel:{{dispositivo.nivel}}}</a></li>
+			</ul> 
+		</div> 
+
+		<div class="label_pai">
+			<div class="left">Em Edição: {% nomenclatura_heranca dispositivo %} </div>
+            <div class="right"> {ordem:{{dispositivo.ordem}}, nivel:{{dispositivo.nivel}}}</div>
+	   </div> 
+    {% endif%}
+    
+    
+    {% if view.pk_view == 0 and view.pk_add == 0 or view.pk_add != view.pk_view%}
+    
+        <div class="actions">
+            <a class="btn-action" pk="{{dispositivo.pk}}"  title="Edição do dispositivo: {{ dispositivo.tipo_dispositivo.nome }} {{ dispositivo.rotulo }}">E</a>
+        </div>
+    
+
+		<div class="editdi {{ dispositivo.tipo_dispositivo.class_css }}">  
+{% spaceless %}
+			<a class="di" id="id{{dispositivo.id}}" pk="{{dispositivo.pk}}" ordem="{{dispositivo.ordem}}" name="{{dispositivo.pk}}" title="{{dispositivo.pk}}">
+			{{ dispositivo.tipo_dispositivo.rotulo_prefixo_html|safe }}{{ dispositivo.rotulo }}{{ dispositivo.tipo_dispositivo.rotulo_sufixo_html|safe }}{{ dispositivo.tipo_dispositivo.texto_prefixo_html|safe }}
+			{% if dispositivo.texto == '' and not dispositivo.tipo_dispositivo.dispositivo_de_articulacao %}<b>({{dispositivo.tipo_dispositivo}} sem texto)</b>{%else%}{{ dispositivo.texto|safe }}{%endif%}
+			</a>
+
+			{% if dispositivo.norma_publicada_id != None %}
+				 <a class="link_alterador" href="{%url 'compilacao' dispositivo.norma_publicada.pk %}#{{dispositivo.dispositivo_atualizador_id}}">
+				{{ dispositivo.tipo_dispositivo.nota_automatica_prefixo_html|safe }}
+				{% nota_automatica dispositivo %}
+				{{ dispositivo.tipo_dispositivo.nota_automatica_sufixo_html|safe }}
+				 </a>
+			{% endif %}
+{% endspaceless %}
+			{% if view.is_norma_alteradora and dispositivo.tipo_dispositivo.class_css == 'bloco_alteracao'%} 
+				{%with node=dispositivo template_name='compilacao/edit_bloco_alteracao.html' %}
+					{%include template_name%}
+				{%endwith%}   
+			{% endif%}
+		</div>
+		<div class="clear"></div>
+		
+		
+    {% endif%}
+		
+	{% set_nivel_old view dispositivo.nivel %}
+{% endfor %}
+
+{% if view|isinst:'DispositivoEditView' %}
+	{% close_div view.flag_nivel_old view.flag_nivel_ini -1 %}  
+{% else %}
+	{% close_div view.flag_nivel_old view.flag_nivel_ini 0 %}  
+{% endif%}

templates/compilacao/bloco_alteracao.html → templates/compilacao/edit_bloco_alteracao.html

@@ -1,5 +1,5 @@
 {% load compilacao_filters %}
-{% for ch in dispositivo.pk|get_bloco %}
+{% for ch in dispositivo.pk|get_bloco_atualizador %}
 {% spaceless %}
 	<div class="dispositivo" id="d{{ch.id}}">
 		<div class="{{ ch.tipo_dispositivo.class_css }}" id="id{{ch.id}}" nivel="{{ch.nivel}}">

templates/compilacao/index.html

@@ -3,47 +3,51 @@
 {% load compilacao_filters %}
 
 {% block title%}
-  <h1>{{ view.get_norma }}</h1>
+    <h1>{{ view.get_norma }}</h1>
 {% endblock %}
 
 {% block base_content %}  
-
 <script type="text/javascript">
 
 $( window ).scroll(function() {
-
+    if (window.pageYOffset <= 180)
-    if (window.pageYOffset <= 180) {
         $( "section.vigencias" ).removeClass("fixed");
-    }
+    else if (!$( "section.vigencias" ).hasClass("fixed"))
-    else if (!$( "section.vigencias" ).hasClass("fixed")){
         $( "section.vigencias" ).addClass("fixed"); 
-    }
+});
-}); 
 
-function textoMultiVigente(item) {
 
+$(window).load(function() {
+    setTimeout(function() {
+	    height = $( "section.vigencias" ).height()
+	    window.scrollTo(0, window.pageYOffset - height - 36 ); 
+    }, 1000);
+});
+ 
+function textoMultiVigente(item) {
 	$(".compilacao .tipo-vigencias a").removeClass("selected")
 	$(item).addClass("selected")
-
 	$(".desativado").removeClass("displaynone");
 	$(".link_alterador").removeClass("displaynone");
 }
 function textoVigente(item, link) {
-
 	$(".compilacao .tipo-vigencias a").removeClass("selected")
 	$(item).addClass("selected")
-
 	$(".desativado").addClass("displaynone");
 	$(".link_alterador").removeClass("displaynone");
-
 	if (!link)
 		$(".link_alterador").addClass("displaynone");
 }
-
-
 </script>
 
 <div class="compilacao">  
+
+
+<div style="float: right; clear:right;">
+<a title="TODO: diminuir fonte... basta manipular font-size da classe css dispositivo">---</a>
+<a title="TODO: aumentar fonte... basta manipular font-size da classe css dispositivo">+++</a>
+</div>
+
 			{% for key, values in view.get_vigencias.items %}
 				{% if forloop.first %}				
 <section class="vigencias">
@@ -84,7 +88,7 @@ function textoVigente(item, link) {
 				<li><a class="selected" onclick="textoMultiVigente(this);">{% trans 'Texto Multivigente'%}</a></li> 
 				<li><a onclick="textoVigente(this, true);">{% trans 'Texto Vigente COM Links para Normas Alteradoras'%}</a></li> 
 				<li><a onclick="textoVigente(this, false);">{% trans 'Texto Vigente SEM Links para Normas Alteradoras'%}</a></li> 
-			</ul>	
+			</ul>
 		</section>
 	</nav>
 </section>
@@ -96,6 +100,8 @@ function textoVigente(item, link) {
 {%endif%}
 
 
-{% include 'compilacao/template_render_bloco.html'%}
+
+
+{% include 'compilacao/index_bloco.html'%}
 </div>
 {% endblock base_content %}

templates/compilacao/template_render_bloco.html → templates/compilacao/index_bloco.html

@@ -1,21 +1,16 @@
 {% load i18n %}
 {% load compilacao_filters %}  
 
-{% for dispositivo in view.get_queryset %}
+{% for dispositivo in object_list %}
 	{% if dispositivo.nivel == view.flag_nivel_old %}
 		</div>
 	{% elif dispositivo.nivel < view.flag_nivel_old %}
-		{% close_div view.flag_nivel_old dispositivo.nivel %}
+		{% close_div view.flag_nivel_old dispositivo.nivel 0 %}
 	{% endif%}
-	<div class="dispositivo" id="d{{dispositivo.id}}">
+	<div class="dispositivo {% dispositivo_desativado dispositivo view.inicio_vigencia view.fim_vigencia %}" id="d{{dispositivo.id}}">
-		<div class="{% dispositivo_desativado dispositivo view.inicio_vigencia view.fim_vigencia %} {{ dispositivo.tipo_dispositivo.class_css }}" id="id{{dispositivo.id}}">  
+		<div class="{{ dispositivo.tipo_dispositivo.class_css }}" id="id{{dispositivo.id}}">  
 {% spaceless %}
-				{{ dispositivo.tipo_dispositivo.rotulo_prefixo_html|safe }}
+			{{ dispositivo.tipo_dispositivo.rotulo_prefixo_html|safe }}<a name="{{dispositivo.pk}}" title="{{dispositivo.pk}}">{{ dispositivo.rotulo }}</a>{{ dispositivo.tipo_dispositivo.rotulo_sufixo_html|safe }}{{ dispositivo.tipo_dispositivo.texto_prefixo_html|safe }}{{ dispositivo.texto|safe }}
-				<a name="{{dispositivo.pk}}">{{ dispositivo.rotulo }}</a>
-				{{ dispositivo.tipo_dispositivo.rotulo_sufixo_html|safe }}
-				{{ dispositivo.tipo_dispositivo.texto_prefixo_html|safe }}
-				{{ dispositivo.texto|safe }}
-				 
 			{% if dispositivo.norma_publicada_id != None %}
 				<a class="link_alterador" href="{%url 'compilacao' dispositivo.norma_publicada.pk %}#{{dispositivo.dispositivo_atualizador_id}}">
 				{{ dispositivo.tipo_dispositivo.nota_automatica_prefixo_html|safe }}
@@ -25,11 +20,11 @@
 			{% endif %}
 {% endspaceless %}
 			{% if view.is_norma_alteradora and dispositivo.tipo_dispositivo.class_css == 'bloco_alteracao'%} 
-				{%with node=dispositivo template_name='compilacao/bloco_alteracao.html' %}
+				{%with node=dispositivo template_name='compilacao/index_bloco_alteracao.html' %}
 					{%include template_name%}
 				{%endwith%}   
 			{% endif%}
 		</div>
 	{% set_nivel_old view dispositivo.nivel %}
 {% endfor %}
-{% close_div view.flag_nivel_old view.flag_nivel_ini %} 
+{% close_div view.flag_nivel_old view.flag_nivel_ini 0 %} 

templates/compilacao/index_bloco_alteracao.html

@@ -0,0 +1,10 @@
+{% load compilacao_filters %}
+{% for ch in dispositivo.pk|get_bloco_atualizador %}
+{% spaceless %}
+	<div class="dispositivo" id="d{{ch.id}}">
+		<div class="{{ ch.tipo_dispositivo.class_css }}" id="id{{ch.id}}" nivel="{{ch.nivel}}">
+			{{ ch.tipo_dispositivo.rotulo_prefixo_html|safe }}<a name="{{ch.pk}}" href="{%url 'compilacao' ch.norma.pk %}#{{ch.pk}}">{{ ch.rotulo }}</a>{{ ch.tipo_dispositivo.rotulo_sufixo_html|safe }}{{ ch.tipo_dispositivo.texto_prefixo_html|safe }}{{ ch.texto|safe }} 
+		</div> 
+	</div>
+{% endspaceless %}
+{% endfor %} 

templates/sistema.html

@@ -78,6 +78,15 @@
   		<li><a href="">Assunto de Norma Jurídica</a></li>
 	</ul>
 
+	<h5>Módulo Compilação</h5>
+	<ul class="small-block-grid-1 medium-block-grid-2 large-block-grid-2">
+  		<li><a href="{% url 'tipodispositivo:list' %}">Tipo de Dispositivo</a></li> 
+  		<li><a href="{% url 'tiponota:list' %}">Tipo de Nota</a></li> 
+  		<li><a href="{% url 'tipovide:list' %}">Tipo de Vide</a></li> 
+  		<li><a href="{% url 'tipopublicacao:list' %}">Tipo de Publicação</a></li> 
+		<li><a href="{% url 'veiculopublicacao:list' %}">Veículo de Públicação</a></li> 
+	</ul>
+
 	<h5>Módulo Sessão Plenária</h5>
 	<ul class="small-block-grid-1 medium-block-grid-2 large-block-grid-2">
   		<li><a href="{% url 'tiposessaoplenaria:list' %}">Tipo de Sessão Plenária</a></li>