first commit

2026-08-08 23:12:37 +02:00
parent ff6ef46cd4
commit e3fd942c47
20 changed files with 494 additions and 271 deletions
@@ -1,90 +1,143 @@
 package turso

 import (
-	"github.com/jmoiron/sqlx"
-	"trankilou.fr/lassistanoque/backend/internal/adapter/database/dberrors"
+	"database/sql"
+	"log"
+
 	"trankilou.fr/lassistanoque/backend/internal/domain"
-	"trankilou.fr/lassistanoque/backend/internal/utility"
+
+	"gitea.trankilou.fr/fabien/lasebuche"
 )

 type TursoUserRepository struct {
-	DB *sqlx.DB
+	DB            *sql.DB
+	UserTable     lasebuche.Table[domain.User]
+	TeamTable     lasebuche.Table[domain.Team]
+	UserTeamTable lasebuche.Table[domain.UserTeam]
+	AddressTable  lasebuche.Table[domain.UserAddress]
+}
+
+func NewTursoUserRepository(db *sql.DB) *TursoUserRepository {
+	dialect := lasebuche.NewSqliteDialect()
+	userTable, err := lasebuche.NewTable[domain.User](db, dialect, "users")
+	if err != nil {
+		log.Fatalf("error creating lasebuche user table")
+	}
+	teamTable, err := lasebuche.NewTable[domain.Team](db, dialect, "teams")
+	if err != nil {
+		log.Fatalf("error creating lasebuche team table")
+	}
+	userTeamTable, err := lasebuche.NewTable[domain.UserTeam](db, dialect, "user_teams")
+	if err != nil {
+		log.Fatalf("error creating lasebuche team table")
+	}
+	userAddressTable, err := lasebuche.NewTable[domain.UserAddress](db, dialect, "user_addresses")
+	if err != nil {
+		log.Fatalf("error creating lasebuche team table")
+	}
+	return &TursoUserRepository{
+		DB:            db,
+		UserTable:     userTable,
+		TeamTable:     teamTable,
+		UserTeamTable: userTeamTable,
+		AddressTable:  userAddressTable,
+	}
 }

 func (ur *TursoUserRepository) FindUser(id string) (*domain.User, error) {
-	var user domain.User
-	err := ur.DB.Get(&user, "select * from users where id=$1", id)
-	return &user, err
+	return ur.UserTable.Get(id)
 }

 func (ur *TursoUserRepository) FindUserByEmail(email string) (*domain.User, error) {
-	var user domain.User
-	err := ur.DB.Get(&user, "select * from users where email=$1", email)
-	return &user, err
-}
-
-func (ur *TursoUserRepository) CountUsers() (int, error) {
-	var count int
-	err := ur.DB.Get(&count, "select count(*) from users")
-	return count, err
+	return ur.UserTable.SelectOne("email=$1", email)
 }

 func (ur *TursoUserRepository) ListUsers() ([]*domain.User, error) {
-	var users []*domain.User
-	err := ur.DB.Select(&users, "select * from users order by lastname, firstname")
-	return users, err
+	return ur.UserTable.SelectWhere("")
 }

 func (ur *TursoUserRepository) CreateUser(user *domain.User) (*domain.User, error) {
-
-	user.ID = utility.GenID()
-	user.VersionId = utility.GenID()
-
-	_, err := ur.DB.NamedExec(
-		`insert into users (id, email, firstname, lastname, enabled, password,  administrator, _version)
-		 values (:id, :email, :firstname, :lastname, :enabled, :password, :administrator, :_version)`,
-		user)
-	if err != nil {
-		return nil, err
-	}
-
-	return user, nil
+	return ur.UserTable.Insert(user)
 }

 func (ur *TursoUserRepository) UpdateUser(user *domain.User) (*domain.User, error) {
-
-	newVersion := utility.GenID()
-
-	res, err := ur.DB.Exec(
-		`update users
-		 set email=$1,
-			firstname=$2,
-			lastname=$3,
-			enabled=$4,
-			administrator=$5
-			_version=:$6
-		 where id=$7 and _version=$8`,
-		user.Email, user.Firstname, user.Lastname,
-		user.Enabled, user.Administrator,
-		newVersion, user.ID, user.VersionId,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	if count, _ := res.RowsAffected(); count == 0 {
-		return nil, dberrors.ErrNoRowUpdated
-	}
-
-	user.VersionId = newVersion
-
-	return user, nil
+	return ur.UserTable.Update(user)
 }

 func (ur *TursoUserRepository) DeleteUser(id string) error {
-	res, err := ur.DB.Exec("delete from users where id=$1", id)
-	if count, _ := res.RowsAffected(); count == 0 {
-		return dberrors.ErrNoRowUpdated
-	}
-	return err
+	return ur.UserTable.Delete(id)
+}
+
+func (ur *TursoUserRepository) FindTeam(userid string, teamid string) (*domain.Team, error) {
+	return ur.TeamTable.SelectOne("id=$1 and user_id=$2", teamid, userid)
+}
+
+func (ur *TursoUserRepository) ListTeams(userid string) ([]*domain.Team, error) {
+	return ur.TeamTable.SelectWhere("user_id=$1", userid)
+}
+
+func (ur *TursoUserRepository) CreateTeam(userid string, team *domain.Team) (*domain.Team, error) {
+	// TODO : gérér dans une transaction
+	// TODO : déplacer dans le service
+	team, err := ur.TeamTable.Insert(team)
+	if err != nil {
+		return nil, err
+	}
+	userTeam := &domain.UserTeam{
+		UserID:        userid,
+		TeamID:        team.ID,
+		Administrator: true,
+	}
+	_, err = ur.UserTeamTable.Insert(userTeam)
+	if err != nil {
+		return nil, err
+	}
+	return team, nil
+}
+
+func (ur *TursoUserRepository) UpdateTeam(userid string, team *domain.Team) (*domain.Team, error) {
+	return ur.TeamTable.Update(team)
+}
+
+func (ur *TursoUserRepository) DeleteTeam(userid string, teamid string) error {
+	return ur.TeamTable.Delete(teamid)
+}
+
+func (ur *TursoUserRepository) FindUserTeam(userid string, teamid string) (*domain.UserTeam, error) {
+	return ur.UserTeamTable.SelectOne("team_id=$1 and user_id=$2", teamid, userid)
+}
+
+func (ur *TursoUserRepository) ListUserTeams(userid string) ([]*domain.UserTeam, error) {
+	return ur.UserTeamTable.SelectWhere("user_id=$1", userid)
+}
+
+func (ur *TursoUserRepository) CreateUserTeam(userid string, team *domain.UserTeam) (*domain.UserTeam, error) {
+	return ur.UserTeamTable.Insert(team)
+}
+
+func (ur *TursoUserRepository) UpdateUserTeam(userid string, team *domain.UserTeam) (*domain.UserTeam, error) {
+	return ur.UserTeamTable.Update(team)
+}
+
+func (ur *TursoUserRepository) DeleteUserTeam(userid string, teamid string) error {
+	return ur.UserTeamTable.Delete(teamid)
+}
+
+func (ur *TursoUserRepository) PopulateUserWithTeams(user *domain.User) (*domain.UserWithTeams, error) {
+	return nil, nil
+}
+
+func (ur *TursoUserRepository) ListUserAddresses(id string) ([]*domain.UserAddress, error) {
+	return ur.AddressTable.SelectWhere("user_id=$1", id)
+}
+
+func (ur *TursoUserRepository) CreateUserAddress(userid string, addr *domain.UserAddress) (*domain.UserAddress, error) {
+	addr.UserID = userid
+	return ur.AddressTable.Insert(addr)
+}
+func (ur *TursoUserRepository) UpdateUserAddress(userid string, addr *domain.UserAddress) (*domain.UserAddress, error) {
+	return ur.AddressTable.Update(addr)
+}
+func (ur *TursoUserRepository) DeleteUserAddress(userid string, addrID string) error {
+	return ur.AddressTable.DeleteWhere("id=$1 and user_id=$2", addrID, userid)
 }