Merge pull request #71 from unb-mds/entradas_retornos_back

Entradas retornos back

Back/puxador_bens.py → Back/Puxador_bens.py

@@ -8,7 +8,7 @@ class DateRange(BaseModel):
     published_since: date
     published_until: date
 
-async def puxador_bens1(date_range: DateRange) -> Union[List[Dict[str, Union[str, float]]], int]:
+async def puxador_bens(date_range: DateRange) -> Union[List[Dict[str, Union[str, float]]], int]:
     # Formatando as datas no formato americano
     published_since_str = date_range.published_since.strftime('%Y-%m-%d')
     published_until_str = date_range.published_until.strftime('%Y-%m-%d')

Back/Puxador_compras.py

@@ -0,0 +1,96 @@
+from fastapi import FastAPI
+import requests
+import re
+
+from typing import List, Dict, Union
+from pydantic import BaseModel
+from datetime import date
+
+class DateRange(BaseModel):
+    published_since: date
+    published_until: date
+
+
+async def puxador_compras(date_range: DateRange) -> Union[List[Dict[str, Union[str, float]]], int]:
+    # Formatando as datas no formato americano
+    published_since_str = date_range.published_since.strftime('%Y-%m-%d')
+    published_until_str = date_range.published_until.strftime('%Y-%m-%d')
+    # Fazendo a solicitação GET para a API
+    response = requests.get(
+        f'https://queridodiario.ok.org.br/api/gazettes?territory_ids=5300108&published_since={published_since_str}&published_until={published_until_str}&querystring=%22cujo%20objeto%20%C3%A9%20a%20aquisi%C3%A7%C3%A3o%20do%20item%20identificado%20pelo%20C%C3%B3digo%22&excerpt_size=800&number_of_excerpts=10000&pre_tags=&post_tags=&size=10000&sort_by=ascending_date')
+
+    # Verificando se a solicitação foi bem-sucedida
+    if response.status_code == 200:
+
+        # Convertendo a resposta para JSON
+        dados = response.json()
+
+        # Acessando a lista de gazettes dentro dos dados
+        gazettes = dados['gazettes']
+
+        # Lista para armazenar os dicionários com as informações extraídas
+        results = []
+
+        # Conjunto para armazenar as datas já vistas
+        datas_vistas = set()
+
+        # Iterando sobre cada gazette na lista
+        for gazette in gazettes:
+            # Acessando a data de cada gazette
+            data = gazette['date']
+
+            # Verificando se a data já foi impressa
+            if data not in datas_vistas:
+                # Adicionando a data ao conjunto de datas vistas
+                datas_vistas.add(data)
+
+            # Acessando a lista de excertos de cada gazette
+            excertos = gazette['excerpts']
+            total_diario = 0
+
+            # Iterando sobre cada excerto
+            for excerto in excertos:
+                # Remover quebras de linha no meio das palavras
+                excerto = re.sub(r'(\w)-\n(\w)', r'\1\2', excerto)
+                excerto = excerto.replace('\n', ' ')
+
+                # Usando expressão regular para encontrar a Empresa, Objeto e Valor
+                empresa_match = re.search(r'empresa\s+([\w\s\-ÇçÉéÁáÍíÓóÚúÃãÕõâêîôûÂÊÎÔÛäëïöüÄËÏÖÜ]+)\s+-\s+CNPJ:\s+(\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2})', excerto, re.DOTALL)
+                objeto_match = re.search(r'cujo objeto é a aquisição do item identificado pelo Código SES\s+\d+\s+-\s+([^\n,]+)', excerto, re.DOTALL)
+                valor_match = re.search(r'valor global de R\$ ([\d,.]+)', excerto)
+
+                if empresa_match and objeto_match and valor_match:
+                    # Extraindo a empresa e o CNPJ encontrados
+                    empresa = empresa_match.group(1).strip()
+                    cnpj = empresa_match.group(2).strip()
+
+                    # Extraindo o objeto encontrado e removendo parte desnecessária
+                    objeto = objeto_match.group(1).strip()
+                    objeto = re.sub(r',\s*para atender as necessidades.*', '', objeto)
+
+                    # Extraindo o valor encontrado
+                    valor = valor_match.group(1)
+                    # Removendo caracteres não numéricos, exceto vírgulas e pontos
+                    valor_limpo = re.sub(r'[^\d,.]', '', valor)
+                    # Removendo pontos extras como separadores de milhar
+                    valor_limpo = valor_limpo.replace('.', '')
+                    # Trocando a vírgula por ponto para ter o formato correto para float
+                    valor_limpo = valor_limpo.replace(',', '.')
+                    # Convertendo o valor para float
+                    valor_float = float(valor_limpo)
+                    total_diario += valor_float
+
+                    # Adicionando as informações à lista de resultados
+                    results.append({
+                        "data": data,
+                        "empresa": empresa,
+                        "cnpj": cnpj,
+                        "objeto": objeto,
+                        "valor": valor_float
+                    })
+                    # não adicionei o total diário à lista de resultados pois pode ser facilmente feito pelo front na hora de montar os gráficos.
+                    # mas ficaria assim: results.append({"data": data, "total_diario": total_diario})
+        return results
+    else:
+        # Se a solicitação falhar, retorne o código de status
+        return response.status_code

