Refatoração de services para implementação de a partir de interfaces e ajustes no modelo de events

backend/internal/database/seed.go

@@ -2,40 +2,53 @@ package database
 
 import (
 	"faladev/internal/models"
+	"faladev/internal/repository"
+	"faladev/internal/services"
 	"log"
 	"time"
 
 	"gorm.io/gorm"
 )
 
 func Seed(db *gorm.DB) {
-	seedEvents(db)
+
+	eventRepo := repository.NewEventRepository(db)
+
+	eventService := services.NewEventService(eventRepo)
+
+	seedEvents(eventService)
 }
 
-func seedEvents(db *gorm.DB) {
+func seedEvents(eventService *services.EventService) {
 
-	var eventCount int64
+	eventCount, err := eventService.CountEvents()
 
-	db.Model(&models.Event{}).Count(&eventCount)
+	if err != nil {
+		log.Fatalf("Failed to count events: %v", err)
+	}
 
 	if eventCount == 0 {
 
 		log.Println("Inserting default event...")
 
 		defaultEvent := models.Event{
-			Name:        "Mentoria (Carreira e Tecnologia)",
-			Description: "",
-			Location:    "https://meet.google.com/eam-bqde-mgd",
-			StartDate:   time.Now().Add(24 * time.Hour),
-			EndDate:     time.Now().Add(26 * time.Hour),
-			StartTime:   time.Now().Add(24 * time.Hour),
-			EndTime:     time.Now().Add(26 * time.Hour),
-			Organizer:   "",
-			Email:       "",
-			Phone:       "",
+			Name:              "Mentoria (Carreira e Tecnologia)",
+			Key:               "04mti3liihmd9u2agf8hg7kf6u",
+			Description:       "Essa é uma mentoria gratuita para quem está entrando na área de tecnologia, migrando de área ou buscando crescimento profissional.",
+			Location:          "https://meet.google.com/eam-bqde-mgd",
+			StartDate:         time.Now().Add(24 * time.Hour),
+			EndDate:           time.Now().Add(26 * time.Hour),
+			StartTime:         time.Now().Add(24 * time.Hour),
+			EndTime:           time.Now().Add(26 * time.Hour),
+			Organizer:         "Marcos Fonseca",
+			Email:             "mentoria@faladev.tech",
+			Phone:             "",
+			CalendarEventLink: "https://www.google.com/calendar/event?eid=MDRtdGkzbGlpaG1kOXUyYWdmOGhnN2tmNnVfMjAyNDA2MTJUMjIwMDAwWiBjb250YXRvQG1hcmNvc2ZvbnNlY2EuY29tLmJy",
 		}
 
-		if err := db.Create(&defaultEvent).Error; err != nil {
+		err = eventService.CreateEvent(&defaultEvent)
+
+		if err != nil {
 			log.Fatalf("Failed to insert default event: %v", err)
 		}
 

backend/internal/models/events.go

@@ -8,14 +8,16 @@ import (
 
 type Event struct {
 	gorm.Model
-	Name        string    `json:"name"`
-	Description string    `json:"description"`
-	Location    string    `json:"location"`
-	StartDate   time.Time `json:"start_date"`
-	EndDate     time.Time `json:"end_date"`
-	StartTime   time.Time `json:"start_time"`
-	EndTime     time.Time `json:"end_time"`
-	Organizer   string    `json:"organizer"`
-	Email       string    `json:"email"`
-	Phone       string    `json:"phone"`
+	Name              string    `json:"name"`
+	Key               string    `json:"key"`
+	Description       string    `json:"description"`
+	Location          string    `json:"location"`
+	StartDate         time.Time `json:"start_date"`
+	EndDate           time.Time `json:"end_date"`
+	StartTime         time.Time `json:"start_time"`
+	EndTime           time.Time `json:"end_time"`
+	Organizer         string    `json:"organizer"`
+	Email             string    `json:"email"`
+	Phone             string    `json:"phone"`
+	CalendarEventLink string    `json:"calendar_event_link"`
 }

backend/internal/repository/event_repository.go

@@ -2,7 +2,6 @@ package repository
 
 import (
 	"faladev/internal/models"
-	"time"
 
 	"gorm.io/gorm"
 )
@@ -17,41 +16,54 @@ func NewEventRepository(db *gorm.DB) *EventRepository {
 	}
 }
 
-func (r *EventRepository) CreateEvent(event *models.Event) error {
-	return r.db.Create(event).Error
+func (eventRepository *EventRepository) CreateEvent(event *models.Event) error {
+	return eventRepository.db.Create(event).Error
 }
 
-func (r *EventRepository) GetEventByID(id uint) (*models.Event, error) {
+func (eventRepository *EventRepository) GetEventByID(id uint) (*models.Event, error) {
 	var event models.Event
-	err := r.db.First(&event, id).Error
+	err := eventRepository.db.First(&event, id).Error
 	if err != nil {
 		return nil, err
 	}
 	return &event, nil
 }
 
-func (r *EventRepository) UpdateEvent(event *models.Event) error {
-	return r.db.Save(event).Error
+func (eventRepository *EventRepository) UpdateEvent(event *models.Event) error {
+	return eventRepository.db.Save(event).Error
 }
 
-func (r *EventRepository) DeleteEvent(id uint) error {
-	return r.db.Delete(&models.Event{}, id).Error
+func (eventRepository *EventRepository) DeleteEvent(id uint) error {
+	return eventRepository.db.Delete(&models.Event{}, id).Error
 }
 
-func (r *EventRepository) ListEvents() ([]models.Event, error) {
+func (eventRepository *EventRepository) ListEvents() ([]models.Event, error) {
 	var events []models.Event
-	err := r.db.Find(&events).Error
+	err := eventRepository.db.Find(&events).Error
 	if err != nil {
 		return nil, err
 	}
 	return events, nil
 }
 
-func (r *EventRepository) GetNextEvent() (*models.Event, error) {
+func (eventRepository *EventRepository) GetNextEvent() (*models.Event, error) {
 	var event models.Event
-	err := r.db.Where("start_date >= ?", time.Now()).Order("start_date, start_time").Debug().First(&event).Error
+	err := eventRepository.db.
+		//Where("start_date >= ?", time.Now()).
+		Order("start_date, start_time").
+		Debug().
+		First(&event).Error
 	if err != nil {
 		return nil, err
 	}
 	return &event, nil
 }
+
+func (eventRepository *EventRepository) CountEvents() (int64, error) {
+	var count int64
+	err := eventRepository.db.Model(&models.Event{}).Count(&count).Error
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}

backend/internal/repository/student_repository.go

@@ -16,29 +16,20 @@ func NewStudentRepository(db *gorm.DB) *StudentRepository {
 	}
 }
 
-func (r *StudentRepository) InsertOrUpdateStudent(name, email, phone string) error {
+func (studentRepository *StudentRepository) InsertOrUpdateStudent(name, email, phone string) error {
 
-	var existingStudent models.Student
+	student := &models.Student{Name: name, Email: email, Phone: phone}
 
-	err := r.db.Where("email = ?", email).First(&existingStudent).Error
+	err := studentRepository.db.Where("email = ?", email).FirstOrCreate(&student).Error
 
 	if err != nil {
-		if err == gorm.ErrRecordNotFound {
-			newStudent := models.Student{
-				Name:  name,
-				Email: email,
-				Phone: phone,
-			}
-			result := r.db.Create(&newStudent)
-			return result.Error
-		}
 		return err
 	}
 
-	existingStudent.Name = name
-	existingStudent.Phone = phone
+	student.Name = name
+	student.Phone = phone
 
-	result := r.db.Save(&existingStudent)
+	result := studentRepository.db.Save(&student)
 
 	return result.Error
 }

backend/internal/repository/token_repository.go

@@ -18,7 +18,7 @@ func NewTokenRepository(db *gorm.DB) *TokenRepository {
 	}
 }
 
-func (r *TokenRepository) CreateToken(token *oauth2.Token) error {
+func (tokenRepository *TokenRepository) CreateToken(token *oauth2.Token) error {
 
 	tokenJSON, err := json.Marshal(token)
 
@@ -30,14 +30,14 @@ func (r *TokenRepository) CreateToken(token *oauth2.Token) error {
 		Token: string(tokenJSON),
 	}
 
-	return r.db.Create(&newToken).Error
+	return tokenRepository.db.Create(&newToken).Error
 }
 
-func (r *TokenRepository) GetToken() (*oauth2.Token, error) {
+func (tokenRepository *TokenRepository) GetToken() (*oauth2.Token, error) {
 
 	var tokenModel models.Token
 
-	err := r.db.Order("created_at desc").First(&tokenModel).Error
+	err := tokenRepository.db.Order("created_at desc").First(&tokenModel).Error
 
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {

backend/internal/services/calendar_service.go

@@ -9,8 +9,8 @@ import (
 
 type CalendarService interface {
 	InitializeService(ctx context.Context, config *oauth2.Config, token *oauth2.Token) (CalendarAPI, error)
-	AddGuestToEvent(ctx context.Context, service CalendarAPI, hangoutLink, email string) (*calendar.Event, error)
-	FindEventByHangoutLink(ctx context.Context, service CalendarAPI, hangoutLink string) (*calendar.Event, error)
+	AddGuestToEvent(ctx context.Context, service CalendarAPI, eventKey, email string) (*calendar.Event, error)
+	FindEventByKey(ctx context.Context, service CalendarAPI, eventKey string) (*calendar.Event, error)
 }
 
 type CalendarAPI interface {

backend/internal/services/email_service.go

@@ -1,10 +1,11 @@
 package services
 
 import (
+	"faladev/internal/models"
+
 	"golang.org/x/oauth2"
-	"google.golang.org/api/calendar/v3"
 )
 
 type EmailService interface {
-	SendMentorshipInvitation(recipient string, eventDetails *calendar.Event, token *oauth2.Token) error
+	SendInvite(recipient string, eventDetails *models.Event, token *oauth2.Token) error
 }

backend/internal/services/event_service.go

@@ -2,39 +2,50 @@ package services
 
 import (
 	"faladev/internal/models"
-	"faladev/internal/repository"
 )
 
+type EventRepository interface {
+	CreateEvent(event *models.Event) error
+	GetEventByID(id uint) (*models.Event, error)
+	UpdateEvent(event *models.Event) error
+	DeleteEvent(id uint) error
+	ListEvents() ([]models.Event, error)
+	GetNextEvent() (*models.Event, error)
+	CountEvents() (int64, error)
+}
+
 type EventService struct {
-	repo *repository.EventRepository
+	repo EventRepository
+}
+
+func NewEventService(repo EventRepository) *EventService {
+	return &EventService{repo: repo}
 }
 
-func NewEventService(repo *repository.EventRepository) *EventService {
-	return &EventService{
-		repo: repo,
-	}
+func (eventService *EventService) CreateEvent(event *models.Event) error {
+	return eventService.repo.CreateEvent(event)
 }
 
-func (s *EventService) CreateEvent(event *models.Event) error {
-	return s.repo.CreateEvent(event)
+func (eventService *EventService) GetEventByID(id uint) (*models.Event, error) {
+	return eventService.repo.GetEventByID(id)
 }
 
-func (s *EventService) GetEventByID(id uint) (*models.Event, error) {
-	return s.repo.GetEventByID(id)
+func (eventService *EventService) UpdateEvent(event *models.Event) error {
+	return eventService.repo.UpdateEvent(event)
 }
 
-func (s *EventService) UpdateEvent(event *models.Event) error {
-	return s.repo.UpdateEvent(event)
+func (eventService *EventService) DeleteEvent(id uint) error {
+	return eventService.repo.DeleteEvent(id)
 }
 
-func (s *EventService) DeleteEvent(id uint) error {
-	return s.repo.DeleteEvent(id)
+func (eventService *EventService) ListEvents() ([]models.Event, error) {
+	return eventService.repo.ListEvents()
 }
 
-func (s *EventService) ListEvents() ([]models.Event, error) {
-	return s.repo.ListEvents()
+func (eventService *EventService) GetNextEvent() (*models.Event, error) {
+	return eventService.repo.GetNextEvent()
 }
 
-func (s *EventService) GetNextEvent() (*models.Event, error) {
-	return s.repo.GetNextEvent()
+func (eventService *EventService) CountEvents() (int64, error) {
+	return eventService.repo.CountEvents()
 }