repo-pattern/app/main.go

package main

import (
	"fmt"
	"repo-pattern/app/lib/cfg"
	"repo-pattern/app/lib/db"
	"repo-pattern/app/lib/logging"
	"repo-pattern/app/models"
	"repo-pattern/app/repository"
	"repo-pattern/app/repository/smartfilter"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

var (
	TRUE  = true
	FALSE = false
)

type CertFilter struct {
	Alive                *bool        `filterfield:"field=alive;operator=EQ"`
	SerialNumber         *string      `filterfield:"field=serial_number;operator=NE"`
	SerialNumberContains *string      `filterfield:"field=serial_number;operator=LIKE"`
	IssuerContains       *string      `filterfield:"field=issuer;operator=ILIKE"`
	Id                   *uuid.UUID   `filterfield:"field=id;operator=EQ"`
	Ids                  *[]uuid.UUID `filterfield:"field=id;operator=IN"`
	IdsNot               *[]string    `filterfield:"field=id;operator=NOT_IN"`
	CreatedAt_Lt         *time.Time   `filterfield:"field=created_at;operator=LT"`
	Timestamps           *[]time.Time `filterfield:"field=created_at;operator=IN"`
	CompanyIsActive      *bool
}

func (f CertFilter) ApplyQuery(query *gorm.DB) *gorm.DB {
	if f.CompanyIsActive != nil {
		query = query.Joins(
			fmt.Sprintf(
				"JOIN companies ON certificates.company_id = companies.id WHERE companies.is_active = %t",
				*f.CompanyIsActive,
			))
	}
	return query
}

type CompanyFilter struct {
	IsActive *bool `filterfield:"field=is_active;operator=EQ"`
}

func doMagic(db *gorm.DB) {
	var err error
	query := db

	// id := "6dc096ab-5c03-427e-b808-c669f7446131"
	// serialNumber := "222"
	// serialNumberContains := "323"
	// issuer := "FINA"
	location, _ := time.LoadLocation("UTC")
	createdTime := time.Date(2024, 5, 26, 16, 8, 0, 0, location)

	id1, _ := uuid.Parse("eb2bcac6-5173-4dbb-93b7-e7c03b924a03")
	id2, _ := uuid.Parse("db9fb837-3483-4736-819d-f427dc8cda23")
	id3, _ := uuid.Parse("1fece5e7-8e8d-4828-8298-3b1f07fd29ff")

	ids := []uuid.UUID{id1, id2, id3}

	filter := CertFilter{
		// Alive: &FALSE,
		// Id:    &id,
		// SerialNumber: &serialNumber,
		// SerialNumberContains: &serialNumberContains,
		Ids: &ids,
		// IssuerContains: &issuer,
		CreatedAt_Lt: &createdTime,
	}

	query, err = smartfilter.ToQuery(models.Cert{}, filter, query)
	if err != nil {
		panic(err)
	}

	var certs []models.Cert

	query.Order("created_at").Find(&certs)
	for n, cert := range certs {
		fmt.Printf(">> [%d] %+v  %s\n", n, cert.Id, cert.CreatedAt)
	}
}

func doList(db *gorm.DB) {
	repo := repository.RepoBase[models.Cert]{}
	repo.Init(db, nil)

	filter := CertFilter{
		Alive: &TRUE,
	}

	certs, err := repo.List(filter, nil)
	if err != nil {
		panic(err)
	}

	for n, cert := range *certs {
		fmt.Printf(">> [%d] %+v  %s (alive %t)\n", n, cert.Id, cert.CreatedAt, cert.Alive)
	}
}

func doListWithJoins(db *gorm.DB) {
	repo := repository.RepoBase[models.Cert]{}
	repo.Init(db, nil)

	filter := CertFilter{
		CompanyIsActive: &FALSE,
	}

	certs, err := repo.List(filter, nil)
	if err != nil {
		panic(err)
	}

	for n, cert := range *certs {
		fmt.Printf(">> [%d] %+v  %s (alive %t)\n", n, cert.Id, cert.CreatedAt, cert.Alive)
	}
}

func doCount(db *gorm.DB) {
	repo := repository.RepoBase[models.Cert]{}
	repo.Init(db, nil)

	filter := CertFilter{
		Alive: &TRUE,
	}

	count, err := repo.Count(filter)
	if err != nil {
		panic(err)
	}
	fmt.Printf(">>> count: %d\n", count)
}

func doGet(db *gorm.DB) {
	repo := repository.RepoBase[models.Cert]{}
	repo.Init(db, nil)

	id, _ := uuid.Parse("db9fb837-3483-4736-819d-f427dc8cda23")

	filter := CertFilter{
		Id: &id,
	}

	cert, err := repo.Get(filter, nil)
	if err != nil {
		panic(err)
	}
	fmt.Printf(">> %+v  %s (alive %t)\n", cert.Id, cert.CreatedAt, cert.Alive)
}

func doSave(db *gorm.DB) {
	repo := repository.RepoBase[models.Company]{}
	repo.Init(db, nil)

	company := models.Company{
		Name:    "Test company",
		Address: "Some address",
		City:    "Some city",
		Email:   "email@example.org",
		Oib:     "123456",
	}

	_, err := repo.Save(&company)
	if err != nil {
		panic(err)
	}
	fmt.Printf("New company id: %s\n", company.Id.String())
}

func doDelete(db *gorm.DB) {
	repo := repository.RepoBase[models.Company]{}
	repo.Init(db, nil)

	filter := CompanyFilter{
		IsActive: &FALSE,
	}

	deletedCount, err := repo.Delete(filter)
	if err != nil {
		panic(err)
	}
	fmt.Printf(">> DELETED: %d\n", deletedCount)
}

func doExists(db *gorm.DB) {
	repo := repository.RepoBase[models.Cert]{}
	repo.Init(db, nil)

	id, _ := uuid.Parse("db9fb837-3483-4736-819d-f427dc8cda23")

	filter := CertFilter{
		Id: &id,
	}

	exists, err := repo.Exists(filter)
	if err != nil {
		panic(err)
	}
	fmt.Printf(">> EXISTS: %t\n", exists)
}

func main() {
	cfg.Init()
	logging.Init()
	defer logging.Log.Sync()

	db := db.InitDB()

	// doMagic(db)
	// doList(db)
	doListWithJoins(db)
	// doCount(db)
	// doSave(db)
	// doDelete(db)
	// doGet(db)
	// doExists(db)
	// inheritance.DoInheritanceTest()
}