251 lines
7.2 KiB
Go
251 lines
7.2 KiB
Go
package httpserver
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"time"
|
|
|
|
"log"
|
|
|
|
// "time"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
betSvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/bet"
|
|
eventsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
|
|
oddssvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/odds"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/report"
|
|
resultsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/result"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/ticket"
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/services/virtualGame/veli"
|
|
"github.com/robfig/cron/v3"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func StartDataFetchingCrons(eventService eventsvc.Service, oddsService oddssvc.ServiceImpl, resultService *resultsvc.Service, mongoLogger *zap.Logger) {
|
|
c := cron.New(cron.WithSeconds())
|
|
|
|
schedule := []struct {
|
|
spec string
|
|
task func()
|
|
}{
|
|
// {
|
|
// spec: "0 0 * * * *", // Every 1 hour
|
|
// task: func() {
|
|
// mongoLogger.Info("Began fetching upcoming events")
|
|
// if err := eventService.FetchUpcomingEvents(context.Background()); err != nil {
|
|
// mongoLogger.Error("Failed to fetch upcoming events",
|
|
// zap.Error(err),
|
|
// )
|
|
// } else {
|
|
// mongoLogger.Info("Successfully fetched upcoming events")
|
|
// }
|
|
// },
|
|
// },
|
|
// {
|
|
// spec: "0 0 * * * *", // Every 1 hour (since its takes that long to fetch all the events)
|
|
// task: func() {
|
|
// mongoLogger.Info("Began fetching non live odds")
|
|
// if err := oddsService.FetchNonLiveOdds(context.Background()); err != nil {
|
|
// mongoLogger.Error("Failed to fetch non live odds",
|
|
// zap.Error(err),
|
|
// )
|
|
// } else {
|
|
// mongoLogger.Info("Successfully fetched non live odds")
|
|
// }
|
|
// },
|
|
// },
|
|
// {
|
|
// spec: "0 */5 * * * *", // Every 5 Minutes
|
|
// task: func() {
|
|
// mongoLogger.Info("Began updating all expired events status")
|
|
// if _, err := resultService.CheckAndUpdateExpiredEvents(context.Background()); err != nil {
|
|
// mongoLogger.Error("Failed to update expired events status",
|
|
// zap.Error(err),
|
|
// )
|
|
// } else {
|
|
// mongoLogger.Info("Successfully updated expired events")
|
|
// }
|
|
// },
|
|
// },
|
|
// {
|
|
// spec: "0 */15 * * * *", // Every 15 Minutes
|
|
// task: func() {
|
|
// mongoLogger.Info("Fetching results for upcoming events")
|
|
// if err := resultService.FetchAndProcessResults(context.Background()); err != nil {
|
|
// mongoLogger.Error("Failed to process result",
|
|
// zap.Error(err),
|
|
// )
|
|
// } else {
|
|
// mongoLogger.Info("Successfully processed all event result outcomes")
|
|
// }
|
|
// },
|
|
// },
|
|
}
|
|
|
|
for _, job := range schedule {
|
|
// job.task()
|
|
if _, err := c.AddFunc(job.spec, job.task); err != nil {
|
|
mongoLogger.Error("Failed to schedule data fetching cron job",
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
}
|
|
|
|
c.Start()
|
|
log.Println("Cron jobs started for event and odds services")
|
|
mongoLogger.Info("Cron jobs started for event and odds services")
|
|
}
|
|
|
|
func StartTicketCrons(ticketService ticket.Service, mongoLogger *zap.Logger) {
|
|
c := cron.New(cron.WithSeconds())
|
|
|
|
schedule := []struct {
|
|
spec string
|
|
task func()
|
|
}{
|
|
{
|
|
spec: "0 0 * * * *", // Every hour
|
|
task: func() {
|
|
mongoLogger.Info("Deleting old tickets")
|
|
if err := ticketService.DeleteOldTickets(context.Background()); err != nil {
|
|
mongoLogger.Error("Failed to remove old ticket",
|
|
zap.Error(err),
|
|
)
|
|
} else {
|
|
mongoLogger.Info("Successfully deleted old tickets")
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, job := range schedule {
|
|
if _, err := c.AddFunc(job.spec, job.task); err != nil {
|
|
mongoLogger.Error("Failed to schedule ticket cron job",
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
}
|
|
|
|
c.Start()
|
|
mongoLogger.Info("Cron jobs started for ticket service")
|
|
}
|
|
|
|
// SetupReportCronJobs schedules periodic report generation
|
|
func SetupReportandVirtualGameCronJobs(
|
|
ctx context.Context,
|
|
reportService *report.Service,
|
|
virtualGameService *veli.Service, // inject your virtual game service
|
|
outputDir string,
|
|
) {
|
|
c := cron.New(cron.WithSeconds()) // use WithSeconds for testing
|
|
|
|
schedule := []struct {
|
|
spec string
|
|
period string
|
|
}{
|
|
{
|
|
spec: "60 0 0 * * *", // 1 Minute
|
|
period: "1 minute",
|
|
},
|
|
{
|
|
spec: "0 0 0 * * *", // Daily at midnight
|
|
period: "daily",
|
|
},
|
|
{
|
|
spec: "0 0 1 * * 0", // Weekly: Sunday at 1 AM
|
|
period: "weekly",
|
|
},
|
|
{
|
|
spec: "0 0 2 1 * *", // Monthly: 1st day of month at 2 AM
|
|
period: "monthly",
|
|
},
|
|
}
|
|
|
|
for _, job := range schedule {
|
|
period := job.period
|
|
|
|
if _, err := c.AddFunc(job.spec, func() {
|
|
now := time.Now()
|
|
var from, to time.Time
|
|
|
|
switch period {
|
|
case "daily":
|
|
from = time.Date(now.Year(), now.Month(), now.Day()-1, 0, 0, 0, 0, now.Location())
|
|
to = time.Date(now.Year(), now.Month(), now.Day()-1, 23, 59, 59, 0, now.Location())
|
|
case "weekly":
|
|
weekday := int(now.Weekday())
|
|
daysSinceSunday := (weekday + 7) % 7
|
|
from = time.Date(now.Year(), now.Month(), now.Day()-daysSinceSunday-7, 0, 0, 0, 0, now.Location())
|
|
to = from.AddDate(0, 0, 6).Add(time.Hour*23 + time.Minute*59 + time.Second*59)
|
|
case "monthly":
|
|
firstOfMonth := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
|
|
from = firstOfMonth.AddDate(0, -1, 0)
|
|
to = firstOfMonth.Add(-time.Second)
|
|
default:
|
|
log.Printf("Unknown period: %s", period)
|
|
return
|
|
}
|
|
|
|
// --- Generate Reports ---
|
|
log.Printf("Running %s report for period %s -> %s", period, from.Format(time.RFC3339), to.Format(time.RFC3339))
|
|
if err := reportService.GenerateReport(ctx, from, to); err != nil {
|
|
log.Printf("Error generating %s report: %v", period, err)
|
|
} else {
|
|
log.Printf("Successfully generated %s report", period)
|
|
}
|
|
|
|
// --- Fetch and Add Virtual Game Providers (daily only) ---
|
|
if period == "1 minute" {
|
|
log.Println("Fetching and adding virtual game providers...")
|
|
req := domain.ProviderRequest{
|
|
BrandID: os.Getenv("VELI_BRAND_ID"), // adjust to your actual brand ID
|
|
ExtraData: true,
|
|
Size: 1000, // or any default value
|
|
Page: 1, // start from first page
|
|
}
|
|
|
|
if _, err := virtualGameService.AddProviders(ctx, req); err != nil {
|
|
log.Printf("Error adding virtual game providers: %v", err)
|
|
} else {
|
|
log.Println("Successfully added virtual game providers")
|
|
}
|
|
}
|
|
}); err != nil {
|
|
log.Fatalf("Failed to schedule %s cron job: %v", period, err)
|
|
}
|
|
}
|
|
|
|
c.Start()
|
|
log.Printf("Cron jobs started. Reports will be saved to: %s", outputDir)
|
|
}
|
|
|
|
func ProcessBetCashback(ctx context.Context, betService *betSvc.Service) {
|
|
c := cron.New(cron.WithSeconds())
|
|
|
|
schedule := []struct {
|
|
spec string
|
|
task func()
|
|
}{
|
|
{
|
|
spec: "0 0 0 * * *", // Daily at midnight
|
|
task: func() {
|
|
log.Println("process bet cashbacks...")
|
|
if err := betService.ProcessBetCashback(ctx); err != nil {
|
|
log.Printf("Failed to process bet cashbacks: %v", err)
|
|
} else {
|
|
log.Printf("Successfully processed bet cashbacks")
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, job := range schedule {
|
|
if _, err := c.AddFunc(job.spec, job.task); err != nil {
|
|
log.Fatalf("Failed to schedule cron job: %v", err)
|
|
}
|
|
}
|
|
|
|
c.Start()
|
|
log.Println("Cron jobs started for bet cashbacks")
|
|
}
|