Hogyan valósítható meg az automatik híváselutasítás logikája, ha egy felhasználótól több mint 10 hívás érkezik 15 perc alatt?

Egy felhasználótól több mint 10 hívás 15 percen belül történő automatikus elutasításának logikáját úgy lehet megvalósítani, hogy egy mozgó időablakot és egy hívásszámlálót használunk. A fő ötlet az, hogy tároljuk a felhasználó hívásainak időbélyegeit, és egy új hívásnál ellenőrizzük, hány hívás történt az elmúlt 15 percben.

Példa Go nyelven:

package main

import (
    "fmt"
    "sync"
    "time"
)

type CallTracker struct {
    mu       sync.Mutex
    callsMap map[string][]time.Time // kulcs — felhasználói azonosító, érték — hívás időbélyegeinek szelete
}

func NewCallTracker() *CallTracker {
    return &CallTracker{
        callsMap: make(map[string][]time.Time),
    }
}

func (ct *CallTracker) RegisterCall(userID string) bool {
    ct.mu.Lock()
    defer ct.mu.Unlock()

    now := time.Now()
    windowStart := now.Add(-15 * time.Minute)

    calls := ct.callsMap[userID]
    // Csak az elmúlt 15 perc hívásait tartsa meg
    var recentCalls []time.Time
    for _, t := range calls {
        if t.After(windowStart) {
            recentCalls = append(recentCalls, t)
        }
    }

    if len(recentCalls) >= 10 {
        // Automatikus elutasítás
        return false
    }

    // Hozzáadjuk az aktuális hívást
    recentCalls = append(recentCalls, now)
    ct.callsMap[userID] = recentCalls
    return true
}

func main() {
    tracker := NewCallTracker()
    userID := "user123"

    for i := 0; i < 12; i++ {
        allowed := tracker.RegisterCall(userID)
        if allowed {
            fmt.Println("Hívás elfogadva")
        } else {
            fmt.Println("Hívás elutasítva")
        }
        time.Sleep(1 * time.Minute)
    }
}