--===========================================================================--
-- ##INI :: IMPORTACAO TABELAS DE MOVIMENTO DE MATERIAS DE CONSUMO           --
--===========================================================================--

--#######################################################################################################################################
--############# SO PRECISA SER RODADO QUANDO FOR REFEITA A MIGRACAO SOMENTE DO ALMOXARIFADO #############################################
--#######################################################################################################################################
-- #INI :: AJUSTAR URS POIS UMA ESTAVA DUPLICADA
BEGIN;
	delete from estruturaorganizacionalalmox ea where ea.estruturaorganizacional_id in (select id from estruturaorganizacional e where e.tipoestruturaorganizacional_id = (select id from dominio where chave = 'tipoEstruturaOrganizacional' and codigo = 4));
	delete from estruturaorganizacionalpatrim ep where ep.estruturaorganizacional_id in (select id from estruturaorganizacional e where e.tipoestruturaorganizacional_id = (select id from dominio where chave = 'tipoEstruturaOrganizacional' and codigo = 4));
	delete from estruturaorganizacional where tipoestruturaorganizacional_id = (select id from dominio where chave = 'tipoEstruturaOrganizacional' and codigo = 4);

	BEGIN;  -- #INI :: IMPORTACAO UNIDADE REQUISITANTE >> ESTRUTURAORGANIZACIONAL
		/*
		 - Conceito diferente de UG/UA/UL
		 - Unidades Requisitantes com mesma UA e mesmo LOCAL que a UL, não serão criadas
		 - Estamos considerando somente as Unidades Requisitantes que não possuem correspondente com UL
		*/
		INSERT INTO public.estruturaorganizacional
			 ( id
			 , databloqueio
			 , datainativo
			 , datacriacao
			 , dataedicao
			 , version
			 , classificacao
			 , codigo
			 , datafim
			 , datainicio
			 , nome
			 , sigla
			 , inativador_id
			 , autor_id
			 , editor_id
			 , organizacao_id
			 , tipoestruturaorganizacional_id
			 , unidadesuperior_id
			 , localizacao_id
			 , unidadegestora_id
			 )
		SELECT NEXTVAL('hibernate_sequence') AS id
			 , UR.DT_BLOQUEIO       AS databloqueio
			 , NULL                 AS datainativo
			 , LOCALTIMESTAMP       AS datacriacao 
			 , LOCALTIMESTAMP       AS dataedicao
			 , 0                    AS "version"
			 , UR.CD_UA             AS classificacao
			 , UR.CD_UR||'1'        AS codigo
			 , UR.DT_BLOQUEIO       AS datafim
			 , COALESCE(UR.DT_BLOQUEIO,LOCALTIMESTAMP) AS datainicio
			 , UR.NM_UR             AS nome
			 , CASE WHEN UR.SG_UR IS NULL THEN 'SG' ELSE UR.SG_UR END AS sigla
			 , NULL                 AS inativador_id
			 , NULL                 AS autor_id
			 , NULL                 AS editor_id
			 , 1                    AS organizacao_id
			 , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoEstruturaOrganizacional' AND CODIGO=4) AS tipoestruturaorganizacional_id -- 1;"Unidade gestora"; 2;"Unidade administrativa"; 3;"Unidade localizadora"; 4;"Unidade requisitante"
			 , UA.ID                AS unidadesuperior_id
			 , L.ID                 AS localizacao_id 
			 , UA.UNIDADEGESTORA_ID AS unidadegestora_id
		FROM ASIWEB.AX_UR UR
		INNER JOIN PUBLIC.ESTRUTURAORGANIZACIONAL UA ON (UA.CODIGO = UR.CD_UA and UA.tipoestruturaorganizacional_id = (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoEstruturaOrganizacional' AND CODIGO=2))     
		INNER JOIN PUBLIC.LOCALIZACAO L ON L.CODIGO = UR.CD_LOCAL
		ORDER BY UR.ID_UR;

		-- TOTALIZADORES
		DO $$ DECLARE
		BEGIN
		  RAISE NOTICE 'IMPORTACAO UNIDADE REQUISITANTE >> ESTRUTURAORGANIZACIONAL';
		  RAISE NOTICE 'Total de registros do ASI (%)', (SELECT COUNT(*) FROM ASIWEB.AX_UR);
		  RAISE NOTICE 'Total de registros no GRP (%)', (SELECT COUNT(*) FROM PUBLIC.ESTRUTURAORGANIZACIONAL WHERE TIPOESTRUTURAORGANIZACIONAL_ID = (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoEstruturaOrganizacional' AND CODIGO=4));
		  RAISE NOTICE ' ';
		END$$;
	COMMIT; -- #FIM :: IMPORTACAO UNIDADE REQUISITANTE >> ESTRUTURAORGANIZACIONAL


	BEGIN;  -- #INI :: REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALPATRIM
		INSERT INTO public.estruturaorganizacionalpatrim
			 ( id
			 , databloqueio
			 , datainativo
			 , datacriacao
			 , dataedicao
			 , version    
			 , isalmoxarifado
			 , islocalizadoradebem
			 , inativador_id
			 , autor_id
			 , editor_id
			 , estruturaorganizacional_id
			 )
		SELECT NEXTVAL('hibernate_sequence')
			 , NULL             AS databloqueio
			 , NULL             AS datainativo
			 , LOCALTIMESTAMP   AS datacriacao
			 , LOCALTIMESTAMP   AS dataedicao
			 , 0                AS version
			 , FALSE            AS isalmoxarifado
			 , FALSE            AS islocalizadoradebem
			 , NULL             AS inativador_id
			 , NULL             AS autor_id
			 , NULL             AS editor_id
			 , E.ID             AS estruturaorganizacional_id
		FROM ESTRUTURAORGANIZACIONAL E
		where tipoestruturaorganizacional_id = (select id from dominio where chave = 'tipoEstruturaOrganizacional' and codigo = 4);    

		-- TOTALIZADORES
		DO $$ DECLARE
		BEGIN
		  RAISE NOTICE 'REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALPATRIM';
		  RAISE NOTICE 'Total de registros do EO  (%)', (SELECT COUNT(*) FROM PUBLIC.ESTRUTURAORGANIZACIONAL);
		  RAISE NOTICE 'Total de registros no EOP (%)', (SELECT COUNT(*) FROM PUBLIC.ESTRUTURAORGANIZACIONALPATRIM);
		  RAISE NOTICE ' ';
		END$$;
	COMMIT; -- #FIM :: REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALPATRIM


	BEGIN;  -- #INI :: REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALALMOX
		INSERT INTO public.estruturaorganizacionalalmox
			 ( id
			 , databloqueio
			 , datainativo
			 , datacriacao
			 , dataedicao
			 , version
			 , diasrequisicao
			 , isalmoxarifado
			 , isundconsumidorarequisitante
			 , inativador_id
			 , autor_id
			 , editor_id
			 , estruturaorganizacional_id
			 )
		SELECT NEXTVAL('hibernate_sequence')
			 , NULL             AS databloqueio
			 , NULL             AS datainativo
			 , LOCALTIMESTAMP   AS datacriacao
			 , LOCALTIMESTAMP   AS dataedicao
			 , 0                AS version
			 , NULL             AS diasrequisicao
			 , FALSE            AS isalmoxarifado
			 , FALSE            AS isundconsumidorarequisitante
			 , NULL             AS inativador_id
			 , NULL             AS autor_id
			 , NULL             AS editor_id
			 , E.ID             AS estruturaorganizacional_id
		FROM ESTRUTURAORGANIZACIONAL E
		where tipoestruturaorganizacional_id = (select id from dominio where chave = 'tipoEstruturaOrganizacional' and codigo = 4);        

		-- TOTALIZADORES
		DO $$ DECLARE
		BEGIN
		  RAISE NOTICE 'REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALALMOX';
		  RAISE NOTICE 'Total de registros do EO  (%)', (SELECT COUNT(*) FROM PUBLIC.ESTRUTURAORGANIZACIONAL);
		  RAISE NOTICE 'Total de registros no EOA (%)', (SELECT COUNT(*) FROM PUBLIC.ESTRUTURAORGANIZACIONALALMOX);
		  RAISE NOTICE ' ';
		END$$;
	COMMIT; -- #FIM :: REPLICACAO ESTRUTURAORGANIZACIONAL >> ESTRUTURAORGANIZACIONALALMOX


	BEGIN;  -- #INI :: AJUSTAR PARENT_ID COM BASE NO CD_UA_SUP IMPORTADO PARA CLASSIFICACAO
		UPDATE public.estruturaorganizacional
		   SET unidadesuperior_id = ep.parent_id
		  FROM 
			 ( SELECT f.id, p.id AS parent_id
				 FROM public.estruturaorganizacional p  INNER JOIN 
					  public.estruturaorganizacional f  ON f.classificacao = p.codigo
			 ) AS ep
		 WHERE public.estruturaorganizacional.id = ep.id
		   AND public.estruturaorganizacional.id <> 1;
	COMMIT; -- #FIM :: AJUSTAR PARENT_ID COM BASE NO CD_UA_SUP IMPORTADO PARA CLASSIFICACAO


	BEGIN;  -- #INI :: JOGANDO O CODIGO NA CLASSIFICACAO PARA FACILICAR A BUSCA PARA USUARIO
		/*
		 * Alinhado com área de negócios de fazer esse update para jogar o código da classifição
		 * sem o 1 para o usuário poder buscar pelo código antigo.
		 */
		UPDATE public.estruturaorganizacional
		   SET classificacao = SUBSTRING(codigo FROM 0 FOR 5)
		 WHERE tipoestruturaorganizacional_id = 
			 ( SELECT ID FROM PUBLIC.DOMINIO 
			   WHERE CHAVE='tipoEstruturaOrganizacional' 
			   AND CODIGO=4 ); 
	COMMIT; -- #FIM :: JOGANDO O CODIGO NA CLASSIFICACAO PARA FACILICAR A BUSCA PARA USUARIO


	BEGIN;  -- #INI :: AJUSTAR CENTROCUSTO_ID COM BASE NO CD_CENTRO_CUSTO DA UNIDADE REQUISITANTE
		UPDATE public.estruturaorganizacionalalmox
		   SET centrocusto_id = und_requisitante.cc_id
		  FROM 
			 ( SELECT E.ID AS EO_ID, CC.ID AS CC_ID
			   FROM ASIWEB.AX_UR UR
			   INNER JOIN PUBLIC.ESTRUTURAORGANIZACIONAL E ON (E.CODIGO = UR.CD_UR||'1')    
			   INNER JOIN PUBLIC.ESTRUTURAORGANIZACIONALALMOX EA ON (EA.ESTRUTURAORGANIZACIONAL_ID = E.ID AND EA.ISUNDCONSUMIDORAREQUISITANTE)
			   INNER JOIN PUBLIC.CENTROCUSTO CC ON (CC.CODIGO = UR.CD_CENTRO_CUSTO)
			 ) AS und_requisitante
		 WHERE public.estruturaorganizacionalalmox.estruturaorganizacional_id = und_requisitante.eo_id;
	COMMIT; -- #FIM :: AJUSTAR CENTROCUSTO_ID COM BASE NO CD_CENTRO_CUSTO DA UNIDADE REQUISITANTE
	
		BEGIN;  -- #INI :: AJUSTA ATRIBUTOS 'ISLOCALIZADORADEBENS'/'ISALMOXARIFADO'/'ISUNDCONSUMIDORAREQUISITANTE'
		DO $$ BEGIN RAISE NOTICE 'Marca as unidades como LOCALIZADORAS se existir bens...'; END;$$;
		UPDATE ESTRUTURAORGANIZACIONALPATRIM
		   SET ISLOCALIZADORADEBEM=TRUE
		  FROM  
			 ( SELECT BP.UNIDADEATUAL_ID, COUNT(*) AS QTD
			   FROM   BEMPATRIMONIAL BP   -- VERIFICA SE A ESTRUTURA POSSUI BENS NÃO BAIXADOS
			   WHERE  BP.DOMINIOSTATUS_ID <> (SELECT ID FROM DOMINIO WHERE CHAVE='tipoStatusBem' AND CODIGO=2) -- BAIXADO
			   GROUP  BY BP.UNIDADEATUAL_ID
			 ) AS B
		 WHERE B.UNIDADEATUAL_ID=ESTRUTURAORGANIZACIONAL_ID
		   AND B.QTD > 0;
		 
		DO $$ BEGIN RAISE NOTICE 'Marca as unidades como ALMOXARIFADO (ALM) se foi informada na entrada de bens...'; END;$$;
		UPDATE PUBLIC.ESTRUTURAORGANIZACIONALALMOX
		   SET ISALMOXARIFADO = TRUE
		  FROM
			 ( SELECT EO.ID AS ALM_ID
			   FROM PUBLIC.ESTRUTURAORGANIZACIONAL EO
			   WHERE EO.DATAFIM IS NULL
			   AND EO.ID IN (SELECT DISTINCT(UNIDADECOMPRA_ID) FROM PUBLIC.BEMPATRIMONIAL)
			 ) AS B
		WHERE ESTRUTURAORGANIZACIONAL_ID=B.ALM_ID;
		
		DO $$ BEGIN RAISE NOTICE 'Marca as unidades como ALMOXARIFADO (ALM) se foi informada na entrada de bens...'; END;$$;
		UPDATE PUBLIC.ESTRUTURAORGANIZACIONALPATRIM
		   SET ISALMOXARIFADO = TRUE
		  FROM
			 ( SELECT EO.ID AS ALM_ID
			   FROM PUBLIC.ESTRUTURAORGANIZACIONAL EO
			   WHERE EO.DATAFIM IS NULL
			   AND EO.ID IN (SELECT DISTINCT(UNIDADECOMPRA_ID) FROM PUBLIC.BEMPATRIMONIAL)
			 ) AS B
		WHERE ESTRUTURAORGANIZACIONAL_ID=B.ALM_ID;    

		DO $$ BEGIN RAISE NOTICE 'Marca as unidades requisitantes (sem ul correspondente) como requisitantes...'; END;$$;
		UPDATE ESTRUTURAORGANIZACIONALALMOX
		   SET ISUNDCONSUMIDORAREQUISITANTE=TRUE
		  FROM  
			 ( SELECT UR.ID FROM PUBLIC.ESTRUTURAORGANIZACIONAL UR 
			   INNER JOIN PUBLIC.DOMINIO D ON UR.TIPOESTRUTURAORGANIZACIONAL_ID = D.ID AND D.CHAVE = 'tipoEstruturaOrganizacional' AND D.CODIGO=4
			 ) AS U
		 WHERE U.ID = ESTRUTURAORGANIZACIONAL_ID;
		 
		 --> ATUALIZANDO AS UNIDADES ALMOXARIFADO E ALMOXARIFADO PADRÃO
		DO $$ BEGIN RAISE NOTICE 'Marca as unidades requisitantes (sem ul correspondente) como requisitantes...'; END;$$;
		UPDATE PUBLIC.ESTRUTURAORGANIZACIONALPATRIM 
		   SET ISALMOXARIFADOPADRAO = ISALMOXARIFADO
		 WHERE ISALMOXARIFADOPADRAO IS NULL;
	COMMIT; -- #FIM :: AJUSTA ATRIBUTOS 'ISLOCALIZADORADEBENS'/'ISALMOXARIFADO'/'ISUNDCONSUMIDORAREQUISITANTE

COMMIT;
-- #FIM :: AJUSTAR URS POIS UMA ESTAVA DUPLICADA

BEGIN;  -- #INI :: DEFINE AS UNIDADES ALMOXARIFADO DO ORGAO >> LOCALESTOQUE
	DO $$ BEGIN RAISE NOTICE 'Importando os registros de local estoque'; END;$$;
	
    INSERT INTO public.localestoque
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , almoxarifado_id
         )
    SELECT (ROW_NUMBER() OVER (ORDER BY EA.ESTRUTURAORGANIZACIONAL_ID)) + M.MAX AS id
         , NULL             AS databloqueio
         , NULL             AS datainativo 
         , LOCALTIMESTAMP   AS datacriacao
         , LOCALTIMESTAMP   AS dataedicao
         , 0                AS "version"
         , NULL             AS inativador_id
         , NULL             AS autor_id
         , NULL             AS editor_id
         , 1                AS organizacao_id
         , EA.ESTRUTURAORGANIZACIONAL_ID AS almoxarifado_id
    FROM ESTRUTURAORGANIZACIONALALMOX EA
    JOIN (SELECT COALESCE(MAX(ID),0) AS MAX FROM PUBLIC.LOCALESTOQUE) M ON 1=1
    WHERE EA.ISALMOXARIFADO IS TRUE;
COMMIT; -- #FIM :: DEFINE AS UNIDADES ALMOXARIFADO DO ORGAO >> LOCALESTOQUE


BEGIN;  -- #INI :: MOVIMENTACAO DE ENTRADAS NO ALMOXARIFADO >> ENTRADA
    /*
        TODAS AS ENTRADAS DO ALMOXARIFADO TEM DT_CONTABIL
    */
    --> REGISTROS DE ENTRADA
	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de entrada almoxarifado (header)...'; END;$$;
	
    INSERT INTO public.entrada
         ( id
         , datacriacao
         , dataedicao
         , version
         , codigo
         , codigoasi
         , datacontabil
         , datarecebimento
         , datareferencia
         , valortotalnota
         , organizacao_id
         , dominiotipoentrada_id
         , dominiotiporecebimento_id
         , fornecedor_id
         )
    SELECT DISTINCT
           NEXTVAL('hibernate_sequence') AS id
         , NR.DT_INCLUSAO                AS datacriacao
         , NR.DT_INCLUSAO                AS dataedicao
         , 0                             AS "version"
         , NR.CD_NOTA_REC                AS codigo
         , NR.CD_ALMOXARIFADO||NR.CD_ORGAO||NR.CD_NOTA_REC AS codigoasi
         , NR.DT_CONTABIL                AS datacontabil
         , NR.DT_RECEBIMENTO             AS datarecebimento
         , NR.DT_CONTABIL                AS datareferencia
         , NRT.VL_TOTAL_ENTRADA/100      AS valortotalnota
         , 1                             AS organizacao_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoEntrada' AND CODIGO=1) AS dominiotipoentrada_id
         , (SELECT ID_GRP FROM PUBLIC.DOMINIO_ASI_GRP WHERE TP_GRP='tipoRecebimentoAlmoxarifado' AND CD_ASI=NR.CD_TIPO_MOVIMENTO) AS dominiotiporecebimento_id -- "asiweb.ax_tipo_movimento"
         , PAR.ID                        AS fornecedor_id
    FROM ASIWEB.AX_NOTA_REC NR
    JOIN ( SELECT AX_NOTA_REC_ITEM.CD_ALMOXARIFADO, AX_NOTA_REC_ITEM.CD_ORGAO, AX_NOTA_REC_ITEM.CD_NOTA_REC
                , SUM(AX_NOTA_REC_ITEM.QT_NOTA_REC_ITEM) AS QT_TOTAL_ENTRADA
                , SUM(AX_NOTA_REC_ITEM.VL_NOTA_REC_ITEM) AS VL_TOTAL_ENTRADA
           FROM ASIWEB.AX_NOTA_REC_ITEM
          GROUP BY AX_NOTA_REC_ITEM.CD_ALMOXARIFADO, AX_NOTA_REC_ITEM.CD_ORGAO, AX_NOTA_REC_ITEM.CD_NOTA_REC) NRT 
    ON NRT.CD_ALMOXARIFADO::TEXT=NR.CD_ALMOXARIFADO::TEXT AND NRT.CD_ORGAO::TEXT=NR.CD_ORGAO::TEXT AND NRT.CD_NOTA_REC::TEXT=NR.CD_NOTA_REC::TEXT
    JOIN ASIWEB.AX_V_AGENTE_ENTRADA AE ON NR.CD_AGENTE_ENTRADA::TEXT=AE.CD_AGENTE::TEXT
    LEFT JOIN PESSOA P ON (P.AGENTE_ID=NR.CD_AGENTE_ENTRADA)
    LEFT JOIN PARCEIRO PAR ON (PAR.PESSOA_ID = P.ID)    
    WHERE AE.CD_TIPO_AGENTE <> '2'; -- CD_TIPO_AGENTE=2 SAO URS E DECIDIMOS MIGRAR COMO DEVOLUCOES DEVIDO AO FEEDBACK DO USUARIO
    
    --> REGISTROS DA REFERENCIA NECESSARIA EM ENTRADA DE ALMOXARIFADO
    INSERT INTO public.entradaalmoxarifado
         ( id
         , notarecebimento
         , almoxarifado_id
         )
    SELECT DISTINCT
           E.ID                    AS id
         , NRI.CD_NOTA_REC::BIGINT AS notarecebimento
         , (SELECT ESTRUTURAORGANIZACIONAL_ID FROM PUBLIC.ESTRUTURAORGANIZACIONALALMOX WHERE ISALMOXARIFADO IS TRUE LIMIT 1) AS estruturaorganizacional_id -- #REVER
    FROM PUBLIC.ENTRADA E
    INNER JOIN ASIWEB.AX_NOTA_REC_ITEM NRI ON (E.CODIGOASI=NRI.CD_ALMOXARIFADO||NRI.CD_ORGAO||NRI.CD_NOTA_REC);

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de entrada almoxarifado (detail)...'; END;$$;
	
    /*
     A estratégia usada para incluir os itens, foi agrupá-los por valor unitário para
     bater com o total, pois um dos itens do mesmo material pode ter valor unitario
     diferente por causa do resto de uma dízima periódica.
     esta dando diferença entre o total da nota e os itens rever cd_entrada com erro = 2001000186
    */
    --> REGISTROS DOS ITENS DA REFERENCIA NECESSARIA EM ENTRADA DE ALMOXARIFADO
    INSERT INTO public.entradaalmoxarifadoitem
         ( id
         , datacriacao
         , dataedicao
         , version
         , datavalidade
         , numerolote
         , quantidade
         , quantidadetipounidadeentrada
         , quantidadesaldo
         , valortotal
         , valorunitario
         , entrada_id
         , material_id
         , unidademedidaentrada_id
         , dominiofinalidade_id
		 , CD_CONTA
         )
    SELECT DISTINCT
           NEXTVAL('hibernate_sequence')            AS id
         , E.DATACRIACAO                            AS datacriacao
         , E.DATAEDICAO                             AS dataedicao
         , 0                                        AS "version"
         , I.DT_VALIDADE                            AS datavalidade
         , I.NR_LOTE                                AS numerolote
         , I.QT_NOTA_REC_ITEM                       AS quantidade
         , I.QT_NOTA_REC_ITEM                       AS quantidadetipounidadeentrada
         , I.QT_SALDO_ITEM                          AS quantidadesaldo
         , (I.VL_NOTA_REC_ITEM)/100                 AS valortotal
         , (I.VL_NOTA_REC_ITEM/I.QT_NOTA_REC_ITEM)/100 AS valorunitario
         , E.ID                                     AS entrada_id
         , M.ID                                     AS material_id   
         , (SELECT ID FROM PUBLIC.UNIDADEMEDIDA WHERE CODIGO=I.CD_UM_ELEMENTAR) AS unidademedidaentrada_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoFinalidadeMaterial' AND CODIGO=1) AS dominiofinalidade_id -- 1;Estoque; 2;Consumo imediato
		 , I.CD_CONTA
    FROM PUBLIC.ENTRADA E
    JOIN ASIWEB.AX_NOTA_REC_ITEM I ON E.CODIGOASI::TEXT=I.CD_ALMOXARIFADO||I.CD_ORGAO||I.CD_NOTA_REC::TEXT
    JOIN PUBLIC.MATERIAL M ON (M.CODIGO=I.CD_BEM_SERVICO);
    
    -- ATRIBUIR 0.0 ONDE A QUANTIDADESALDO FOR NULA;
    UPDATE ENTRADAALMOXARIFADOITEM 
       SET QUANTIDADESALDO = 0.0 
     WHERE QUANTIDADESALDO IS NULL;
    
    UPDATE ENTRADAALMOXARIFADOITEM 
       SET VALORSOBRA = 0.0
     WHERE VALORSOBRA IS NULL;

    --Possivel erro aqui porque pode não ter a coluna código, rodar na mão um por um caso de erro. 
    DO $$
    BEGIN
      ALTER TABLE DOCUMENTO DROP COLUMN CODIGO;        
      ALTER TABLE DOCUMENTO ADD COLUMN codigo CHARACTER VARYING (30);
    EXCEPTION
        WHEN OTHERS THEN NULL;
    END$$;

    --> DOCUMENTOS DA ENTRADA
    INSERT INTO public.documento
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , dataemissao
         , numero
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , dominiotipodocumento_id
         , emitente_id
         , codigo
         )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                          AS databloqueio
         , NULL                          AS datainativo
         , LOCALTIMESTAMP                AS datacriacao
         , LOCALTIMESTAMP                AS dataedicao
         , 0                             AS "version"
         , DOC.DT_DOCUMENTO              AS dataemissao
         , DOC.NR_DOCUMENTO              AS numero
         , NULL                          AS inativador_id
         , NULL                          AS autor_id
         , NULL                          AS editor_id
         , 1                             AS organizacao_id
         , (SELECT ID_GRP FROM PUBLIC.DOMINIO_ASI_GRP WHERE TP_GRP='tipoDocumento' AND CD_ASI=DOC.CD_TP_DOCUMENTO) AS dominiotipodocumento_id -- "asiweb.cr_tp_documento"
         , NULL                          AS emitente_id
         , DOC.CD_ALMOXARIFADO||DOC.CD_ORGAO||DOC.CD_NOTA_REC AS codigo
    FROM ASIWEB.AX_DOC_NOTA_REC DOC
    ORDER BY DOC.CD_NOTA_REC;

    --> REFERENCIA DOS DOCUMENTOS DAS ENTRADAS
    INSERT INTO public.entradadocumento
         ( id 
         , entrada_id
         , entradainativo_id
         )
    SELECT D.ID    AS id
         , (SELECT E.ID FROM PUBLIC.ENTRADA E WHERE E.CODIGOASI=D.CODIGO) AS entrada_id
         , NULL    AS entradainativo_id
    FROM PUBLIC.DOCUMENTO D
    WHERE CODIGO IS NOT NULL;
COMMIT; -- #FIM :: MOVIMENTACAO DE ENTRADAS NO ALMOXARIFADO >> ENTRADA


BEGIN;  -- #INI :: IMPORTACAO BAIXAS DE ESTOQUE >> BAIXA

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de baixa almoxarifado (header)...'; END;$$;
	
    /*
      BAIXA ALMOXARIFADO
      ==================
      1. Somente uma baixa está sem data da baixa, deixei ela de fora pois a data é obrigatória, por isso a codicao dt_baixa is not null;
      2. dominiotipobaixa definido para 'tipoBaixa' do patrimonio, mudar/criar um dominio so da baixa almoxarifado
    */
    INSERT INTO public.baixa
         ( id
         , datacriacao 
         , dataedicao
         , version
         , organizacao_id
         , codigo  
         ) 
    SELECT NEXTVAL('hibernate_sequence')
         , B.DT_BAIXA     AS DATACRIACAO
         , LOCALTIMESTAMP AS DATAEDICAO
         , 0              AS "version"
         , 1              AS organizacao_id
         , (B.CD_BAIXA||B.CD_UG)::bigint AS CODIGO    
    FROM ASIWEB.AX_BAIXA B
    WHERE B.DT_BAIXA IS NOT NULL;

    INSERT INTO public.baixaalmoxarifado
         ( id
         , databaixa
         , numerobaixa
         , almoxarifado_id
         , destino_id
         , dominiotipobaixa_id
         , dominiosituacaoestorno_id
         )
    SELECT B.ID                AS id
         , B.DATACRIACAO       AS databaixa
         , BA.CD_BAIXA::bigint AS numerobaixa
         , (SELECT ESTRUTURAORGANIZACIONAL_ID FROM ESTRUTURAORGANIZACIONALALMOX WHERE ISALMOXARIFADO IS TRUE LIMIT 1) AS almoxarifado_id 
         , PAR.ID              AS destino_id
         , (SELECT ID_GRP FROM PUBLIC.DOMINIO_ASI_GRP WHERE TP_GRP='tipoBaixaAlmoxarifado' AND CD_ASI=BA.CD_TIPO_MOVIMENTO) AS dominiotipobaixa_id  -- "asiweb.ax_tipo_movimento"
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoStatusBaixaEstorno' AND CODIGO=1) AS dominiosituacaoestorno_id  -- por padrão ajustar no final
    FROM BAIXA B
    INNER JOIN ASIWEB.AX_BAIXA BA ON ((BA.CD_BAIXA||BA.CD_UG)::BIGINT=B.CODIGO)    
    LEFT JOIN PUBLIC.PARCEIRO PAR ON (PAR.AGENTE_ID=BA.CD_ORGAO_EXTERNO); 

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de baixa almoxarifado (detail)...'; END;$$;
	
    INSERT INTO public.baixaalmoxarifadoitem
         ( id
         , datacriacao
         , dataedicao
         , version
         , quantidade
         , materialconsumo_id
         , dataestorno
         , baixaalmoxarifado_id
         , sq_baixa_item
         , total
		 , CD_CONTA
         )
    SELECT NEXTVAL('hibernate_sequence') as id
         , B.DATACRIACAO                 AS datacricao
         , B.DATAEDICAO                  AS dataedicao
         , 0                             AS "version"
         , CASE WHEN I.QT_BAIXAR IS NULL THEN L.QT_ATENDIDO ELSE I.QT_BAIXAR END AS quantidade
         , M.ID                          AS materialconsumo_id
         , NULL                          AS dataestorno
         , B.ID                          AS baixaalmoxarifado_id
         , I.SQ_BAIXA_ITEM               AS sq_baixa_item
         , L.VL_BAIXA_ITEM               AS total
		 , I.CD_CONTA 					 AS CD_CONTA
    FROM ASIWEB.AX_BAIXA_ITEM I
    INNER JOIN ASIWEB.AX_BAIXA BA ON (BA.CD_ORGAO=I.CD_ORGAO AND BA.CD_ALMOXARIFADO=I.CD_ALMOXARIFADO AND BA.CD_UG=I.CD_UG AND BA.CD_BAIXA=I.CD_BAIXA)
    INNER JOIN ASIWEB.AX_BAIXA_UG_LOTE L ON (L.SQ_BAIXA_ITEM=I.SQ_BAIXA_ITEM AND L.CD_ORGAO=I.CD_ORGAO AND L.CD_UG=I.CD_UG AND L.CD_ALMOXARIFADO=I.CD_ALMOXARIFADO AND L.CD_BEM_SERVICO=I.CD_BEM_SERVICO AND L.CD_BAIXA=I.CD_BAIXA)
    INNER JOIN PUBLIC.BAIXA B ON ((BA.CD_BAIXA||BA.CD_UG)::BIGINT=B.CODIGO)
    INNER JOIN PUBLIC.BAIXAALMOXARIFADO A ON (A.ID=B.ID)
    LEFT JOIN MATERIAL M ON (M.CODIGO = I.CD_BEM_SERVICO);

    -- Refazer as migracoes de documentos  (Apagar e criar denovo, apagando o codigo toda vez que inserir nas tabelas
    --> DOCUMENTOS DA BAIXAALMOXARIFADO
    INSERT INTO public.documento
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , dataemissao
         , numero
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , dominiotipodocumento_id
         , emitente_id
         , codigo
         )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL              AS databloqueio
         , NULL              AS datainativo
         , LOCALTIMESTAMP    AS datacriacao
         , LOCALTIMESTAMP    AS dataedicao
         , 0                 AS "version"
         , DOC.DT_DOCUMENTO  AS dataemissao
         , DOC.NR_DOCUMENTO  AS numero
         , NULL              AS inativador_id
         , NULL              AS autor_id
         , NULL              AS editor_id
         , 1                 AS organizacao_id
         , (SELECT ID_GRP FROM PUBLIC.DOMINIO_ASI_GRP WHERE TP_GRP='tipoDocumento' AND CD_ASI=DOC.CD_TP_DOCUMENTO) AS dominiotipodocumento_id  -- "asiweb.cr_tp_documento"
         , NULL              AS emitente_id
         , DOC.CD_BAIXA||DOC.CD_UG AS codigo
    FROM ASIWEB.AX_DOC_BAIXA DOC
    WHERE DOC.DT_DOCUMENTO IS NOT NULL
    ORDER BY DOC.CD_BAIXA;
    
    --> REFERENCIA DOS DOCUMENTOS DAS BAIXASALMOXARIFADO
    INSERT INTO public.baixadocumento
        ( id
        , baixa_ID
        )
    SELECT DOC.ID
         , B.ID
    FROM PUBLIC.DOCUMENTO DOC 
    INNER JOIN PUBLIC.BAIXA B ON (B.CODIGO::TEXT = DOC.CODIGO)
    WHERE DOC.CODIGO IS NOT NULL
    ORDER BY DOC.CODIGO;
    
COMMIT; -- #FIM :: IMPORTACAO BAIXAS DE ESTOQUE >> BAIXA 


BEGIN;  -- #INI :: IMPORTACAO REQUISICAO >> REQUISICAOCONSUMO

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de requisicao (header)...'; END;$$;
	
    INSERT INTO public.requisicaoconsumo
         ( id
         , datacriacao
         , dataedicao
         , datarequisicao
         , version 
         , numerorequisicao
         , organizacao_id
         , almoxarifado_id
         , centrocusto_id
         , tipostatusrequisicao_id
         , unidaderequisitante_id
         , datafinalizacaoatendimento
         )
    SELECT NEXTVAL('hibernate_sequence')
         , R.DT_INCLUSAO   AS datacriacao
         , LOCALTIMESTAMP  AS dataedicao
         , R.DT_REQUISICAO AS datarequisicao
         , 0               AS version
         , R.CD_REQUISICAO AS numeroreq
         , 1               AS organizacao_id
         , (SELECT ESTRUTURAORGANIZACIONAL_ID FROM PUBLIC.ESTRUTURAORGANIZACIONALALMOX WHERE ISALMOXARIFADO LIMIT 1) AS almoxarifado_id
         , EA.CENTROCUSTO_ID  AS centrocusto_id  -- REDMINE #3587
         , (SELECT ID_GRP FROM PUBLIC.DOMINIO_ASI_GRP WHERE TP_GRP='tipoStatusRequisicao' AND CD_ASI=R.CD_SITUACAO_REQ_ATUAL) AS tipostatusrequisicao_id  -- "asiweb.ax_situacao_req"
         , E.ID            AS unidaderequisitante_id
         , CASE WHEN R.CD_SITUACAO_REQ_ATUAL='007'
             THEN R.DT_SITUACAO_REQ_ATUAL 
             ELSE NULL 
           END             AS datafinalizacaoatendimento
    FROM ASIWEB.AX_REQUISICAO R
    INNER JOIN ASIWEB.AX_UR UR ON (UR.CD_ORGAO = R.CD_ORGAO AND UR.CD_AGENTE::TEXT = R.CD_AGENTE::TEXT)
    INNER JOIN ESTRUTURAORGANIZACIONAL E ON (E.CODIGO = UR.CD_UR||'1')    
    INNER JOIN ESTRUTURAORGANIZACIONALALMOX EA ON (EA.ESTRUTURAORGANIZACIONAL_ID = E.ID AND EA.ISUNDCONSUMIDORAREQUISITANTE); 

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de requisicao (detail)...'; END;$$;
	
    INSERT INTO public.requisicaoconsumoitem
         ( id
         , datacriacao
         , dataedicao
         , version
         , quantidade
         , quantidadedevolvida
         , organizacao_id
         , materialconsumo_id
         , requisicaoconsumo_id
         , quantidadeatendida
         , sq_requisicao_item
		 , cd_conta
         )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , R.DATACRIACAO        AS datacriacao
         , R.DATAEDICAO         AS dataedicao
         , 0                    AS "version"
         , I.QT_REQUISICAO      AS quantidade
         , 0                    AS quantidadedevolvida
         , R.ORGANIZACAO_ID     AS organizacao_id
         , M.ID                 AS materialconsumo_id
         , R.ID                 AS requisicaoconsumo_id
         , RUL.QT_ATENDIDO      AS quantidadeatendida
         , I.SQ_REQUISICAO_ITEM AS sq_requisicao_item
		 , I.CD_CONTA 			AS CD_CONTA
    FROM ASIWEB.AX_REQUISICAO_ITEM I 
    INNER JOIN REQUISICAOCONSUMO R ON (R.NUMEROREQUISICAO = I.CD_REQUISICAO)
    INNER JOIN MATERIAL M ON (M.CODIGO = I.CD_BEM_SERVICO)
    LEFT JOIN ASIWEB.AX_REQ_UG_LOTE RUL ON I.CD_ORGAO::TEXT = RUL.CD_ORGAO::TEXT AND I.CD_ALMOXARIFADO::TEXT = RUL.CD_ALMOXARIFADO::TEXT AND I.CD_REQUISICAO::TEXT = RUL.CD_REQUISICAO::TEXT AND I.SQ_REQUISICAO_ITEM = RUL.SQ_REQUISICAO_ITEM;
    
    -- O ASI nao tem o conceito de "Atendido Parcialmente" entao verificar necessidade de criar este no GRP
    -- O comando abaixo atribui o novo dominio para as requisicoes com status atendida em que a quantidadeatendida eh menor que a quantidade
     
    UPDATE public.requisicaoconsumo
       SET tipostatusrequisicao_id = (SELECT ID FROM DOMINIO WHERE CHAVE='tipoStatusRequisicao' AND NOME='ATENDIDA_PARCIALMENTE')
     WHERE ID IN (SELECT DISTINCT R.ID FROM REQUISICAOCONSUMO R 
                  INNER JOIN REQUISICAOCONSUMOITEM RCI ON (RCI.REQUISICAOCONSUMO_ID = R.ID) 
                  WHERE R.TIPOSTATUSREQUISICAO_ID = (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE ='tipoStatusRequisicao' AND CODIGO=3)
                    AND (RCI.QUANTIDADE <> RCI.QUANTIDADEATENDIDA));
COMMIT; -- #FIM :: IMPORTACAO REQUISICAO >> REQUISICAOCONSUMO


BEGIN;  -- #INI :: IMPORTACAO ATENDIMENTO REQUISICAO >> TESTAR

	CREATE INDEX idx_requisicao_link
	  ON REQUISICAOCONSUMOITEM
	  USING btree
	  (requisicaoconsumo_id, materialconsumo_id, sq_requisicao_item);

	CREATE INDEX idx_atendimentorequisicao_numero
	  ON ATENDIMENTOREQUISICAOCONSUMO
	  USING btree
	  (numeroatendimento);

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de atendimento requisicao (header)...'; END;$$;
    INSERT INTO public.atendimentorequisicaoconsumo
        ( id
        , databloqueio
        , datainativo
        , datacriacao
        , dataedicao
        , version
        , dataatendimento
        , numeroatendimento
        , inativador_id 
        , autor_id
        , editor_id
        , organizacao_id
        , requisicaoconsumo_id
        )
    SELECT NEXTVAL('hibernate_sequence')
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , R.DT_CONFIRMADA         AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , R.DT_CONFIRMADA AS dataatendimento
         , AR.ID_REQ_UG_LOTE       AS numeroatendimento
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , 1                       AS organizacao_id
         , RC.ID                   AS requisicao_id
    FROM ASIWEB.AX_REQ_UG_LOTE AR
    INNER JOIN ASIWEB.AX_REQUISICAO R ON (R.CD_REQUISICAO = AR.CD_REQUISICAO)
    INNER JOIN ASIWEB.AX_REQUISICAO_ITEM RI ON (RI.CD_ALMOXARIFADO = AR.CD_ALMOXARIFADO AND RI.CD_REQUISICAO = AR.CD_REQUISICAO AND RI.CD_ORGAO = AR.CD_ORGAO AND RI.SQ_REQUISICAO_ITEM = AR.SQ_REQUISICAO_ITEM)
    INNER JOIN REQUISICAOCONSUMO RC ON (RC.NUMEROREQUISICAO = R.CD_REQUISICAO)
    WHERE R.CD_SITUACAO_REQ_ATUAL IN ('002', '003', '007');

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de atendimento requisicao item (detail)...'; END;$$;
    INSERT INTO public.atendimentoreqconsumoitem 
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , quantidade
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , atendimentoreqconsumo_id
         , material_id
         , requisicaoconsumoitem_id
		 , VALOR
         )
        SELECT NEXTVAL('hibernate_sequence') AS id
             , NULL            AS databloqueio
             , NULL            AS datainativo
             , ARC.DATACRIACAO AS datacriacao
             , LOCALTIMESTAMP  AS dataedicao
             , 0               AS "version"
             , AR.QT_ATENDIDO  AS quantidade
             , NULL            AS inativador_id
             , NULL            AS autor_id
             , NULL            AS editor_id
             , 1               AS organizacao_id
             , ARC.ID          AS atendimentoreqconsumo_id
             , M.ID            AS material_id
             , RCI.ID          AS requisicaoconsumoitem_id
			 , AR.VL_ATENDIDO/100 AS VALOR
       FROM ASIWEB.AX_REQ_UG_LOTE AR
       INNER JOIN ATENDIMENTOREQUISICAOCONSUMO ARC ON (ARC.NUMEROATENDIMENTO::NUMERIC = AR.ID_REQ_UG_LOTE)
       INNER JOIN MATERIAL M ON (M.CODIGO = AR.CD_BEM_SERVICO)
       INNER JOIN REQUISICAOCONSUMOITEM RCI ON (RCI.REQUISICAOCONSUMO_ID = ARC.REQUISICAOCONSUMO_ID AND RCI.MATERIALCONSUMO_ID = M.ID AND RCI.SQ_REQUISICAO_ITEM = AR.SQ_REQUISICAO_ITEM);
	   
	   --demorando maquina ju 28 min 15-03-2016
COMMIT; -- #FIM :: IMPORTACAO ATENDIMENTO REQUISICAO >> TESTAR


BEGIN;  -- #INI :: DEVOLUCOES
	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de devolucao (header)...'; END;$$;
    ALTER TABLE DEVOLUCAO
    ALTER COLUMN REQUISICAO_ID DROP NOT NULL;

    INSERT INTO DEVOLUCAO
    (      ID
        ,DATABLOQUEIO
        ,DATAINATIVO
        ,DATACRIACAO
        ,DATAEDICAO
        ,VERSION
        ,CODIGO
        ,DATADEVOLUCAO
        ,INATIVADOR_ID
        ,AUTOR_ID
        ,EDITOR_ID
        ,ORGANIZACAO_ID
        ,REQUISICAO_ID
    )
    SELECT NEXTVAL('hibernate_sequence')
        ,NULL
        ,NULL
        ,NR.DT_INCLUSAO                AS datacriacao
        ,NR.DT_INCLUSAO                AS dataedicao    
        ,0                             AS "version"
        ,NR.CD_NOTA_REC                AS codigo
        ,NR.DT_CONTABIL                AS datacontabil
        ,NULL                    AS INATIVADOR_ID
        ,NULL                    AS AUTOR_ID
        ,NULL                    AS EDITOR_ID
        ,(select id from organizacao limit 1) AS ORGANIZACAO_ID
        ,NULL                    AS REQUISICAO_ID
        FROM ASIWEB.AX_NOTA_REC NR
        JOIN ASIWEB.AX_V_AGENTE_ENTRADA AE ON NR.CD_AGENTE_ENTRADA::TEXT=AE.CD_AGENTE::TEXT         
        WHERE AE.CD_TIPO_AGENTE = '2' and NR.CD_TIPO_MOVIMENTO IN ('005', '033');

	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de devolucao (detail)...'; END;$$;
    INSERT INTO DEVOLUCAOITEM
    (    ID
        ,DATABLOQUEIO
        ,DATAINATIVO
        ,DATACRIACAO
        ,DATAEDICAO
        ,VERSION
        ,QUANTIDADE    
        ,INATIVADOR_ID
        ,AUTOR_ID
        ,EDITOR_ID
        ,ORGANIZACAO_ID
        ,DEVOLUCAO_ID
        ,MATERIALCONSUMO_ID    
		,cd_conta
    )
    SELECT NEXTVAL('hibernate_sequence')
        ,NULL
        ,NULL
        ,D.DATACRIACAO                            AS datacriacao
        ,D.DATAEDICAO                             AS dataedicao
        ,0                                        AS "version"
        ,I.QT_NOTA_REC_ITEM                       AS quantidade
        ,NULL                       AS INATIVADOR_ID
        ,NULL                       AS AUTOR_ID
        ,NULL                       AS EDITOR_ID
        ,(SELECT ID FROM ORGANIZACAO LIMIT 1) AS ORGANIZACAO_ID
        ,D.ID                       AS DEVOLUCAO_ID
        ,M.ID                       AS MATERIALCONSUMO_ID
		,I.CD_CONTA 			    AS CD_CONTA
        FROM PUBLIC.DEVOLUCAO D
        JOIN ASIWEB.AX_NOTA_REC_ITEM I ON D.CODIGO=I.CD_NOTA_REC
        JOIN PUBLIC.MATERIAL M ON (M.CODIGO=I.CD_BEM_SERVICO);     
        
    ALTER TABLE REQUISICAOCONSUMO 
    ADD COLUMN DEVOLUCAO_ID BIGINT;
	
    --CRIANDO AS REQUISICOES PARA LINKAR AS DEVOLUCOES
        
    -- #INI :: REQUISICAO CONSUMO VINCULADA A DEVOLUCAO
    DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de requisicoes que devem ser linkadas a devolucao '; END;$$;
	
    DO $$
    DECLARE
      rREQ      RECORD;
      v_codigo  character varying(10);
    BEGIN
      -- REQUISICOES QUE DEVERAO SER VINCULADAS AS DEVOLUCOES
      FOR rREQ IN 
        SELECT 
           NR.DT_INCLUSAO                        AS datarequisicao                          
           ,(SELECT ID FROM ORGANIZACAO LIMIT 1) AS organizacao
           ,(SELECT ESTRUTURAORGANIZACIONAL_ID FROM PUBLIC.ESTRUTURAORGANIZACIONALALMOX WHERE ISALMOXARIFADO IS TRUE LIMIT 1) AS ALMOXARIFADO_id 
           ,(SELECT ID FROM PUBLIC.CENTROCUSTO WHERE CODIGO = CC.CD_CENTRO_CUSTO) AS CENTROCUSTO
           ,(SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoStatusRequisicao' AND CODIGO=5) AS TIPOSTATUSREQUISICAO -- DEVOLVIDA
           ,E.ID           AS unidaderequisitante
           ,NR.DT_INCLUSAO AS DATAFINALIZACAO
           ,D.ID           AS DEVOLUCAO
       FROM ASIWEB.AX_NOTA_REC NR
       JOIN ASIWEB.AX_V_AGENTE_ENTRADA AE ON NR.CD_AGENTE_ENTRADA::TEXT=AE.CD_AGENTE::TEXT
       JOIN ASIWEB.AX_UR UR ON (UR.CD_UR = AE.CD_AGENTE_EXT)
       JOIN ASIWEB.CR_CENTRO_CUSTO CC ON (CC.CD_CENTRO_CUSTO = UR.CD_CENTRO_CUSTO)     
       INNER JOIN ESTRUTURAORGANIZACIONAL E ON (E.CODIGO = UR.CD_UR||'1')    
       INNER JOIN ESTRUTURAORGANIZACIONALALMOX EA ON (EA.ESTRUTURAORGANIZACIONAL_ID = E.ID AND EA.ISUNDCONSUMIDORAREQUISITANTE)
       INNER JOIN DEVOLUCAO D ON (D.CODIGO = NR.CD_NOTA_REC)
       WHERE AE.CD_TIPO_AGENTE = '2' and NR.CD_TIPO_MOVIMENTO IN ('005', '033')
      LOOP
        v_codigo := (select extract(year from rREQ.datarequisicao)||lpad(t.novareq::text, 6, '0') from (select substring(max(numerorequisicao) from 5 for 6)::bigint+1 as novareq from requisicaoconsumo where extract(year from datarequisicao) = extract(year from rREQ.datarequisicao)) as t);

        INSERT INTO public.requisicaoconsumo
        (id,
        datacriacao,
        dataedicao,
        datarequisicao,
        version, 
        numerorequisicao,
        organizacao_id,
        almoxarifado_id,
        centrocusto_id,
        tipostatusrequisicao_id,
        unidaderequisitante_id,
        datafinalizacaoatendimento,
        devolucao_id
        )VALUES(
        NEXTVAL('hibernate_sequence'),
        rREQ.datarequisicao,
        rREQ.datarequisicao,
        rREQ.datarequisicao,
        0,
        v_codigo,
        rREQ.organizacao,
        rREQ.almoxarifado_id,
        rREQ.centrocusto,
        rREQ.TIPOSTATUSREQUISICAO,
        rREQ.unidaderequisitante,
        rREQ.datarequisicao,
        rREQ.DEVOLUCAO
        );    
      END LOOP;
      
    END$$;    
    -- #FIM :: REQUISICAO CONSUMO VINCULADA A DEVOLUCAO             
        
    INSERT INTO PUBLIC.REQUISICAOCONSUMOITEM
    (    ID,
        DATACRIACAO,
        DATAEDICAO,
        VERSION,
        QUANTIDADE,
        QUANTIDADEDEVOLVIDA,
        organizacao_id,
        MATERIALCONSUMO_ID,
        REQUISICAOCONSUMO_ID,
        QUANTIDADEATENDIDA
    )
    SELECT NEXTVAL('hibernate_sequence')
       ,D.DATACRIACAO AS DATACRIACAO
       ,D.DATAEDICAO AS DATAEDICAO
       ,0 AS "VERSION"
       ,I.QT_NOTA_REC_ITEM AS QTD
       ,I.QT_NOTA_REC_ITEM AS QTDDEVOLVIDA  
       ,(SELECT ID FROM ORGANIZACAO LIMIT 1) AS ORGANIZACAO
       ,M.ID AS MATERIAL_ID     
       ,(select id from requisicaoconsumo where devolucao_id = d.id) as requisicao_id
       ,I.QT_NOTA_REC_ITEM AS QTDATENDIDA 
       FROM PUBLIC.DEVOLUCAO D
    JOIN ASIWEB.AX_NOTA_REC_ITEM I ON D.CODIGO=I.CD_NOTA_REC
    JOIN PUBLIC.MATERIAL M ON (M.CODIGO=I.CD_BEM_SERVICO);  
        
    -- Setando requisicoes nas devolucoes
    
    UPDATE devolucao d
    SET requisicao_id = (select id from requisicaoconsumo where devolucao_id = d.id);
       
    --campo de devolucao na requisicao nao Ã© mais necessario
    ALTER TABLE REQUISICAOCONSUMO 
    DROP COLUMN DEVOLUCAO_ID;       
       
    
    ALTER TABLE DEVOLUCAO
    ALTER COLUMN REQUISICAO_ID SET NOT NULL;    
COMMIT; -- #FIM :: DEVOLUCOES


-- ############                                                                                 ##########
-- ############  REVER COM CONCEITO DE CLASSIFICACAO POR NATUREZA (ESTOCAVEL E NAO ESTOCAVEL)   ##########
-- ############                                                                                 ##########
BEGIN;  -- #INI :: IMPORTACAO SALDOS DE ESTOQUE >> MOVIMENTOESTOQUESALDOMEDIO
	DO $$ BEGIN RAISE NOTICE 'Importando os registros consolidados de materialestoquesaldomedio ...'; END;$$;
    INSERT INTO public.materialestoquesaldomedio
         ( id
         , datacriacao
         , dataedicao
         , version    
         , quantidadeatual
         , organizacao_id
         , material_id
         )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , LOCALTIMESTAMP                AS datacriacao
         , LOCALTIMESTAMP                AS dataedicao
         , 0                             AS "version"
         , SUM(EST.QT_ESTOQUE)           AS quantidadeatual
         , 1                             AS organizacao_id
         , M.ID                          AS material_id
    FROM ASIWEB.AX_ESTOQUE_END EST
    INNER JOIN MATERIAL M ON (M.CODIGO = EST.CD_BEM_SERVICO)
    GROUP BY M.ID, EST.CD_BEM_SERVICO;

	DO $$ BEGIN RAISE NOTICE 'Atualizando o valormedio do material'; END;$$;
    UPDATE MATERIALESTOQUESALDOMEDIO S
       SET VALORUNITARIOMEDIO = ESTOQUE.PRECO
         , RESTOMEDIO = ESTOQUE.RESTO
    FROM (
          SELECT MATERIAL_ID
              , (SELECT PR_MEDIO/100 FROM ASIWEB.AX_ESTOQUE_UG WHERE CD_BEM_SERVICO = M.CODIGO ORDER BY CD_NATUREZA_CLASS LIMIT 1) AS PRECO
              , (SELECT VL_RESIDUO/100 FROM ASIWEB.AX_ESTOQUE_UG WHERE CD_BEM_SERVICO = M.CODIGO ORDER BY CD_NATUREZA_CLASS LIMIT 1) AS RESTO
          FROM MATERIALESTOQUESALDOMEDIO E 
          INNER JOIN MATERIAL M ON (M.ID = E.MATERIAL_ID AND DOMINIOTIPOMATERIAL_ID = (SELECT id FROM DOMINIO WHERE CHAVE='tipoMaterial' and codigo = 1))
          ) AS ESTOQUE
    WHERE S.MATERIAL_ID = ESTOQUE.MATERIAL_ID;
COMMIT; -- #FIM :: IMPORTACAO SALDOS DE ESTOQUE >> MOVIMENTOESTOQUESALDOMEDIO 

BEGIN;  -- #INI :: IMPORTACAO DOS MOVIMENTO DE ESTOQUE >> MOVIMENTOESTOQUE
	DO $$ BEGIN RAISE NOTICE 'Criando os movimentos do estoque para geracao dos saldos mensais'; END;$$;
    -- MOVIMENTOS DE ENTRADA
	DO $$ BEGIN RAISE NOTICE 'Criando os movimentos do estoque para entradas'; END;$$;
    INSERT INTO public.movimentoestoque
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , datamovimento
         , quantidade
         , valorfifo
         , valormedia
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , atendimentoreqconsumoitem_id
         , baixaalmoxarifadoitem_id
         , devolucaoitem_id
         , entradaalmoxarifadoitem_id
         , localestoque_id
         , material_id
         , materialestoquesaldo_id
         , tipomovimento_id
         )
    SELECT NEXTVAL('hibernate_sequence') AS ID
         , NULL                          AS databloqueio
         , NULL                          AS datainativo
         , E.DATACRIACAO                 AS datacriacao
         , LOCALTIMESTAMP                AS dataedicao
         , 0                             AS "version"
         , E.DATACONTABIL                AS datamovimento
         , EAI.QUANTIDADE                AS quantidade
         , EAI.VALORTOTAL             AS valorfifo
         , EAI.VALORTOTAL             AS valormedia
         , NULL                          AS inativador_id
         , NULL                          AS autor_id
         , NULL                          AS editor_id
         , 1                             AS organizacao_id
         , NULL                          AS atendimentoreqconsumoitem_id
         , NULL                          AS baixaalmoxarifadoitem_id
         , NULL                          AS devolucaoitem_id
         , EAI.ID                        AS entradaalmoxarifadoitem_id
         , (SELECT ID FROM LOCALESTOQUE LIMIT 1) AS LOCALESTOQUE_ID
         , EAI.MATERIAL_ID               AS material_id
         , NULL                          AS materialestoquesaldo_id
         , (SELECT ID FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' AND CODIGO = 1) AS tipomovimento_id
    FROM ENTRADAALMOXARIFADO EA
    INNER JOIN ENTRADA E ON (E.ID = EA.ID)
    INNER JOIN ENTRADAALMOXARIFADOITEM EAI ON (EAI.ENTRADA_ID = E.ID);

    --MOVIMENTOS DE BAIXA
	DO $$ BEGIN RAISE NOTICE 'Criando os movimentos do estoque para a baixa'; END;$$;
    INSERT INTO public.movimentoestoque
        ( id
        , databloqueio
        , datainativo
        , datacriacao
        , dataedicao
        , version
        , datamovimento
        , quantidade
        , valorfifo
        , valormedia
        , inativador_id
        , autor_id
        , editor_id
        , organizacao_id
        , atendimentoreqconsumoitem_id
        , baixaalmoxarifadoitem_id
        , devolucaoitem_id
        , entradaalmoxarifadoitem_id
        , localestoque_id
        , material_id
        , materialestoquesaldo_id
        , tipomovimento_id
        )
    SELECT NEXTVAL('hibernate_sequence') AS ID
         , NULL                          AS databloqueio
         , NULL                          AS datainativo
         , B.DATACRIACAO                 AS datacriacao
         , LOCALTIMESTAMP                AS dataedicao
         , 0                             AS "version"
         , BA.DATABAIXA                  AS datamovimento
         , -BAI.QUANTIDADE               AS quantidade
         , -(BL.VL_BAIXA_ITEM/100)       AS valorfifo
         , -(BL.VL_BAIXA_ITEM/100)       AS valormedia
         , NULL                          AS inativador_id
         , NULL                          AS autor_id
         , NULL                          AS editor_id
         , 1                             AS organizacao_id
         , NULL                          AS atendimentoreqconsumoitem_id
         , BAI.ID                        AS baixaalmoxarifadoitem_id
         , NULL                          AS devolucaoitem_id
         , NULL                          AS entradaalmoxarifadoitem_id
         , (SELECT ID FROM LOCALESTOQUE LIMIT 1) AS localestoque_id
         , BAI.MATERIALCONSUMO_ID        AS material_id
         , NULL                          AS materialestoquesaldo_id
         , (SELECT ID FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' AND CODIGO = 2) AS tipomovimento_id
    FROM BAIXAALMOXARIFADO BA
    INNER JOIN BAIXA B ON (B.ID = BA.ID)
    INNER JOIN BAIXAALMOXARIFADOITEM BAI ON (BAI.BAIXAALMOXARIFADO_ID = B.ID)
    INNER JOIN ASIWEB.AX_BAIXA_ITEM BI ON (BI.CD_BAIXA||BI.CD_UG = B.CODIGO::text and BAI.SQ_BAIXA_ITEM = BI.SQ_BAIXA_ITEM)
    INNER JOIN ASIWEB.AX_BAIXA_UG_LOTE BL ON (BL.CD_ORGAO = BI.CD_ORGAO AND BL.CD_ALMOXARIFADO = BI.CD_ALMOXARIFADO AND BL.CD_UG = BI.CD_UG AND BL.CD_BAIXA = BI.CD_BAIXA AND BL.CD_BEM_SERVICO = BI.CD_BEM_SERVICO AND BL.SQ_BAIXA_ITEM = BI.SQ_BAIXA_ITEM)
    ORDER BY BAI.ID;
    
    -- movimentos de atendimento de requisicao
	DO $$ BEGIN RAISE NOTICE 'Criando os movimentos do estoque para os atendimentos a requsicoes'; END;$$;
    INSERT INTO public.movimentoestoque
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , datamovimento
         , quantidade
         , valorfifo
         , valormedia
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , atendimentoreqconsumoitem_id
         , baixaalmoxarifadoitem_id
         , devolucaoitem_id
         , entradaalmoxarifadoitem_id
         , localestoque_id
         , material_id
         , materialestoquesaldo_id
         , tipomovimento_id
         )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                          AS databloqueio
         , NULL                          AS datainativo
         , A.DATACRIACAO                 AS datacriacao
         , LOCALTIMESTAMP                AS dataedicao
         , 0                             AS "version"    
         , A.DATAATENDIMENTO             AS datamovimento
         , -AI.QUANTIDADE                AS quantidade
         , (case when ai.quantidade = 0 then 0 else -(AI.VALOR) end) AS valorfifo
         , (case when ai.quantidade = 0 then 0 else -(AI.VALOR) end) AS valormedia
         , NULL                          AS inativador_id
         , NULL                          AS autor_id
         , NULL                          AS editor_id
         , 1                             AS organizacao_id
         , AI.ID                         AS atendimentoreqconsumoitem_id
         , NULL                          AS baixaalmoxarifadoitem_id
         , NULL                          AS devolucaoitem_id
         , NULL                          AS entradaalmoxarifadoitem_id
         , (SELECT ID FROM LOCALESTOQUE LIMIT 1) AS LOCALESTOQUE_ID
         , AI.MATERIAL_ID                AS material_id
         , NULL                          AS materialestoquesaldo_id
         , (SELECT ID FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' AND CODIGO = 3) AS tipomovimento_id
    FROM ATENDIMENTOREQUISICAOCONSUMO A
    INNER JOIN ATENDIMENTOREQCONSUMOITEM AI ON (A.ID = AI.ATENDIMENTOREQCONSUMO_ID);
    

    -- MOVIMENTOS DEVOLUCOES
	DO $$ BEGIN RAISE NOTICE 'Criando os movimentos do estoque para devolucoes'; END;$$;
    INSERT INTO public.movimentoestoque
         ( id
         , databloqueio
         , datainativo
         , datacriacao
         , dataedicao
         , version
         , datamovimento
         , quantidade
         , valorfifo
         , valormedia
         , inativador_id
         , autor_id
         , editor_id
         , organizacao_id
         , atendimentoreqconsumoitem_id
         , baixaalmoxarifadoitem_id
         , devolucaoitem_id
         , entradaalmoxarifadoitem_id
         , localestoque_id
         , material_id
         , materialestoquesaldo_id
         , tipomovimento_id
         )
    SELECT NEXTVAL('hibernate_sequence')    AS id
         , NULL                             AS databloqueio
         , NULL                             AS datainativo
         , D.DATACRIACAO                    AS datacriacao
         , D.DATAEDICAO                     AS dataedicao
         , 0                                AS "version"
         , D.DATADEVOLUCAO                  AS datamovimento
         , DI.QUANTIDADE                    AS quantidade
         , (I.VL_NOTA_REC_ITEM/100)         AS valorfifo
         , (I.VL_NOTA_REC_ITEM/100)         AS valormedia
         , NULL                             AS INATIVADOR_ID
         , NULL                             AS AUTOR_ID
         , NULL                             AS EDITOR_ID
         , 1                                AS organizacao_id
         , NULL                             AS atendimentoreqconsumoitem_id
         , NULL                             AS baixaalmoxarifadoitem_id
         , DI.ID                            AS devolucaoitem_id
         , NULL                             AS entradaalmoxarifadoitem_id
         , (SELECT ID FROM LOCALESTOQUE LIMIT 1) AS localestoque_id
         , DI.MATERIALCONSUMO_ID            AS material_id
         , NULL                             AS materialestoquesaldo_id
         , (SELECT ID FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' AND CODIGO = 4) AS tipomovimento_id
    FROM PUBLIC.DEVOLUCAO D
    INNER JOIN PUBLIC.DEVOLUCAOITEM DI ON (D.ID = DI.DEVOLUCAO_ID)    
    INNER JOIN MATERIAL M ON (M.ID = DI.MATERIALCONSUMO_ID)
    INNER JOIN ASIWEB.AX_NOTA_REC_ITEM I ON (D.CODIGO=I.CD_NOTA_REC AND M.CODIGO = I.CD_BEM_SERVICO);
COMMIT; -- #FIM :: IMPORTACAO DOS MOVIMENTO DE ESTOQUE >> MOVIMENTOESTOQUE

BEGIN;  -- #INI :: IMPORTACAO DOS MOVIMENTO DAS CONTAS DE ALMOXARIFADO >> CONTACONTABILMOVIMENTO (REVER, O CERTO ERA QUE FOSSE POR ITEM)
	DO $$ BEGIN RAISE NOTICE 'Criando o contacontabilmovimento'; END;$$;
  /*  INSERT INTO public.contacontabilmovimento
    ( id
    , databloqueio
    , datainativo
    , datacriacao
    , dataedicao
    , version
    , datareferencia
    , valor
    , inativador_id
    , autor_id
    , editor_id
    , baixa_id
    , contacontabil_id
    , tipomovimentocontacontabil_id
    , entrada_id
    , transferenciaconta_id
    )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , LOCALTIMESTAMP          AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , TO_DATE(S.AA_FECHAMENTO||S.MM_FECHAMENTO,'YYYYMM') AS datareferencia
         , CASE 
             WHEN S.VL_ENTRADA > 0 THEN (S.VL_ENTRADA/100)
             WHEN S.VL_SAIDA   > 0 THEN (ABS(S.VL_SAIDA/100)*(-1))
           END                     AS valor
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , NULL                    AS baixa_id
         , C.ID                    AS contacontabil_id
         , CASE 
             WHEN S.VL_ENTRADA > 0 THEN (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=1)  -- "Entrada orçamentária"
             WHEN S.VL_SAIDA   > 0 THEN (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=2)  -- "Baixa orçamentária"
           END                     AS tipomovimentocontacontabil_id
         , NULL                    AS entrada_id
         , NULL                    AS transferenciaconta_id
    FROM PUBLIC.CONTACONTABIL C
    INNER JOIN ASIWEB.AX_V_SALDO_ANT S ON C.CODIGO=S.CD_CONTA
    JOIN (SELECT COALESCE(MAX(ID),0) AS MAX FROM public.contacontabilmovimento) M ON 1=1
    WHERE (S.VL_ENTRADA+S.VL_SAIDA)>0
    ORDER BY S.CD_CONTA; */
	
	DO $$ BEGIN RAISE NOTICE 'Criando o contacontabilmovimento das entradas'; END;$$;
    INSERT INTO public.contacontabilmovimento
    ( id
    , databloqueio
    , datainativo
    , datacriacao
    , dataedicao
    , version
    , datareferencia
    , valor
    , inativador_id
    , autor_id
    , editor_id
    , baixa_id
    , contacontabil_id
    , tipomovimentocontacontabil_id
    , entrada_id
    , transferenciaconta_id
    , idclassereferencia
    , dominioclassereferencia_id
    )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , LOCALTIMESTAMP          AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , M.DATAMOVIMENTO         AS datareferencia
         , M.VALORMEDIA            AS valor
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , NULL                    AS baixa_id
         , C.ID                    AS contacontabil_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=1) AS tipomovimentocontacontabil_id -- "Entrada orçamentária" 
         , NULL                    AS entrada_id
         , NULL                    AS transferenciaconta_id
         , M.entradaalmoxarifadoitem_id AS IDCLASSEREFERENCIA
         , (select id from dominio where chave='classeReferencia' and codigo = 12) as dominioclassereferencia_id
    FROM PUBLIC.MOVIMENTOESTOQUE M
    inner join public.entradaalmoxarifadoitem ei on (ei.id = m.entradaalmoxarifadoitem_id)
    inner join public.contacontabil c on (c.codigo = ei.cd_conta)
    WHERE tipomovimento_id = (SELECT id FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' and codigo = 1);	
	
	DO $$ BEGIN RAISE NOTICE 'Criando o contacontabilmovimento das baixas'; END;$$;
    INSERT INTO public.contacontabilmovimento
    ( id
    , databloqueio
    , datainativo
    , datacriacao
    , dataedicao
    , version
    , datareferencia
    , valor
    , inativador_id
    , autor_id
    , editor_id
    , baixa_id
    , contacontabil_id
    , tipomovimentocontacontabil_id
    , entrada_id
    , transferenciaconta_id
    , idclassereferencia
    , dominioclassereferencia_id
    )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , LOCALTIMESTAMP          AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , M.DATAMOVIMENTO         AS datareferencia
         , M.VALORMEDIA            AS valor
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , NULL                    AS baixa_id
         , C.ID                    AS contacontabil_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=4) AS tipomovimentocontacontabil_id -- "Entrada orçamentária" 
         , NULL                    AS entrada_id
         , NULL                    AS transferenciaconta_id
         , M.baixaalmoxarifadoitem_id AS IDCLASSEREFERENCIA
         , (select id from dominio where chave='classeReferencia' and codigo = 13) as dominioclassereferencia_id
    FROM PUBLIC.MOVIMENTOESTOQUE M
    inner join public.BAIXAalmoxarifadoitem Bi on (Bi.id = m.baixaalmoxarifadoitem_id)
    inner join public.contacontabil c on (c.codigo = bi.cd_conta)
    WHERE tipomovimento_id = (SELECT id FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' and codigo = 2);

    DO $$ BEGIN RAISE NOTICE 'Criando o contacontabilmovimento das devoluções'; END;$$;
    INSERT INTO public.contacontabilmovimento
    ( id
    , databloqueio
    , datainativo
    , datacriacao
    , dataedicao
    , version
    , datareferencia
    , valor
    , inativador_id
    , autor_id
    , editor_id
    , baixa_id
    , contacontabil_id
    , tipomovimentocontacontabil_id
    , entrada_id
    , transferenciaconta_id
    , idclassereferencia
    , dominioclassereferencia_id
    )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , LOCALTIMESTAMP          AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , M.DATAMOVIMENTO         AS datareferencia
         , M.VALORMEDIA            AS valor
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , NULL                    AS baixa_id
         , C.ID                    AS contacontabil_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=1) AS tipomovimentocontacontabil_id -- "Entrada orçamentária" 
         , NULL                    AS entrada_id
         , NULL                    AS transferenciaconta_id
         , M.devolucaoitem_id AS IDCLASSEREFERENCIA
         , (select id from dominio where chave='classeReferencia' and codigo = 6) as dominioclassereferencia_id
    FROM PUBLIC.MOVIMENTOESTOQUE M
    inner join public.devolucaoitem di on (di.id = m.devolucaoitem_id)
    inner join public.contacontabil c on (c.codigo = di.cd_conta)
    WHERE tipomovimento_id = (SELECT id FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' and codigo = 4);    

    DO $$ BEGIN RAISE NOTICE 'Criando o contacontabilmovimento dos atendimentos'; END;$$;
    INSERT INTO public.contacontabilmovimento
    ( id
    , databloqueio
    , datainativo
    , datacriacao
    , dataedicao
    , version
    , datareferencia
    , valor
    , inativador_id
    , autor_id
    , editor_id
    , baixa_id
    , contacontabil_id
    , tipomovimentocontacontabil_id
    , entrada_id
    , transferenciaconta_id
    , idclassereferencia
    , dominioclassereferencia_id
    )
    SELECT NEXTVAL('hibernate_sequence') AS id
         , NULL                    AS databloqueio
         , NULL                    AS datainativo
         , LOCALTIMESTAMP          AS datacriacao
         , LOCALTIMESTAMP          AS dataedicao
         , 0                       AS "version"
         , M.DATAMOVIMENTO         AS datareferencia
         , M.VALORMEDIA            AS valor
         , NULL                    AS inativador_id
         , NULL                    AS autor_id
         , NULL                    AS editor_id
         , NULL                    AS baixa_id
         , C.ID                    AS contacontabil_id
         , (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMovimentoContaContabil' AND CODIGO=4) AS tipomovimentocontacontabil_id -- "Entrada orçamentária" 
         , NULL                    AS entrada_id
         , NULL                    AS transferenciaconta_id
         , M.atendimentoreqconsumoitem_id AS IDCLASSEREFERENCIA
         , (select id from dominio where chave='classeReferencia' and codigo = 14) as dominioclassereferencia_id
    FROM PUBLIC.MOVIMENTOESTOQUE M
    inner join public.atendimentoreqconsumoitem ai on (ai.id = m.atendimentoreqconsumoitem_id)    
    INNER JOIN public.requisicaoconsumoitem ri on (ri.id = ai.requisicaoconsumoitem_id)
    inner join public.contacontabil c on (c.codigo = ri.cd_conta)
    WHERE tipomovimento_id = (SELECT id FROM DOMINIO WHERE CHAVE = 'tipoMovimentoEstoque' and codigo = 3);       
    	
COMMIT; -- #FIM :: IMPORTACAO DOS MOVIMENTO DAS CONTAS DE ALMOXARIFADO >> CONTACONTABILMOVIMENTO


BEGIN; -- PRIMEIRO SALDO 200912 ALMOX
                INSERT INTO public.contacontabilsaldo
                     ( id
                     , datacriacao
                     , dataedicao
                     , version
                     , datareferencia
                     , valor
                     , contacontabil_id
                     , depreciacaoacumulada
                     , depreciacaomensal
                     , reavaliacaoperiodo
                     , reavaliacaoacumulada
                     , reducaoperiodo
                     , reducaoacumulada               
                     )
                SELECT 
		       NEXTVAL('hibernate_sequence')
		     , LOCALTIMESTAMP
		     , LOCALTIMESTAMP
		     , 0
		     , TO_TIMESTAMP('20091201','YYYYMMDD')::timestamp without time zone
		     , F.vl_saldo_ant/100
		     , C.ID
		     , 0
		     , 0
		     , 0
		     , 0 
		     , 0
		     , 0
		FROM ASIWEB.AX_V_SALDO_ANT F 
		INNER JOIN CONTACONTABIL C ON (C.CODIGO = F.CD_CONTA)
		WHERE F.AA_FECHAMENTO = '2010' AND F.MM_FECHAMENTO = '01' AND F.VL_SALDO_ANT > 0;

	INSERT INTO public.contacontabilsaldo
	(	id,
		datacriacao, 
		dataedicao, 
		version, 
		datareferencia, 
		valor,             
		contacontabil_id,
		depreciacaoacumulada,
		depreciacaomensal,
		reavaliacaoperiodo,
		reavaliacaoacumulada,
		reducaoperiodo,
		reducaoacumulada		
	)
	SELECT
		NEXTVAL('hibernate_sequence'),
		LOCALTIMESTAMP,
		LOCALTIMESTAMP,
		0,
		TO_TIMESTAMP('20091201','YYYYMMDD')::timestamp without time zone,
		0,
		C.ID,
		0,
		0,
		0,
		0,
		0,
		0
	FROM PUBLIC.CONTACONTABIL C 
	WHERE C.ID NOT IN (SELECT CONTACONTABIL_ID FROM PUBLIC.CONTACONTABILSALDO)
	  AND C.DOMINIOTIPOMATERIAL_ID = (SELECT ID FROM PUBLIC.DOMINIO WHERE CHAVE='tipoMaterial' AND CODIGO=1);
COMMIT;

-- ############     ))) RODAR PARA MES NAO CONTEMPLADO (((      ##########
-- ############ SE A INSERCAO_CONTACONTABILSALDO FOI EXECUTADA  ##########
-- ############                                                 ##########
-- #INI :: GERACAO DE SALDOS COM DADADOS DEPRECIACAO >> CONTACONTABILSALDO
    /*
      SCRIPT QUE GERA O SALDO
      =======================
      1. Definir intervalo referencia (v_dtaini_ref/v_dtafin_ref) com o mês
         a partir do qual se deseja gerar os saldos, por exemplo: JAN-2016.
      2. Definir intervalo anterior (v_dtaini_ant e v_dtafin_ant) com o mês
         com saldo anterior, por exemplo: DEZ-2015, lembrando que os saldos
         ja devem estar gerados para esse mes.
      3. Definir v_anomes_fin como o ultimo mes de referencia fechado.
    */
    DO $$
    DECLARE
        v_moventOrcamentaria       BIGINT;
        v_moventExtraOrcamentaria  BIGINT;
        v_movbai        BIGINT;
        v_movbaiEo      BIGINT;
        v_matcons       BIGINT;
        v_dtaini_ant    TIMESTAMP WITHOUT TIME ZONE;
        v_dtafin_ant    TIMESTAMP WITHOUT TIME ZONE;
        v_dtaini_ref    TIMESTAMP WITHOUT TIME ZONE;
        v_dtafin_ref    TIMESTAMP WITHOUT TIME ZONE;
        v_anomes_fin    TIMESTAMP WITHOUT TIME ZONE;
        v_ccmId         BIGINT;
        r               RECORD;
        v_anomes        CHAR(6);
    BEGIN
        SELECT ID INTO v_moventOrcamentaria
          FROM PUBLIC.DOMINIO 
         WHERE CHAVE  = 'tipoMovimentoContaContabil' 
           AND CODIGO = 1;
           
        SELECT ID INTO v_moventExtraOrcamentaria
          FROM PUBLIC.DOMINIO 
         WHERE CHAVE  = 'tipoMovimentoContaContabil' 
           AND CODIGO = 3;         
        
        SELECT ID INTO v_movbai
          FROM PUBLIC.DOMINIO
         WHERE CHAVE  = 'tipoMovimentoContaContabil'
           AND CODIGO = 2;
           
        SELECT ID INTO v_movbaiEo
          FROM PUBLIC.DOMINIO
         WHERE CHAVE  = 'tipoMovimentoContaContabil'
           AND CODIGO = 4;      
        
        SELECT ID INTO v_matcons
          FROM PUBLIC.DOMINIO
         WHERE CHAVE  = 'tipoMaterial'
           AND CODIGO = 1;
        
        v_anomes_fin := TO_TIMESTAMP('20160201','YYYYMMDD')::timestamp without time zone;
        
        v_dtaini_ant := TO_TIMESTAMP('20091201','YYYYMMDD')::timestamp without time zone;
        v_dtafin_ant := v_dtaini_ant + interval '1 month' - interval '1 second';
        
        v_dtaini_ref := TO_TIMESTAMP('20100101','YYYYMMDD')::timestamp without time zone;
        v_dtafin_ref := v_dtaini_ref + interval '1 month' - interval '1 second';
        
        LOOP 
            v_anomes = TO_CHAR(v_dtaini_ref, 'YYYYMM');
            
            RAISE NOTICE 'AnoMes %d', v_anomes;      
            
            FOR R IN 
                SELECT CONTACONTABIL.ID
                     , CONTACONTABIL.CODIGO AS CONTA
                     , coalesce(SALDO.VALOR, 0)          AS SALDOANTERIOR
                     , COALESCE(
                         (SELECT SUM(M.VALOR) AS ENTRADATOTAL 
                            FROM CONTACONTABILMOVIMENTO M
                           WHERE CONTACONTABIL_ID = CONTACONTABIL.ID 
                             AND M.DATAREFERENCIA BETWEEN v_dtaini_ref AND v_dtafin_ref
                             AND TIPOMOVIMENTOCONTACONTABIL_ID in (v_moventOrcamentaria, v_moventExtraOrcamentaria))
                         , 0) AS ENTRADAGRP
                     , COALESCE(
                         (SELECT SUM(M.VALOR) AS SAIDA 
                            FROM CONTACONTABILMOVIMENTO M 
                           WHERE CONTACONTABIL_ID = CONTACONTABIL.ID
                             AND M.DATAREFERENCIA BETWEEN v_dtaini_ref AND v_dtafin_ref
                             AND TIPOMOVIMENTOCONTACONTABIL_ID in (v_movbai, v_movbaiEo))
                         , 0) AS SAIDAGRP
                FROM  CONTACONTABIL
                LEFT JOIN CONTACONTABILSALDO SALDO ON (SALDO.CONTACONTABIL_ID = CONTACONTABIL.ID AND SALDO.DATAREFERENCIA BETWEEN v_dtaini_ant AND v_dtafin_ant)
                WHERE CONTACONTABIL.DATAINATIVO IS NULL
                AND DOMINIOTIPOMATERIAL_ID = v_matcons
                ORDER BY CONTACONTABIL.ID
            LOOP
                RAISE NOTICE 'contacontabil codigo: %D', R.CONTA;
                      
                SELECT NEXTVAL('hibernate_sequence') INTO v_ccmId;
          
                INSERT INTO public.contacontabilsaldo
                     ( id
                     , datacriacao
                     , dataedicao
                     , version
                     , datareferencia
                     , valor
                     , contacontabil_id
                     , depreciacaoacumulada
                     , depreciacaomensal
                     , reavaliacaoperiodo
                     , reavaliacaoacumulada
                     , reducaoperiodo
                     , reducaoacumulada               
                     )
                VALUES
                     ( v_ccmId
                     , LOCALTIMESTAMP
                     , LOCALTIMESTAMP
                     , 0
                     , v_dtaini_ref
                     , (R.SALDOANTERIOR+R.ENTRADAGRP)+R.SAIDAGRP
                     , R.ID
                     , 0
                     , 0
                     , 0
                     , 0
                     , 0
                     , 0
                     );
            END LOOP;

            IF DATE_TRUNC('month',v_dtaini_ref) = DATE_TRUNC('month', v_anomes_fin) THEN 
                -- Quando termina de gerar os saldos eu atribuo o último no contacontabilsaldoanterior_id
                -- na tabela contacontabil (necessário para o RMB e fechamento de mês)
                UPDATE PUBLIC.CONTACONTABIL C
                    SET CONTACONTABILSALDOANTERIOR_ID = 
                        ( SELECT S.ID FROM PUBLIC.CONTACONTABILSALDO S 
                        WHERE S.CONTACONTABIL_ID = C.ID 
                        ORDER BY DATAREFERENCIA DESC LIMIT 1 );
                RETURN;
            END IF;

           v_dtaini_ref := v_dtaini_ref + interval '1 month';
           v_dtafin_ref := v_dtaini_ref + interval '1 month' - interval '1 second';

           v_dtaini_ant := v_dtaini_ant + interval '1 month';
           v_dtafin_ant := v_dtaini_ant + interval '1 month' - interval '1 second';

      END LOOP;          
    END$$; 
-- #INI :: GERACAO DE SALDOS COM DADADOS DEPRECIACAO >> CONTACONTABILSALDO


BEGIN;  -- #INI :: INCLUI AS CONTAS SEM SALDO EM CADA REFERENCIA >> CONTACONTABILSALDO
  /*  DO $$
    DECLARE
        contas RECORD;
        v_tipoMat int;
        v_dataIni date;
        v_dataFin date;
        v_dataRef date;
        v_tipo int;
    BEGIN
        --> RECUPERA O DOMINIO DAS CONTAS DE MATERIAL DE CONSUMO
        SELECT ID INTO v_tipo
          FROM PUBLIC.DOMINIO 
         WHERE CHAVE='tipoMaterial'
           AND CODIGO=1;

        --> RECUPERA O PRIMEIRO MES DE REFERENCIA DAS CONTAS DE MATERIAL DE CONSUMO
        SELECT MIN(datareferencia) INTO v_dataIni
          FROM PUBLIC.CONTACONTABILSALDO;

        --> INICIALIZA A DATA DE REFERENCIA
        v_dataRef := v_dataIni;

        --> RECUPERA O ULTIMO MES DE REFERENCIA DAS CONTAS DE MATERIAL DE CONSUMO
        SELECT MAX(datareferencia) INTO v_dataFin
          FROM PUBLIC.CONTACONTABILSALDO; 

        WHILE (v_dataRef BETWEEN v_dataIni AND v_dataFin) LOOP
            FOR contas IN SELECT ID FROM public.contacontabil WHERE dominiotipomaterial_id = v_tipo LOOP
                IF (SELECT ID FROM public.contacontabilsaldo WHERE contacontabil_id=contas.id AND datareferencia=v_dataRef) IS NULL THEN
                    INSERT INTO public.contacontabilsaldo
                         ( 
                           id, datacriacao, dataedicao, 
                           version, datareferencia, valor, contacontabil_id, depreciacaoacumulada, depreciacaomensal,
                           reavaliacaoperiodo, reavaliacaoacumulada, reducaoperiodo, reducaoacumulada    
                         )
                    VALUES 
                         ( 
                           NEXTVAL('hibernate_sequence'), LOCALTIMESTAMP, LOCALTIMESTAMP, 0,
                           v_dataRef, 0.0, contas.id, 0, 0, 0, 0, 0, 0
                         );
                END IF;
            END LOOP;
            v_dataRef := v_dataRef + interval '1 month';
        END LOOP;
    END;
    $$ LANGUAGE plpgsql; */
COMMIT; -- #FIM :: INCLUI AS CONTAS SEM SALDO EM CADA REFERENCIA >> CONTACONTABILSALDO



--===========================================================================--
-- ##INI :: IMPORTACAO TABELAS DE MOVIMENTO DE MATERIAS DE CONSUMO           --
--===========================================================================--