Back/Puxador_convenio.py

@@ -1,66 +1,90 @@
 import requests
 import re
 
-# Fazendo a solicitação GET para a API
-response = requests.get(
-    'https://queridodiario.ok.org.br/api/gazettes?territory_ids=5300108&published_since=2023-06-26&published_until=2023-06-30&querystring=%22RECONHECIMENTO%20DE%20D%C3%8DVIDA%22&excerpt_size=500&number_of_excerpts=100000&pre_tags=&post_tags=&size=10000&sort_by=descending_date'
-)
+from typing import List, Dict, Union
+from pydantic import BaseModel
+from datetime import date
 
-# Verificando se a solicitação foi bem-sucedida
-if response.status_code == 200:
-    dados = response.json()
-    gazettes = dados.get('gazettes', [])
+class DateRange(BaseModel):
+    published_since: date
+    published_until: date
 
-    datas_vistas = set()
+async def puxador_convenio(date_range: DateRange) -> Union[List[Dict[str, Union[str, float]]], int]:
+    # Formatando as datas no formato americano
+    published_since_str = date_range.published_since.strftime('%Y-%m-%d')
+    published_until_str = date_range.published_until.strftime('%Y-%m-%d')
 
-    for gazette in gazettes:
-        data = gazette.get('date')
+    # Fazendo a solicitação GET para a API
+    response = requests.get(
+        F'https://queridodiario.ok.org.br/api/gazettes?territory_ids=5300108&published_since=2023-06-26&published_until=2023-06-30&querystring=%22RECONHECIMENTO%20DE%20D%C3%8DVIDA%22&excerpt_size=500&number_of_excerpts=100000&pre_tags=&post_tags=&size=10000&sort_by=descending_date'
+    )
 
-        # Verifica se a data está presente e não é uma string vazia
-        if data and data not in datas_vistas:
-            print("\nData:", data)
-            datas_vistas.add(data)
+    # Verificando se a solicitação foi bem-sucedida
+    if response.status_code == 200:
+        dados = response.json()
+        gazettes = dados.get('gazettes', [])
+
+        # Lista para armazenar os dicionários com as informações extraídas
+        results = []
 
-            excertos = gazette.get('excerpts', [])
-            total_diario = 0
+        datas_vistas = set()
 
-            for excerto in excertos:
-                # Normalizando o texto para facilitar a extração
-                excerto = excerto.replace('\n', ' ').replace('\r', ' ')
+        for gazette in gazettes:
+            data = gazette.get('date')
 
-                # Ajustando regex para capturar corretamente o interessado e valor
-                interessado_match = re.search(
-                    r'(?:Interessado:\s*|\bem\s+favor\s+da\s+empresa\s+)([^\.,\n]+(?:[^\.,\n]+)*)',
-                    excerto, re.IGNORECASE)
-                valor_match = re.search(
-                    r'Valor:\s*R\$(.*?[\d,.]+)|(?:no\s+valor\s+total\s+de\s+R\$(.*?[\d,.]+))',
-                    excerto, re.IGNORECASE)
+            # Verifica se a data está presente e não é uma string vazia
+            if data and data not in datas_vistas:
+                datas_vistas.add(data)
 
-                if interessado_match and valor_match:
-                    interessado = interessado_match.group(1).strip()
+                excertos = gazette.get('excerpts', [])
+                total_diario = 0
 
-                    if valor_match.group(1):
-                        valor = valor_match.group(1).strip()
-                    else:
-                        valor = valor_match.group(2).strip()
+                for excerto in excertos:
+                    # Normalizando o texto para facilitar a extração
+                    excerto = excerto.replace('\n', ' ').replace('\r', ' ')
 
