fix(jobs): normaliza campos nulos do scraper e conta vagas salvas de verdade

O jobspy devolve None nas colunas que nao preencheu — description vem sempre
nula com linkedin_fetch_description desligado — e `record.get("campo", "")`
nao protege disso, porque a chave existe com valor nulo. Como os campos de
DailyJob sao NOT NULL, o primeiro registro assim derrubava o bulk_create do
termo inteiro com IntegrityError, descartando todas as vagas daquele termo.
Apareceu em producao assim que o scrape voltou a funcionar.

Corrige tambem as metricas do fetch diario:

- jobs_skipped era sempre 0: `bulk_create(ignore_conflicts=True)` devolve a
  lista que recebeu (o Postgres nao retorna as linhas inseridas nesse modo),
  entao toda vaga repetida contava como nova. Agora medimos pela diferenca de
  linhas do termo no dia.
- novo terms_empty separa "dia sem vagas" de "scraper quebrado", ja que
  search() engole as falhas e devolve lista vazia
- evento fetch_daily_jobs_no_results (nivel error) quando nenhum termo entrega
  vaga alguma

Author: ErickBonruque

apps/jobs/services.py

@@ -164,6 +164,20 @@ def build_review_for_user(course, job_searcher: JobSearcher) -> list[dict[str, A
     return combined[:5]
 
 
+def _job_field(value: Any, max_length: int | None = None) -> str:
+    """Normaliza um campo textual vindo do scraper para persistência.
+
+    O jobspy entrega `None` nas colunas que não preencheu (NaN convertido) —
+    `record.get("campo", "")` não protege disso, porque a chave existe com valor
+    nulo. Como os campos de DailyJob são NOT NULL, um único registro assim
+    derrubava o bulk_create do termo inteiro (`description` vem sempre nula
+    quando `linkedin_fetch_description` está desligado). Truncar no limite da
+    coluna evita perder o lote pelo mesmo motivo.
+    """
+    text = str(value).strip() if value is not None else ""
+    return text[:max_length] if max_length else text
+
+
 def fetch_and_save_daily_jobs(job_searcher) -> dict[str, int]:
     """Scrapa todos os SearchTerms ativos e persiste em DailyJob (BOT-02).
 
@@ -179,6 +193,7 @@ def fetch_and_save_daily_jobs(job_searcher) -> dict[str, int]:
     search_terms = list(SearchTerm.objects.filter(is_default=True).select_related("course"))
     stats: dict[str, int] = {
         "terms_processed": 0,
+        "terms_empty": 0,
         "jobs_saved": 0,
         "jobs_skipped": 0,
         "errors": 0,
@@ -188,23 +203,35 @@ def fetch_and_save_daily_jobs(job_searcher) -> dict[str, int]:
         kwargs = term.to_search_kwargs()
         try:
             results = job_searcher.search(terms=[term.term], **kwargs)
+            if not results:
+                # `search()` engole falhas de scrape e devolve lista vazia, então
+                # esta contagem é o que separa "dia sem vagas" de "scraper quebrado".
+                stats["terms_empty"] += 1
             to_create = [
                 DailyJob(
                     search_term=term,
                     fetched_date=today,
-                    title=r.get("title", ""),
-                    company=r.get("company", ""),
-                    location=r.get("location", ""),
-                    job_url=r.get("job_url") or r.get("job_url_direct", ""),
-                    description=r.get("description", ""),
-                    job_type=r.get("job_type", ""),
+                    title=_job_field(r.get("title"), 255),
+                    company=_job_field(r.get("company"), 255),
+                    location=_job_field(r.get("location"), 255),
+                    job_url=_job_field(r.get("job_url") or r.get("job_url_direct"), 1000),
+                    description=_job_field(r.get("description")),
+                    job_type=_job_field(r.get("job_type"), 50),
                 )
                 for r in results
                 if r.get("job_url") or r.get("job_url_direct")
             ]
-            created = DailyJob.objects.bulk_create(to_create, ignore_conflicts=True)
-            stats["jobs_saved"] += len(created)
-            stats["jobs_skipped"] += len(to_create) - len(created)
+            # `bulk_create(ignore_conflicts=True)` devolve a lista que recebeu —
+            # o Postgres não retorna as linhas inseridas nesse modo, então contar
+            # o retorno marcaria toda vaga repetida como nova. Medimos pela
+            # diferença de linhas do termo no dia.
+            saved_before = DailyJob.objects.filter(search_term=term, fetched_date=today).count()
+            DailyJob.objects.bulk_create(to_create, ignore_conflicts=True)
+            saved = (
+                DailyJob.objects.filter(search_term=term, fetched_date=today).count() - saved_before
+            )
+            stats["jobs_saved"] += saved
+            stats["jobs_skipped"] += len(to_create) - saved
             JobSearchLog.objects.create(
                 user=None,
                 search_term=term.term,
@@ -230,6 +257,10 @@ def fetch_and_save_daily_jobs(job_searcher) -> dict[str, int]:
         deleted_old=deleted,
         **stats,
     )
+    if search_terms and not stats["jobs_saved"] and not stats["jobs_skipped"]:
+        # Nenhum termo entregou vaga alguma: é falha sistêmica (scraper bloqueado,
+        # rede, runner quebrado), não um dia fraco. Evento próprio para alarme.
+        logger.error("fetch_daily_jobs_no_results", **stats)
     return stats
 
 

apps/jobs/tests/test_daily_job.py

@@ -215,7 +215,13 @@ def test_retorna_dict_com_chaves_esperadas(self):
             ]
         )
         stats = fetch_and_save_daily_jobs(job_searcher=searcher)
-        assert set(stats.keys()) == {"terms_processed", "jobs_saved", "jobs_skipped", "errors"}
+        assert set(stats.keys()) == {
+            "terms_processed",
+            "terms_empty",
+            "jobs_saved",
+            "jobs_skipped",
+            "errors",
+        }
 
     def test_erro_em_termo_incrementa_errors_e_continua(self):
         from apps.courses.models import SearchTerm
@@ -237,6 +243,75 @@ def side_effect(terms, **kwargs):
         assert stats["terms_processed"] == 2
         assert DailyJob.objects.count() == 1
 
+    def test_persiste_vaga_com_campos_nulos_do_scraper(self):
+        from apps.jobs.models import DailyJob
+        from apps.jobs.services import fetch_and_save_daily_jobs
+
+        # Regressão de produção: o jobspy devolve None nas colunas que não
+        # preencheu (description vem sempre nula sem linkedin_fetch_description)
+        # e os campos do modelo são NOT NULL — um registro assim derrubava o
+        # bulk_create do termo inteiro com IntegrityError.
+        searcher = self._make_searcher(
+            [
+                {
+                    "title": "Dev Python",
+                    "company": "Corp",
+                    "location": None,
+                    "description": None,
+                    "job_type": None,
+                    "job_url": "https://example.com/nulo",
+                },
+            ]
+        )
+
+        stats = fetch_and_save_daily_jobs(job_searcher=searcher)
+
+        job = DailyJob.objects.get(job_url="https://example.com/nulo")
+        assert (job.description, job.location, job.job_type) == ("", "", "")
+        assert stats["errors"] == 0
+        assert stats["jobs_saved"] == 1
+
+    def test_trunca_campos_maiores_que_a_coluna(self):
+        from apps.jobs.models import DailyJob
+        from apps.jobs.services import fetch_and_save_daily_jobs
+
+        searcher = self._make_searcher(
+            [
+                {
+                    "title": "T" * 300,
+                    "company": "Corp",
+                    "job_url": "https://example.com/longo",
+                },
+            ]
+        )
+
+        fetch_and_save_daily_jobs(job_searcher=searcher)
+
+        assert len(DailyJob.objects.get(job_url="https://example.com/longo").title) == 255
+
+    def test_conta_termo_sem_resultado_em_terms_empty(self):
+        from apps.jobs.services import fetch_and_save_daily_jobs
+
+        stats = fetch_and_save_daily_jobs(job_searcher=self._make_searcher([]))
+
+        assert stats["terms_empty"] == 1
+        assert stats["jobs_saved"] == 0
+
+    def test_vaga_repetida_conta_como_skipped_e_nao_como_salva(self):
+        from apps.jobs.services import fetch_and_save_daily_jobs
+
+        searcher = self._make_searcher(
+            [
+                {"title": "Dev", "company": "Corp", "job_url": "https://example.com/dup"},
+            ]
+        )
+        fetch_and_save_daily_jobs(job_searcher=searcher)
+
+        stats = fetch_and_save_daily_jobs(job_searcher=searcher)
+
+        assert stats["jobs_saved"] == 0
+        assert stats["jobs_skipped"] == 1
+
     def test_cria_job_search_log_com_user_none(self):
         from apps.jobs.models import JobSearchLog
         from apps.jobs.services import fetch_and_save_daily_jobs