From 5e53c09c23857b279fe3b37cb09d4164cbf24b90 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 1/8] =?UTF-8?q?Soma=20parcelas=20confirmadas=20nas=20consu?= =?UTF-8?q?ltas=20de=20m=C3=A9tricas=20parciais?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reutiliza a seleção diária das extensões nos quatro contadores. Meses completos usam os totais mensais, sem somar as mesmas parcelas duas vezes; consultas sem cobertura conservam as somas anteriores. --- counter_api/query.py | 16 ++++++++-------- counter_api/tests/test_query.py | 23 +++++++++++++++++++++++ 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/counter_api/query.py b/counter_api/query.py index 466a002..58586f4 100644 --- a/counter_api/query.py +++ b/counter_api/query.py @@ -5,6 +5,7 @@ from counter_api.constants import COMPOSITE_PAGE_SIZE from counter_api.exceptions import incongruous_filter, invalid_filter +from counter_api.extensions.coverage import metric_sum from counter_api.identifiers import ITEM_ID_FIELDS from counter_api.metadata import fetch_metadata from counter_api.search import composite_pages, search @@ -237,14 +238,13 @@ def _query_body(self, months, after, report_id, params=None): "rows": { "composite": composite, "aggs": { - "total_requests": {"sum": {"field": "total_requests"}}, - "total_investigations": { - "sum": {"field": "total_investigations"} - }, - "unique_requests": {"sum": {"field": "unique_requests"}}, - "unique_investigations": { - "sum": {"field": "unique_investigations"} - }, + metric: {"sum": metric_sum(metric, params.get("coverage"))} + for metric in ( + "total_requests", + "total_investigations", + "unique_requests", + "unique_investigations", + ) }, } }, diff --git a/counter_api/tests/test_query.py b/counter_api/tests/test_query.py index 0dd798e..4be5efb 100644 --- a/counter_api/tests/test_query.py +++ b/counter_api/tests/test_query.py @@ -55,6 +55,29 @@ def test_platform_query_groups_by_data_type_not_items(self): self.assertIn("data_type", fields) self.assertIn("month", fields) + def test_partial_metrics_use_confirmed_days_without_changing_default_sums(self): + query = ReportQuery(Mock(client=Mock())) + months = [date(2024, 1, 1), date(2024, 2, 1)] + + coverage = { + "basis": "confirmed_days", + "months": [ + {"month": "2024-01", "complete_month": True, "confirmed_days": [1]}, + {"month": "2024-02", "complete_month": False, "confirmed_days": [1, 3]}, + ], + } + + body = query._query_body(months, None, "tr", {"coverage": coverage}) + for metric, aggregation in body["aggs"]["rows"]["aggs"].items(): + params = aggregation["sum"]["script"]["params"] + self.assertEqual(params["metric"], metric) + self.assertEqual(params["complete"], ["2024-01"]) + self.assertEqual(params["days"], {"2024-02": ["01", "03"]}) + + default = query._query_body(months, None, "tr") + for metric, aggregation in default["aggs"]["rows"]["aggs"].items(): + self.assertEqual(aggregation, {"sum": {"field": metric}}) + def test_query_applies_access_filters_before_aggregation(self): query = ReportQuery(Mock(client=Mock())) From 041d96f6b320add9123f601bb5e9c4649b0ae020 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 2/8] =?UTF-8?q?Gera=20relat=C3=B3rios=20provis=C3=B3rios?= =?UTF-8?q?=20a=20partir=20dos=20dias=20confirmados?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Acrescenta um modo interno provisório ao gerador compartilhado, com seleção temporal, cobertura e avisos. O caminho padrão permanece restrito aos meses completos e mantém as validações de livros. --- counter_api/generation.py | 46 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 43 insertions(+), 3 deletions(-) diff --git a/counter_api/generation.py b/counter_api/generation.py index 65c1f63..b3a974b 100644 --- a/counter_api/generation.py +++ b/counter_api/generation.py @@ -1,19 +1,49 @@ +from datetime import date + from counter_api.availability import split_period from counter_api.exceptions import CounterAPIError, service_unavailable +from counter_api.extensions.coverage import coverage_fields, resolve_coverage from counter_api.integrity import metric_invariant_errors from counter_api.parameters import parse_parameters, report_parameters from counter_api.query import ReportQuery from counter_api.reports import build_report -def generate_report(report_id, platform, begin, end, query_params): - months, pending, unavailable = split_period(platform, begin, end) +def generate_report( + report_id, platform, begin, end, query_params, *, provisional=False +): + query = ReportQuery() + coverage = None + + if provisional: + coverage = resolve_coverage( + query.client, platform, begin, end, "allow_partial", False, query.deadline + ) + months = [ + date.fromisoformat(f"{month}-01") for month in coverage["included_months"] + ] + pending = [ + date.fromisoformat(f"{item['month']}-01") + for item in coverage["months"] + if not item["complete_month"] and item["status"] != "future" + ] + unavailable = [] + + query_params = { + key: value + for key, value in query_params.items() + if key != "coverage_policy" + } + else: + months, pending, unavailable = split_period(platform, begin, end) + params = parse_parameters(query_params, report_id) params["pending_months"] = pending params["unavailable_months"] = unavailable report_params = report_parameters(report_id, params) - query = ReportQuery() + if coverage is not None: + report_params["coverage"] = coverage if params.get("Item_ID"): try: @@ -51,4 +81,14 @@ def generate_report(report_id, platform, begin, end, query_params): if errors: raise service_unavailable(f"Book metrics inconsistent: {errors[0]}") + if coverage is not None: + payload.update(coverage_fields(coverage)) + payload["provisional"] = True + payload["Report_Header"]["Report_Name"] += " — Usage provisional report" + payload["warnings"].insert( + 0, + "Usage provisional report, not a COUNTER-compliant report. " + "Counts may change as processing completes.", + ) + return payload, query.deadline From 737a3cc58aee0ba0b3a72a31b2ab51f14da1d785 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 3/8] =?UTF-8?q?Permite=20especializar=20per=C3=ADodo=20e?= =?UTF-8?q?=20gera=C3=A7=C3=A3o=20na=20view=20de=20relat=C3=B3rios?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Oferece pontos de extensão para o parser, o gerador e o prefixo dos downloads. Preserva os componentes e nomes de arquivo usados pela rota COUNTER oficial. --- counter_api/views.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/counter_api/views.py b/counter_api/views.py index 5b9ae36..e272e95 100644 --- a/counter_api/views.py +++ b/counter_api/views.py @@ -149,6 +149,10 @@ def get(self, request): class ReportView(CounterAPIView): + period_parser = None + report_generator = None + filename_prefix = "" + @extend_schema( tags=["Reports"], auth=[], @@ -166,6 +170,7 @@ def get(self, request, report_id): try: validate_customer(request.query_params) platform = get_platform(request.query_params.get("platform")) + definition = REPORTS.get(report_id) if ( not definition @@ -173,8 +178,10 @@ def get(self, request, report_id): ): return Response({}, status=404) - begin, end = parse_period(request.query_params) - payload, deadline = generate_report( + period_parser = self.period_parser or parse_period + report_generator = self.report_generator or generate_report + begin, end = period_parser(request.query_params) + payload, deadline = report_generator( report_id, platform, begin, @@ -193,8 +200,8 @@ def get(self, request, report_id): response = FileResponse(content, content_type=content_type) filename = ( - f"{report_id}_{platform.acron3}_{begin:%Y%m}_{end:%Y%m}." - f"{output_format}" + f"{self.filename_prefix}{report_id}_{platform.acron3}_" + f"{begin:%Y%m}_{end:%Y%m}.{output_format}" ) response["Content-Disposition"] = f'attachment; filename="{filename}"' From 490806fc512bd245322a9da9d515e4b94f94b2ba Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 4/8] =?UTF-8?q?Inclui=20cobertura=20e=20avisos=20nos=20dow?= =?UTF-8?q?nloads=20provis=C3=B3rios?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Exporta a cobertura em uma aba do Excel e em uma seção após os dados no TSV, inclusive sem itens. Os downloads COUNTER padrão não recebem essas seções. --- counter_api/tabular.py | 53 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/counter_api/tabular.py b/counter_api/tabular.py index c4f35ef..501cdad 100644 --- a/counter_api/tabular.py +++ b/counter_api/tabular.py @@ -1,7 +1,9 @@ import csv +import json from codecs import BOM_UTF8 from datetime import date from io import StringIO +from itertools import chain from tempfile import SpooledTemporaryFile from time import monotonic @@ -57,6 +59,11 @@ def build_workbook(report, deadline=None): sheet.append(row) + if report.get("provisional"): + coverage_sheet = workbook.create_sheet(title="Coverage") + for row in _coverage_rows(report): + coverage_sheet.append(row) + output = SpooledTemporaryFile(max_size=SPOOL_SIZE) if deadline and monotonic() >= deadline: workbook.close() @@ -75,7 +82,7 @@ def build_tsv(report, deadline=None): line = StringIO(newline="") writer = csv.writer(line, delimiter="\t", lineterminator="\n") - for row in _report_rows(report): + for row in chain(_report_rows(report), _coverage_rows(report)): if deadline and monotonic() >= deadline: output.close() raise service_unavailable() @@ -90,6 +97,50 @@ def build_tsv(report, deadline=None): return output +def _coverage_rows(report): + if not report.get("provisional"): + return + + coverage = report["coverage"] + yield () + yield ("Usage_Coverage", "Provisional, not a COUNTER-compliant report") + yield ("Policy", coverage["policy"]) + yield ("Status", coverage["status"]) + yield ("Basis", coverage["basis"]) + + for warning in report["warnings"]: + yield ("Warning", warning) + + yield ( + "Month", + "Status", + "Included", + "Complete_Month", + "Requested_Days", + "Confirmed_Days", + "Missing_Days", + "Future_Days", + ) + + included = set(coverage["included_months"]) + for month in coverage["months"]: + yield ( + month["month"], + month["status"], + month["month"] in included, + month["complete_month"], + *( + json.dumps(month[field], separators=(",", ":")) + for field in ( + "requested_days", + "confirmed_days", + "missing_days", + "future_days", + ) + ), + ) + + def _report_rows(report): header = report["Report_Header"] yield from ( From 11b9c5eaa951fbb0de8acb011cd2d0ab58347a40 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 5/8] =?UTF-8?q?Adiciona=20a=20rota=20de=20relat=C3=B3rios?= =?UTF-8?q?=20sempre=20parciais?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Expõe /r51/extensions/reports/ sem exigir coverage_policy e rejeita strict. Centraliza datas e schema nos módulos correspondentes e reutiliza a view e o gerador existentes, preservando acesso e quotas. --- counter_api/extensions/dates.py | 17 +++++++++++++- counter_api/extensions/openapi.py | 8 +++++++ counter_api/extensions/reports.py | 37 +++++++++++++++++++++++++++++++ counter_api/extensions/urls.py | 6 +++++ counter_api/tests/test_access.py | 1 + counter_api/tests/test_http.py | 1 + 6 files changed, 69 insertions(+), 1 deletion(-) create mode 100644 counter_api/extensions/reports.py diff --git a/counter_api/extensions/dates.py b/counter_api/extensions/dates.py index aadcb49..ac5623c 100644 --- a/counter_api/extensions/dates.py +++ b/counter_api/extensions/dates.py @@ -2,11 +2,26 @@ from datetime import date from counter_api.dates import parse_period_inputs -from counter_api.exceptions import invalid_dates +from counter_api.exceptions import insufficient_information, invalid_dates from counter_api.extensions.contracts import SEGMENT_DIMENSIONS from counter_api.extensions.query import validate_segmented_period +def parse_provisional_period(params): + if params.get("coverage_policy", "allow_partial") != "allow_partial": + raise insufficient_information("Provisional reports only support allow_partial") + + begin, end = parse_period_inputs(params) + if begin.day != 1 or end.day != monthrange(end.year, end.month)[1]: + raise invalid_dates("Provisional reports require full calendar months") + + today = date.today() + if begin > today or end.year > today.year: + raise invalid_dates("Period must start by today and end by the current year") + + return begin, end + + def parse_analytics_period(params): begin, end = parse_period_inputs(params) today = date.today() diff --git a/counter_api/extensions/openapi.py b/counter_api/extensions/openapi.py index eef6c73..4cb4659 100644 --- a/counter_api/extensions/openapi.py +++ b/counter_api/extensions/openapi.py @@ -1,5 +1,7 @@ from rest_framework import serializers +from counter_api.openapi import CounterReportSerializer + class RankingItemSerializer(serializers.Serializer): id = serializers.CharField() @@ -46,6 +48,12 @@ class CoverageSerializer(serializers.Serializer): months = CoverageMonthSerializer(many=True) +class ProvisionalReportSerializer(CounterReportSerializer): + provisional = serializers.BooleanField() + coverage = CoverageSerializer() + warnings = serializers.ListField(child=serializers.CharField()) + + class CoverageResponseSerializer(serializers.Serializer): coverage = CoverageSerializer(required=False) warnings = serializers.ListField(child=serializers.CharField(), required=False) diff --git a/counter_api/extensions/reports.py b/counter_api/extensions/reports.py new file mode 100644 index 0000000..055e39a --- /dev/null +++ b/counter_api/extensions/reports.py @@ -0,0 +1,37 @@ +from functools import partial + +from drf_spectacular.utils import extend_schema, extend_schema_view + +from counter_api.extensions.dates import parse_provisional_period +from counter_api.extensions.openapi import ProvisionalReportSerializer +from counter_api.generation import generate_report +from counter_api.openapi import REPORT_PARAMETERS, REPORT_RESPONSES +from counter_api.views import ReportView + + +@extend_schema_view( + get=extend_schema( + tags=["SciELO extensions"], + operation_id="extension_provisional_report", + summary="Generate a provisional Usage report with monthly coverage", + description=( + "Not a COUNTER-compliant report. Reuses PR, TR, TR_J3, TR_B3 and IR " + "filters and formats. Always includes confirmed daily contributions " + "in incomplete months, including the current month. No coverage_policy " + "parameter is needed; strict and invalid values are rejected. Periods must span " + "full calendar months; future months through December of the current " + "year are coverage-only, never zero usage. Coverage describes collection " + "processing, not completeness of the source. JSON, XLSX and TSV retain " + "coverage and warnings. Standard COUNTER routes are unchanged." + ), + parameters=REPORT_PARAMETERS, + responses={ + **REPORT_RESPONSES, + (200, "application/json"): ProvisionalReportSerializer, + }, + ) +) +class ProvisionalReportView(ReportView): + period_parser = staticmethod(parse_provisional_period) + report_generator = staticmethod(partial(generate_report, provisional=True)) + filename_prefix = "provisional_" diff --git a/counter_api/extensions/urls.py b/counter_api/extensions/urls.py index 500e8d2..0af8cf9 100644 --- a/counter_api/extensions/urls.py +++ b/counter_api/extensions/urls.py @@ -1,8 +1,14 @@ from django.urls import path +from counter_api.extensions.reports import ProvisionalReportView from counter_api.extensions.views import CapabilitiesView, DistributionView, RankingView urlpatterns = [ + path( + "reports/", + ProvisionalReportView.as_view(), + name="extension-provisional-report", + ), path("capabilities", CapabilitiesView.as_view(), name="extension-capabilities"), path("distribution", DistributionView.as_view(), name="extension-distribution"), path("ranking", RankingView.as_view(), name="extension-ranking"), diff --git a/counter_api/tests/test_access.py b/counter_api/tests/test_access.py index 36ef023..20d37a4 100644 --- a/counter_api/tests/test_access.py +++ b/counter_api/tests/test_access.py @@ -24,6 +24,7 @@ "/r51/extensions/capabilities", "/r51/extensions/ranking", "/r51/extensions/distribution", + "/r51/extensions/reports/tr", ) diff --git a/counter_api/tests/test_http.py b/counter_api/tests/test_http.py index 364f6ca..675e6e4 100644 --- a/counter_api/tests/test_http.py +++ b/counter_api/tests/test_http.py @@ -114,6 +114,7 @@ def test_swagger_and_schema_are_public_and_limited_to_counter(self): "/r51/extensions/capabilities", "/r51/extensions/distribution", "/r51/extensions/ranking", + "/r51/extensions/reports/{report_id}", }, ) self.assertFalse(payload.get("security")) From b96ecb1266465db6e6b30befcc0c763af6af686f Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 6/8] =?UTF-8?q?Verifica=20a=20sele=C3=A7=C3=A3o=20parcial?= =?UTF-8?q?=20e=20a=20cobertura=20dos=20downloads?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mantém dois testes essenciais para o contrato HTTP: modo parcial implícito, rejeição de políticas incompatíveis e preservação da rota oficial; cobertura e avisos nos arquivos Excel e TSV sem itens. --- counter_api/tests/test_provisional_reports.py | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 counter_api/tests/test_provisional_reports.py diff --git a/counter_api/tests/test_provisional_reports.py b/counter_api/tests/test_provisional_reports.py new file mode 100644 index 0000000..e91844d --- /dev/null +++ b/counter_api/tests/test_provisional_reports.py @@ -0,0 +1,112 @@ +from datetime import date +from io import BytesIO +from unittest.mock import Mock, patch + +from django.test import TestCase +from openpyxl import load_workbook + + +class ProvisionalReportTests(TestCase): + def setUp(self): + platform = Mock(acron3="scl", collection_type="journals") + + self.params = { + "platform": "scl", + "begin_date": "2024-01", + "end_date": "2024-02", + } + self.coverage = { + "policy": "allow_partial", + "status": "partial", + "basis": "confirmed_days", + "included_months": ["2024-01", "2024-02"], + "ongoing": False, + "months": [ + { + "month": month, + "status": "complete" if complete else "partial", + "complete_month": complete, + "ongoing": False, + "requested_days": list(range(1, days + 1)), + "confirmed_days": list(range(1, days + 1)) if complete else [1, 3], + "missing_days": [] + if complete + else [day for day in range(1, days + 1) if day not in (1, 3)], + "future_days": [], + } + for month, days, complete in ( + ("2024-01", 31, True), + ("2024-02", 29, False), + ) + ], + } + + for target, value in ( + ("counter_api.views.get_platform", platform), + ("counter_api.generation.resolve_coverage", self.coverage), + ( + "counter_api.generation.split_period", + ([date(2024, 1, 1)], [date(2024, 2, 1)], []), + ), + ): + mocked = patch(target, return_value=value) + mocked.start() + self.addCleanup(mocked.stop) + + query_patch = patch("counter_api.generation.ReportQuery") + self.query = query_patch.start().return_value + self.addCleanup(query_patch.stop) + self.query.deadline = float("inf") + self.query.fetch.return_value = [] + + def test_partial_selection_preserves_standard_report_behavior(self): + response = self.client.get("/r51/extensions/reports/tr", self.params) + self.assertEqual(response.status_code, 200) + self.assertTrue(response.json()["provisional"]) + self.assertEqual(response.json()["coverage"]["policy"], "allow_partial") + self.assertEqual( + self.query.fetch.call_args.args[1], [date(2024, 1, 1), date(2024, 2, 1)] + ) + self.assertIn("coverage", self.query.fetch.call_args.args[3]) + + response = self.client.get( + "/r51/extensions/reports/tr", + {**self.params, "coverage_policy": "allow_partial"}, + ) + self.assertEqual(response.status_code, 200) + + for policy in ("strict", "invalid"): + with self.subTest(policy=policy): + response = self.client.get( + "/r51/extensions/reports/tr", + {**self.params, "coverage_policy": policy}, + ) + self.assertEqual(response.status_code, 400) + + response = self.client.get("/r51/reports/tr", self.params) + self.assertEqual(response.status_code, 200) + self.assertNotIn("provisional", response.json()) + self.assertEqual(self.query.fetch.call_args.args[1], [date(2024, 1, 1)]) + self.assertNotIn("coverage", self.query.fetch.call_args.args[3]) + + def test_empty_downloads_preserve_partial_coverage_and_warnings(self): + for output_format in ("xlsx", "tsv"): + with self.subTest(output_format=output_format): + response = self.client.get( + "/r51/extensions/reports/tr", + {**self.params, "format": output_format}, + ) + self.assertEqual(response.status_code, 200) + + content = b"".join(response.streaming_content) + if output_format == "xlsx": + workbook = load_workbook(BytesIO(content), read_only=True) + text = str(list(workbook["Coverage"].values)) + workbook.close() + else: + text = content.decode("utf-8-sig") + + self.assertIn("not a COUNTER-compliant report", text) + self.assertIn("2024-02", text) + self.assertIn("partial", text) + self.assertIn("Confirmed_Days", text) From d33e6b16ba7b9a2fcd5038af37aa7f49458303b6 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:46:37 -0300 Subject: [PATCH 7/8] =?UTF-8?q?Documenta=20a=20consulta=20de=20relat=C3=B3?= =?UTF-8?q?rios=20provis=C3=B3rios?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Apresenta a rota sempre parcial, um exemplo sem parâmetro de política e a cobertura dos downloads. Direciona consultas de meses completos à rota COUNTER oficial e detalhes de contrato ao OpenAPI. --- README.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/README.md b/README.md index 0bb36a6..f23e429 100644 --- a/README.md +++ b/README.md @@ -135,6 +135,25 @@ com a indicação `Included`, evitando o limite de texto por célula do Excel. Consultas mensais sem dias confirmados e marcadores inconsistentes retornam erro. Relatórios COUNTER padrão não mudam. Consulte o OpenAPI para o contrato completo. +## Relatórios provisórios com cobertura parcial + +`GET /r51/extensions/reports/` oferece `pr`, `tr`, `tr_j3`, `tr_b3` +e `ir` como relatórios **provisórios, não conformes ao COUNTER**. As rotas +COUNTER padrão permanecem inalteradas. + +A rota sempre inclui dias confirmados de meses incompletos, sem exigir +`coverage_policy`; `strict` é rejeitado. Para meses completos, use a rota +COUNTER oficial. Consulte meses inteiros; meses futuros do ano corrente +aparecem somente na cobertura, sem valores estimados. + +JSON inclui `coverage` e `warnings`; Excel acrescenta a aba `Coverage` e TSV, +a seção `Usage_Coverage` após os dados. Filtros, formatos e regras estão no +OpenAPI em `/r51/`. + +```text +/r51/extensions/reports/tr?platform=scl&begin_date=2025-01&end_date=2025-12 +``` + ## API COUNTER e política de acesso As rotas GET sob `/r51/` oferecem descoberta, relatórios COUNTER R5.1 e From dfde33950cef6571d52a388c6ed871e7c9eb9e99 Mon Sep 17 00:00:00 2001 From: Rafael JPD Date: Wed, 11 Nov 2026 13:51:37 -0300 Subject: [PATCH 8/8] =?UTF-8?q?Atualiza=20a=20vers=C3=A3o=20da=20aplica?= =?UTF-8?q?=C3=A7=C3=A3o=20para=202.8.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Marca a inclusão dos relatórios provisórios com cobertura parcial, preservando as rotas COUNTER existentes. --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 860487c..834f262 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.7.1 +2.8.0