zineshop/repositories/repository.go

package repositories

import(
	"os"
	"strconv"
	"gorm.io/gorm"
	"gorm.io/driver/sqlite"

	"example.com/gin/test/models"
)	

var(
	Rooms RoomRepository
	Users UserRepository
)

type RoomRepository interface {
	Create(models.Room) (models.Room, error)	
	GetAll() ([]models.Room, error)
	GetById(string) (models.Room, error)
	Update(models.Room) (models.Room, error)
	DeleteById(string) error
	GetRoomUsersById(string) ([]models.User, error)
	AddRoomUserById(string, models.User) error
}

type UserRepository interface {
	Create(models.User) (models.User, error)	
	GetByEmail(string) (models.User, error)
	GetById(interface{}) (models.User, error)
	GetOwnedRooms(models.User) ([]models.Room, error)
}

func InitRepositories() {
	db, err := gorm.Open(sqlite.Open(os.Getenv("SQLITE_DB")), &gorm.Config{})
	if err != nil {
		panic("failed to connect to database")
	}

	err =  db.AutoMigrate(&models.Room{}, &models.User{}, &models.Booking{})
	if err != nil {
		panic("failed to migrate database")
	}

	Rooms = NewGORMRoomRepository(db)
	Users = NewGORMUserRepository(db)
}

type GORMUserRepository struct {
	DB *gorm.DB
}

type GORMRoomRepository struct {
	DB *gorm.DB
}

func NewGORMUserRepository(db *gorm.DB) UserRepository {
	return &GORMUserRepository{
		DB: db,
	}
}


func NewGORMRoomRepository(db *gorm.DB) RoomRepository {
	return &GORMRoomRepository{
		DB: db,
	}
}

func (r *GORMRoomRepository) Create(room models.Room) (models.Room, error)	{
	result := r.DB.Create(&room)
	if result.Error != nil {
		return models.Room{}, result.Error	
	}

	return room, nil
}

func (r *GORMRoomRepository) GetAll() ([]models.Room, error){
	var rooms []models.Room
	result := r.DB.Find(&rooms)

	return rooms, result.Error
}

func (r *GORMRoomRepository) GetById(id string) (models.Room, error) {
	roomId, err := strconv.Atoi(id)

	if err != nil {
		return models.Room{}, err
	}

	var room models.Room
	result := r.DB.First(&room, uint(roomId))

	if result.Error != nil {
		return models.Room{}, result.Error
	}

	return room, nil
}

func (r *GORMRoomRepository) Update(room models.Room) (models.Room, error) {
	result := r.DB.Save(&room)
	if result.Error != nil {
		return models.Room{}, result.Error
	}

	return room, nil
}

func (r *GORMRoomRepository) DeleteById(id string) error {
	roomId, err := strconv.Atoi(id)

	if err != nil {
		return err
	}

	result := r.DB.Delete(&models.Room{}, roomId)
	return result.Error
}

func (r *GORMRoomRepository) GetRoomUsersById(id string) ([]models.User, error) {
	roomId, err := strconv.Atoi(id)

	if err != nil {
		return nil, err
	}

	var room models.Room
	result := r.DB.First(&room, uint(roomId))

	if result.Error != nil {
		return nil, result.Error
	}

	var users []models.User
	err = r.DB.Model(&room).Association("Users").Find(&users)
	
	if err != nil {
		return nil, err
	}

	return users, nil
}

func (r *GORMRoomRepository) AddRoomUserById(id string, user models.User) error {
	roomId, err := strconv.Atoi(id)

	if err != nil {
		return err
	}

	var room models.Room
	result := r.DB.First(&room, uint(roomId))

	if result.Error != nil {
		return result.Error
	}

	err = r.DB.Model(&room).Association("Users").Append(&user)
	return err
}

func (u *GORMUserRepository) Create(user models.User) (models.User, error)	{
	result := u.DB.Create(&user)

	if result.Error != nil {
		return models.User{}, result.Error
	}

	return user, nil
}

func (u *GORMUserRepository) GetByEmail(email string) (models.User, error) {
	var user models.User
	result := u.DB.First(&user, "email = ?", email)

	if result.Error != nil {
		return models.User{}, result.Error
	}

	return user, nil
}

func (u *GORMUserRepository) GetById(id interface{}) (models.User, error) {
	var user models.User
	result := u.DB.First(&user, id)

	if result.Error != nil {
		return models.User{}, result.Error
	}

	return user, nil
}

func (u *GORMUserRepository) GetOwnedRooms(user models.User) ([]models.Room, error) {
	var rooms []models.Room
	err := u.DB.Model(&user).Association("OwnedRooms").Find(&rooms)
	return rooms, err
}