Hoe implementeer je de logica voor automatische afwijzing van oproepen bij meer dan 10 oproepen in 15 minuten van een gebruiker?

Om de logica voor automatische afwijzing van oproepen te implementeren wanneer er meer dan 10 oproepen binnen 15 minuten van één gebruiker plaatsvinden, kan een glijdend venster en een oproepenteller worden gebruikt. Het belangrijkste idee is om de tijdstempels van de oproepen van de gebruiker op te slaan en bij een nieuwe oproep te controleren hoeveel oproepen er in de afgelopen 15 minuten zijn geweest.

Voorbeeld in Go:

package main

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

type CallTracker struct {
    mu       sync.Mutex
    callsMap map[string][]time.Time // sleutel — gebruikers-ID, waarde — reeks tijdstempels van oproepen
}

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]
    // Alleen oproepen binnen het venster van 15 minuten bewaren
    var recentCalls []time.Time
    for _, t := range calls {
        if t.After(windowStart) {
            recentCalls = append(recentCalls, t)
        }
    }

    if len(recentCalls) >= 10 {
        // Automatische afwijzing
        return false
    }

    // Voeg de huidige oproep toe
    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("Oproep geaccepteerd")
        } else {
            fmt.Println("Oproep geweigerd")
        }
        time.Sleep(1 * time.Minute)
    }
}