-                    # Limpeza do valor
-                    valor_limpo = re.sub(r'[^\d,]', '',
-                                         valor)  # Remove todos os caracteres não numéricos, exceto vírgula
-                    valor_limpo = valor_limpo.replace('.', '', valor_limpo.count(
-                        ',') - 1)  # Remove pontos de milhar, mantém apenas o último
-                    valor_limpo = valor_limpo.replace(',', '.')  # Substitui vírgula por ponto decimal
+                    # Ajustando regex para capturar corretamente o interessado e valor
+                    interessado_match = re.search(
+                        r'(?:Interessado:\s*|\bem\s+favor\s+da\s+empresa\s+)([^\.,\n]+(?:[^\.,\n]+)*)',
+                        excerto, re.IGNORECASE)
+                    valor_match = re.search(
+                        r'Valor:\s*R\$(.*?[\d,.]+)|(?:no\s+valor\s+total\s+de\s+R\$(.*?[\d,.]+))',
+                        excerto, re.IGNORECASE)
 
-                    try:
-                        valor_float = float(valor_limpo)
-                    except ValueError:
-                        print(f"Erro ao converter o valor '{valor_limpo}' para float.")
-                        valor_float = 0.0
+                    if interessado_match and valor_match:
+                        interessado = interessado_match.group(1).strip()
 
-                    total_diario += valor_float
+                        if valor_match.group(1):
+                            valor = valor_match.group(1).strip()
+                        else:
+                            valor = valor_match.group(2).strip()
 
-                    print(f"Interessado: {interessado}\nValor: R${valor_float:.2f}")
-
-            print(f'Dívidas totais = R${total_diario:.2f}')
-else:
-    print("Erro:", response.status_code)
+                        # Limpeza do valor
+                        valor_limpo = re.sub(r'[^\d,]', '',
+                                             valor)  # Remove todos os caracteres não numéricos, exceto vírgula
+                        valor_limpo = valor_limpo.replace('.', '', valor_limpo.count(
+                            ',') - 1)  # Remove pontos de milhar, mantém apenas o último
+                        valor_limpo = valor_limpo.replace(',', '.')  # Substitui vírgula por ponto decimal
+
+                        try:
+                            valor_float = float(valor_limpo)
+                            total_diario += valor_float
+                            erro = False
+                        except ValueError:
+                            valor_float = None
+                            erro = True
+
+                        # Adiciona os dados à lista de resultados e agora ele informa se hove erro e passa o valor_limpo sem conversão de float.
+                        results.append({
+                            'data': data,
+                            'interessado': interessado,
+                            'valor': valor_float,
+                            'valor_limpo': valor_limpo,
+                            'erro': erro
+                        })
+                        # não adicionei o total diario mas ele pode ser facilmente implementado aqui ou no front.
+
+        return results
+    else:
+        # Se a solicitação falhar, retorne o código de status
+        return response.status_code

Back/Puxador_credito.py

@@ -1,67 +1,85 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
 import requests
 import re
+from typing import List, Dict, Union
+from pydantic import BaseModel
+from datetime import date
 
-# Fazendo a solicitação GET para a API
-response = requests.get(
-    'https://queridodiario.ok.org.br/api/gazettes?territory_ids=5300108&published_since=2024-04-01&published_until=2024-06-01&querystring=%22Abre%20cr%C3%A9dito%20suplementar%22&excerpt_size=120&number_of_excerpts=100000&pre_tags=&post_tags=&size=10000&sort_by=descending_date')
+class DateRange(BaseModel):
+    published_since: date
+    published_until: date
 
-# Verificando se a solicitação foi bem-sucedida
-if response.status_code == 200:
-    # Convertendo a resposta para JSON
-    dados = response.json()
+async def puxador_credito(date_range: DateRange) -> Union[List[Dict[str, Union[str, float]]], int]:
+    # Formatando as datas no formato americano
+    published_since_str = date_range.published_since.strftime('%Y-%m-%d')
+    published_until_str = date_range.published_until.strftime('%Y-%m-%d')
 
-    # Acessando a lista de gazettes dentro dos dados
-    gazettes = dados['gazettes']
+    # Fazendo a solicitação GET para a API
+    response = requests.get(
+        f'https://queridodiario.ok.org.br/api/gazettes?territory_ids=5300108&published_since={published_since_str}&published_until={published_until_str}&querystring=%22Abre%20cr%C3%A9dito%20suplementar%22&excerpt_size=120&number_of_excerpts=100000&pre_tags=&post_tags=&size=10000&sort_by=descending_date')
 
