Move ingestion + Telegram/Bale/Divar config to DB-backed admin settings

- AppSetting gains source config: AutoIngestEnabled, IngestIntervalMinutes, Telegram/Bale/Divar enabled+channels/token/queries
- IListingSource.FetchAsync(AppSetting) — sources read config from DB, not IOptions/appsettings; sample source dev-only
- IngestionWorker reads AutoIngest+interval from DB each cycle (toggle at runtime, no redeploy)
- /Admin/Settings gets a 'منابع جمع‌آوری' section; removed Ingestion env/appsettings + compose env vars
- ENV_FILE shrinks to HOST_PORT + POSTGRES_* + ADMIN_PHONE (AI + sources are all in-admin); migration

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/JobsMedical.Web/Services/Scraping/IngestionWorker.cs

@@ -1,58 +1,52 @@
-using Microsoft.Extensions.Options;
-
 namespace JobsMedical.Web.Services.Scraping;
 
-public class IngestionOptions
-{
-    public bool Enabled { get; set; } = false;     // off by default — opt in via config
-    public int IntervalMinutes { get; set; } = 30;
-}
-
 /// <summary>
-/// Periodically runs the ingestion engine when enabled (Ingestion:Enabled=true). Off by default
-/// so nothing scrapes uninvited; admins can also trigger a run on demand from the admin UI.
+/// Periodically runs the ingestion engine when the admin has turned auto-ingest ON
+/// (AppSetting.AutoIngestEnabled) — read fresh from the DB each cycle, so it can be toggled at
+/// runtime from the admin panel with no redeploy. When off, it idles and re-checks.
 /// </summary>
 public class IngestionWorker : BackgroundService
 {
     private readonly IServiceScopeFactory _scopes;
-    private readonly IngestionOptions _opts;
     private readonly ILogger<IngestionWorker> _log;
 
-    public IngestionWorker(IServiceScopeFactory scopes, IOptions<IngestionOptions> opts,
-        ILogger<IngestionWorker> log)
+    public IngestionWorker(IServiceScopeFactory scopes, ILogger<IngestionWorker> log)
     {
         _scopes = scopes;
-        _opts = opts.Value;
         _log = log;
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
-        if (!_opts.Enabled)
-        {
-            _log.LogInformation("Ingestion worker disabled (Ingestion:Enabled=false).");
-            return;
-        }
-
-        var interval = TimeSpan.FromMinutes(Math.Max(1, _opts.IntervalMinutes));
-        _log.LogInformation("Ingestion worker on; every {Min} min.", _opts.IntervalMinutes);
+        // Small startup delay so the DB/migrations are ready.
+        try { await Task.Delay(TimeSpan.FromSeconds(20), stoppingToken); }
+        catch (OperationCanceledException) { return; }
 
         while (!stoppingToken.IsCancellationRequested)
         {
+            var idleMinutes = 10;
             try
             {
                 using var scope = _scopes.CreateScope();
-                var svc = scope.ServiceProvider.GetRequiredService<IngestionService>();
-                var summary = await svc.RunAsync(stoppingToken);
-                _log.LogInformation("Scheduled ingestion: queued={Q} flagged={F} spam={S} dupes={D}",
-                    summary.TotalQueued, summary.TotalFlagged, summary.TotalSpam, summary.TotalDuplicates);
+                var settings = await scope.ServiceProvider
+                    .GetRequiredService<SettingsService>().GetAsync();
+
+                if (settings.AutoIngestEnabled)
+                {
+                    var svc = scope.ServiceProvider.GetRequiredService<IngestionService>();
+                    var summary = await svc.RunAsync(stoppingToken);
+                    _log.LogInformation("Auto-ingest: queued={Q} published={P} flagged={F} spam={S} dupes={D}",
+                        summary.TotalQueued, summary.TotalPublished, summary.TotalFlagged,
+                        summary.TotalSpam, summary.TotalDuplicates);
+                    idleMinutes = Math.Max(1, settings.IngestIntervalMinutes);
+                }
             }
             catch (Exception ex) when (ex is not OperationCanceledException)
             {
-                _log.LogError(ex, "Scheduled ingestion run failed");
+                _log.LogError(ex, "Auto-ingest cycle failed");
             }
 
-            try { await Task.Delay(interval, stoppingToken); }
+            try { await Task.Delay(TimeSpan.FromMinutes(idleMinutes), stoppingToken); }
             catch (OperationCanceledException) { break; }
         }
     }