AutoMark Platform

class MarketplaceProvider:
    """Interface obrigatória para todo marketplace."""
    
    def search(
        self, 
        *, 
        rules: SearchRules, 
        limit: int,
        tenant_connection: TenantMarketplaceConnection,
    ) -> list[OfferCandidate]:
        """Busca ofertas no marketplace."""
        ...
    
    def build_affiliate_url(
        self, 
        *, 
        product_url: str, 
        tenant_connection: TenantMarketplaceConnection,
    ) -> str:
        """Gera URL com tag de afiliado do tenant."""
        ...
    
    def validate_connection(
        self, 
        tenant_connection: TenantMarketplaceConnection,
    ) -> ValidationResult:
        """Valida credenciais (app_id, secret, affiliate_tag)."""
        ...

class ShopeeProvider(MarketplaceProvider):
    PROVIDER_KEY = "shopee"
    GRAPHQL_ENDPOINT = "https://open-api.affiliate.shopee.com.br/graphql"
    
    def search(self, *, rules, limit, tenant_connection):
        credentials = self._get_credentials(tenant_connection)
        
        # GraphQL query com filtros
        query = self._build_search_query(
            keyword=rules.query,
            category=rules.category,
            min_price=rules.min_price,
            max_price=rules.max_price,
            min_discount=rules.min_discount_percent,
        )
        
        # Assinatura HMAC para autenticação
        signature = self._sign_request(query, credentials)
        
        response = httpx.post(
            self.GRAPHQL_ENDPOINT,
            json={"query": query},
            headers={"Authorization": f"SHA256 {signature}"},
            timeout=20.0,
        )
        
        return self._parse_offers(response.json())
    
    def _build_dedupe_key(self, item) -> str:
        """Identidade única: shopee:{shop_id}:{item_id}"""
        return f"shopee:{item['shopId']}:{item['itemId']}"

# Score Components (0-10 each)
discount_score = min(discount_percent, 80) / 80 * 10
rating_score = (rating / 5) * 10
commission_score = min(commission_pct, 10) / 10 * 10
sales_score = min(sold_count, 1000) / 1000 * 10

# Weighted Sum
score = (discount_score * 0.40) +
        (rating_score * 0.25) +
        (commission_score * 0.15) +
        (sales_score * 0.20) +
        recency_bonus

# Recency Bonus
< 6h:  +1.5
< 24h: +1.0
< 72h: +0.5
> 72h: +0.0

# Penalties (subtraídas do score)
fake_promo:      discount > 70% AND rating < 4.1 → -2.0
no_reviews:      rating is None or 0 → -1.0
too_cheap:       price < R$5.00 → -0.5
high_commission: commission > 20% → -1.0

class DedupeService:
    def is_blocked(
        self,
        *,
        tenant_id: UUID,
        channel_id: UUID,
        dedupe_key: str,  # ex: "shopee:123:456"
        target_ref: UUID | None,
        scope: DedupeScope,
    ) -> bool:
        """
        Check if offer is blocked by cooldown.
        
        Returns True if still in cooldown, False if can send.
        """
        record = self.db.query(DedupeRecord).filter(
            DedupeRecord.tenant_id == tenant_id,
            DedupeRecord.dedupe_key == dedupe_key,
            DedupeRecord.scope == scope,
            DedupeRecord.cooldown_until > now,  # Still cooling
        ).first()
        
        return record is not None
    
    def mark_sent(self, *, dedupe_key, scope, post_id):
        """Mark offer as sent, starting cooldown."""
        cooldown = (
            timedelta(hours=48) if scope == DedupeScope.target
            else timedelta(minutes=5)
        )
        
        record = DedupeRecord(
            dedupe_key=dedupe_key,
            cooldown_until=now + cooldown,
            last_post_id=post_id,
        )
        self.db.add(record)

# Pipeline de Execução (workers/tasks.py)

1. tick_automations()
   └─ Busca automations habilitadas no intervalo

2. Para cada automation:
   ├─ Valida janela de horário (start_time/end_time)
   ├─ Carrega conexões ativas do tenant (marketplace + channel)
   │
   ├─ Busca ofertas via provider.search()
   │   └─ Aplica rules (keywords, price, discount)
   │
   ├─ Normaliza ofertas + gera dedupe_key
   │
   ├─ Aplica scoring + ranking
   │   └─ priority_mode: max_discount | min_price | score
   │
   └─ Para cada target:
       ├─ Check dedupe (target scope)
       ├─ Check rate limit (channel scope)
       ├─ Check quiet hours
       │
       ├─ typing() → delay → send()
       │
       ├─ Cria Post + PostDispatch
       └─ Marca dedupe

automation_targets:
  - target_ref: "uuid-do-grupo"
    max_posts_per_day: 10      # Máximo de posts/dia neste grupo
    min_gap_minutes: 30        # Mínimo entre posts (além do dedupe)
    quiet_hours_start: "23:00"
    quiet_hours_end: "08:00"