-    # Conjunto para armazenar as datas já vistas
-    datas_vistas = set()
+    # Verificando se a solicitação foi bem-sucedida
+    if response.status_code == 200:
+        # Convertendo a resposta para JSON
+        dados = response.json()
 
-    # Iterando sobre cada gazette na lista
-    for gazette in gazettes:
-        # Acessando a data de cada gazette
-        data = gazette['date']
-        # url para o pdf do diario oficial
-        url = gazette['url']
+        # Acessando a lista de gazettes dentro dos dados
+        gazettes = dados['gazettes']
+
+        # Lista para armazenar os dicionários com as informações extraídas
+        results = []
 
-        # Verificando se a data já foi impressa
-        if data not in datas_vistas:
-            print("\nData:", data)
-            print("Diario oficial:", url)
-            # Adicionando a data ao conjunto de datas vistas
-            datas_vistas.add(data)
+        # Conjunto para armazenar as datas já vistas
+        datas_vistas = set()
 
-        # Acessando a lista de excertos de cada gazette
-        excertos = gazette['excerpts']
+        # Iterando sobre cada gazette na lista
+        for gazette in gazettes:
+            # Acessando a data de cada gazette
+            data = gazette['date']
+            # url para o pdf do diario oficial
+            url = gazette['url']
 
+            # Verificando se a data já foi impressa
+            if data not in datas_vistas:
+                # Adicionando a data ao conjunto de datas vistas
+                datas_vistas.add(data)
 
-        # Iterando sobre cada excerto
-        for excerto in excertos:
-            # Substituindo quebras de linha múltiplas por um único espaço
-            excerto = re.sub(r'\s+', ' ', excerto)
+            # Acessando a lista de excertos de cada gazette
+            excertos = gazette['excerpts']
 
-            # Usando expressão regular para encontrar o Decreto e Valor
-            decreto_match = re.search(r'DECRETO\s*N[ºo]\s*([\d.]+)', excerto, re.IGNORECASE)
-            valor_match = re.search(r'valor\s*de\s*R\$\s*([\d,.]+)', excerto, re.IGNORECASE)
 
-            if decreto_match and valor_match:
-                # Extraindo o decreto encontrado
-                decreto = decreto_match.group(1).strip()
+            # Iterando sobre cada excerto
+            for excerto in excertos:
+                # Substituindo quebras de linha múltiplas por um único espaço
+                excerto = re.sub(r'\s+', ' ', excerto)
 
-                # Extraindo o valor encontrado
-                valor = valor_match.group(1)
-                # Removendo caracteres não numéricos, exceto vírgulas e pontos
-                valor_limpo = re.sub(r'[^\d,.]', '', valor)
-                # Removendo pontos extras como separadores de milhar
-                valor_limpo = valor_limpo.replace('.', '')
-                # Trocando a vírgula por ponto para ter o formato correto para float
-                valor_limpo = valor_limpo.replace(',', '.')
-                # Convertendo o valor para float
-                valor_float = float(valor_limpo)
+                # Usando expressão regular para encontrar o Decreto e Valor
+                decreto_match = re.search(r'DECRETO\s*N[ºo]\s*([\d.]+)', excerto, re.IGNORECASE)
+                valor_match = re.search(r'valor\s*de\s*R\$\s*([\d,.]+)', excerto, re.IGNORECASE)
 
-                print(f"Decreto: {decreto}, Valor: R${valor_float:.2f}")
+                if decreto_match and valor_match:
+                    # Extraindo o decreto encontrado
+                    decreto = decreto_match.group(1).strip()
 
-else:
-    # Se a solicitação falhar, imprima o código de status
-    print("Erro:", response.status_code)
+                    # Extraindo o valor encontrado
+                    valor = valor_match.group(1)
+                    # Removendo caracteres não numéricos, exceto vírgulas e pontos
+                    valor_limpo = re.sub(r'[^\d,.]', '', valor)
+                    # Removendo pontos extras como separadores de milhar
+                    valor_limpo = valor_limpo.replace('.', '')
+                    # Trocando a vírgula por ponto para ter o formato correto para float
+                    valor_limpo = valor_limpo.replace(',', '.')
+                    # Convertendo o valor para float
+                    valor_float = float(valor_limpo)
+
+                    results.append({
+                        "data": data,
+                        "decreto": decreto,
+                        "valor": valor_float
+                    })
+
+
+        return results
+    else:
+        # Se a solicitação falhar, retorne o código de status
+        return response.status_code