implemented data sources with prisma in go
This commit is contained in:
+25
-25
@@ -1,25 +1,25 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
DatabaseURL string
|
||||
Port string
|
||||
}
|
||||
|
||||
func LoadConfig(path string) (*Config, error) {
|
||||
viper.AddConfigPath(path)
|
||||
viper.SetConfigName("config")
|
||||
viper.SetConfigType("yaml")
|
||||
|
||||
if err := viper.ReadInConfig(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Config{
|
||||
DatabaseURL: viper.GetString("database.url"),
|
||||
Port: viper.GetString("server.port"),
|
||||
}, nil
|
||||
}
|
||||
package config
|
||||
|
||||
import (
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
DatabaseURL string
|
||||
Port string
|
||||
}
|
||||
|
||||
func LoadConfig(path string) (*Config, error) {
|
||||
viper.AddConfigPath(path)
|
||||
viper.SetConfigName("config")
|
||||
viper.SetConfigType("yaml")
|
||||
|
||||
if err := viper.ReadInConfig(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Config{
|
||||
DatabaseURL: viper.GetString("database.url"),
|
||||
Port: viper.GetString("server.port"),
|
||||
}, nil
|
||||
}
|
||||
Executable → Regular
@@ -0,0 +1,22 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/app_error"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"errors"
|
||||
)
|
||||
|
||||
func handleDBError(err error, notFoundMessage string) error {
|
||||
if errors.Is(err, db.ErrNotFound) {
|
||||
return app_error.NewNotFoundError(notFoundMessage)
|
||||
}
|
||||
return app_error.NewInternalError(err)
|
||||
}
|
||||
|
||||
|
||||
func NullableField[T any](getter func() (T, bool)) *T {
|
||||
if value, ok := getter(); ok {
|
||||
return &value
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/entities"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
)
|
||||
|
||||
// Maps a Prisma User model to the domain User model.
|
||||
func mapPrismaUserToDomain(user db.UserDboModel) entities.User {
|
||||
return entities.User{
|
||||
ID: user.ID,
|
||||
Name: user.Name,
|
||||
Email: user.Email,
|
||||
Password: user.Password,
|
||||
CreatedAt: user.CreatedAt,
|
||||
UpdatedAt: user.UpdatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
// Maps a slice of Prisma User models to domain User models.
|
||||
func mapPrismaUsersToDomain(users []db.UserDboModel) []entities.User {
|
||||
domainUsers := make([]entities.User, len(users))
|
||||
for i, user := range users {
|
||||
domainUsers[i] = mapPrismaUserToDomain(user)
|
||||
}
|
||||
return domainUsers
|
||||
}
|
||||
|
||||
func mapPrismaProjectToDomain(project db.ProjectDboModel) entities.Project {
|
||||
return entities.Project{
|
||||
ID: project.ID,
|
||||
Name: project.Name,
|
||||
UserID: project.UserID,
|
||||
Description: NullableField(project.Description),
|
||||
ClientID: NullableField(project.ClientID),
|
||||
CreatedAt: project.CreatedAt,
|
||||
UpdatedAt: project.UpdatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
func mapPrismaProjectsToDomain(projects []db.ProjectDboModel) []entities.Project {
|
||||
domainProjects := make([]entities.Project, len(projects))
|
||||
for i, project := range projects {
|
||||
domainProjects[i] = mapPrismaProjectToDomain(project)
|
||||
}
|
||||
return domainProjects
|
||||
}
|
||||
|
||||
func mapPrismaTimeEntryToDomain(timeEntry db.TimeEntryDboModel) entities.TimeEntry {
|
||||
return entities.TimeEntry{
|
||||
ID: timeEntry.ID,
|
||||
ProjectID: timeEntry.ProjectID,
|
||||
UserID: timeEntry.UserID,
|
||||
StartTime: timeEntry.StartTime,
|
||||
EndTime: NullableField(timeEntry.EndTime),
|
||||
Description: NullableField(timeEntry.Description),
|
||||
CreatedAt: timeEntry.CreatedAt,
|
||||
UpdatedAt: timeEntry.UpdatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
func mapPrismaTimeEntriesToDomain(timeEntries []db.TimeEntryDboModel) []entities.TimeEntry {
|
||||
domainTimeEntries := make([]entities.TimeEntry, len(timeEntries))
|
||||
for i, timeEntry := range timeEntries {
|
||||
domainTimeEntries[i] = mapPrismaTimeEntryToDomain(timeEntry)
|
||||
}
|
||||
return domainTimeEntries
|
||||
}
|
||||
|
||||
func mapPrismaProjectTaskToDomain(projectTask db.ProjectTaskDboModel) entities.ProjectTask {
|
||||
return entities.ProjectTask{
|
||||
ID: projectTask.ID,
|
||||
ProjectID: projectTask.ProjectID,
|
||||
Name: projectTask.Name,
|
||||
Description: NullableField(projectTask.Description),
|
||||
CreatedAt: projectTask.CreatedAt,
|
||||
UpdatedAt: projectTask.UpdatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
func mapPrismaProjectTasksToDomain(projectTasks []db.ProjectTaskDboModel) []entities.ProjectTask {
|
||||
domainProjectTasks := make([]entities.ProjectTask, len(projectTasks))
|
||||
for i, projectTask := range projectTasks {
|
||||
domainProjectTasks[i] = mapPrismaProjectTaskToDomain(projectTask)
|
||||
}
|
||||
return domainProjectTasks
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/data"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"context"
|
||||
"log"
|
||||
)
|
||||
|
||||
// PrismaDatabase provides access to various data sources and manages the Prisma client.
|
||||
type PrismaDatabase struct {
|
||||
client *db.PrismaClient
|
||||
users data.UserDataSource
|
||||
timeEntries data.TimeEntryDataSource
|
||||
projectTasks data.ProjectTaskDataSource
|
||||
projects data.ProjectDataSource
|
||||
}
|
||||
|
||||
// NewPrismaDatabase initializes the Prisma client and the data sources.
|
||||
func NewPrismaDatabase() (*PrismaDatabase, error) {
|
||||
// Create a new Prisma client
|
||||
client := db.NewClient()
|
||||
|
||||
// Test the connection to ensure the client is working
|
||||
if err := client.Connect(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Initialize the database and data sources
|
||||
db := &PrismaDatabase{
|
||||
client: client,
|
||||
users: NewPrismaUserDataSource(client),
|
||||
timeEntries: NewPrismaTimeEntryDataSource(client),
|
||||
projectTasks: NewPrismaProjectTaskDataSource(client),
|
||||
projects: NewPrismaProjectDataSource(client),
|
||||
}
|
||||
|
||||
log.Println("Database initialized")
|
||||
return db, nil
|
||||
}
|
||||
|
||||
// Users returns the User data source.
|
||||
func (db *PrismaDatabase) Users() data.UserDataSource {
|
||||
return db.users
|
||||
}
|
||||
|
||||
// TimeEntries returns the TimeEntry data source.
|
||||
func (db *PrismaDatabase) TimeEntries() data.TimeEntryDataSource {
|
||||
return db.timeEntries
|
||||
}
|
||||
|
||||
// ProjectTasks returns the ProjectTask data source.
|
||||
func (db *PrismaDatabase) ProjectTasks() data.ProjectTaskDataSource {
|
||||
return db.projectTasks
|
||||
}
|
||||
|
||||
// Projects returns the Project data source.
|
||||
func (db *PrismaDatabase) Projects() data.ProjectDataSource {
|
||||
return db.projects
|
||||
}
|
||||
|
||||
// Close releases the Prisma client connection.
|
||||
func (db *PrismaDatabase) Close(ctx context.Context) error {
|
||||
log.Println("Closing database connection")
|
||||
return db.client.Disconnect();
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/app_error"
|
||||
"actatempus_backend/internal/domain/entities"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
E "github.com/IBM/fp-go/either"
|
||||
)
|
||||
|
||||
type PrismaProjectDataSource struct {
|
||||
client *db.PrismaClient
|
||||
}
|
||||
|
||||
func NewPrismaProjectDataSource(client *db.PrismaClient) *PrismaProjectDataSource {
|
||||
return &PrismaProjectDataSource{client: client}
|
||||
}
|
||||
|
||||
// Create a new project
|
||||
func (ds *PrismaProjectDataSource) Create(ctx context.Context, project entities.ProjectCreate) E.Either[error, entities.Project] {
|
||||
createdProject, err := ds.client.ProjectDbo.CreateOne(
|
||||
db.ProjectDbo.Name.Set(project.Name),
|
||||
db.ProjectDbo.User.Link(
|
||||
db.UserDbo.ID.Equals(project.UserID),
|
||||
),
|
||||
db.ProjectDbo.UserID.Set(project.UserID),
|
||||
db.ProjectDbo.Description.SetIfPresent(project.Description),
|
||||
db.ProjectDbo.ClientID.SetIfPresent(project.ClientID),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.Project,error](app_error.NewInternalError(err))
|
||||
}
|
||||
|
||||
if createdProject == nil {
|
||||
return E.Left[entities.Project,error](app_error.NewInternalError(fmt.Errorf("Could not create project")))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectToDomain(*createdProject))
|
||||
}
|
||||
|
||||
// FindByID retrieves a project by ID
|
||||
func (ds *PrismaProjectDataSource) FindByID(ctx context.Context, id string) E.Either[error, entities.Project] {
|
||||
project, err := ds.client.ProjectDbo.FindUnique(
|
||||
db.ProjectDbo.ID.Equals(id),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.Project](handleDBError(err, fmt.Sprintf("Project with ID %s not found", id)))
|
||||
}
|
||||
|
||||
if project == nil {
|
||||
return E.Left[entities.Project,error](app_error.NewNotFoundError(fmt.Sprintf("Project with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectToDomain(*project))
|
||||
}
|
||||
|
||||
// Update updates a project
|
||||
func (ds *PrismaProjectDataSource) Update(ctx context.Context, project entities.ProjectUpdate) E.Either[error, entities.Project] {
|
||||
|
||||
updatedProject, err := ds.client.ProjectDbo.FindUnique(
|
||||
db.ProjectDbo.ID.Equals(project.ID),
|
||||
).Update(
|
||||
db.ProjectDbo.Name.SetIfPresent(project.Name),
|
||||
db.ProjectDbo.Description.SetIfPresent(project.Description),
|
||||
db.ProjectDbo.ClientID.SetIfPresent(project.ClientID),
|
||||
db.ProjectDbo.User.Link(
|
||||
db.UserDbo.ID.EqualsIfPresent(project.UserID),
|
||||
),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.Project](handleDBError(err, fmt.Sprintf("Could not update project with ID %s", project.ID)))
|
||||
}
|
||||
|
||||
if updatedProject == nil {
|
||||
return E.Left[entities.Project,error](app_error.NewNotFoundError(fmt.Sprintf("Project with ID %s not found", project.ID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectToDomain(*updatedProject))
|
||||
}
|
||||
|
||||
// Delete removes a project
|
||||
func (ds *PrismaProjectDataSource) Delete(ctx context.Context, id string) E.Either[error, entities.Project] {
|
||||
deleted, err := ds.client.ProjectDbo.FindUnique(
|
||||
db.ProjectDbo.ID.Equals(id),
|
||||
).Delete().Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.Project](handleDBError(err, fmt.Sprintf("Could not delete project with ID %s", id)))
|
||||
}
|
||||
|
||||
if deleted == nil {
|
||||
return E.Left[entities.Project,error](app_error.NewNotFoundError(fmt.Sprintf("Project with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectToDomain(*deleted))
|
||||
}
|
||||
|
||||
// FindAll retrieves all projects
|
||||
func (ds *PrismaProjectDataSource) FindAll(ctx context.Context) E.Either[error, []entities.Project] {
|
||||
projects, err := ds.client.ProjectDbo.FindMany().Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.Project](handleDBError(err, "Could not retrieve projects"))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectsToDomain(projects))
|
||||
}
|
||||
|
||||
// FindByUserID retrieves all projects for a user
|
||||
func (ds *PrismaProjectDataSource) FindByUserID(ctx context.Context, userID string) E.Either[error, []entities.Project] {
|
||||
projects, err := ds.client.ProjectDbo.FindMany(
|
||||
db.ProjectDbo.UserID.Equals(userID),
|
||||
).Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.Project](handleDBError(err, fmt.Sprintf("Could not retrieve projects for user with ID %s", userID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectsToDomain(projects))
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/app_error"
|
||||
"actatempus_backend/internal/domain/entities"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
E "github.com/IBM/fp-go/either"
|
||||
)
|
||||
|
||||
type PrismaProjectTaskDataSource struct {
|
||||
client *db.PrismaClient
|
||||
}
|
||||
|
||||
func NewPrismaProjectTaskDataSource(client *db.PrismaClient) *PrismaProjectTaskDataSource {
|
||||
return &PrismaProjectTaskDataSource{client: client}
|
||||
}
|
||||
|
||||
// Create a new ProjectTask
|
||||
func (ds *PrismaProjectTaskDataSource) Create(ctx context.Context, task entities.ProjectTaskCreate) E.Either[error, entities.ProjectTask] {
|
||||
createdTask, err := ds.client.ProjectTaskDbo.CreateOne(
|
||||
db.ProjectTaskDbo.Name.Set(task.Name),
|
||||
db.ProjectTaskDbo.Project.Link(
|
||||
db.ProjectDbo.ID.Equals(task.ProjectID),
|
||||
),
|
||||
db.ProjectTaskDbo.Description.SetIfPresent(task.Description),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.ProjectTask,error](handleDBError(err, fmt.Sprintf("Could not create project task")))
|
||||
}
|
||||
|
||||
if createdTask == nil {
|
||||
return E.Left[entities.ProjectTask,error](app_error.NewInternalError(fmt.Errorf("Could not create project task")))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTaskToDomain(*createdTask))
|
||||
}
|
||||
|
||||
// Find ProjectTask by ID
|
||||
func (ds *PrismaProjectTaskDataSource) FindByID(ctx context.Context, id string) E.Either[error, entities.ProjectTask] {
|
||||
task, err := ds.client.ProjectTaskDbo.FindUnique(
|
||||
db.ProjectTaskDbo.ID.Equals(id),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.ProjectTask](handleDBError(err, fmt.Sprintf("ProjectTask with ID %s not found", id)))
|
||||
}
|
||||
|
||||
if task == nil {
|
||||
return E.Left[entities.ProjectTask,error](app_error.NewNotFoundError(fmt.Sprintf("ProjectTask with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTaskToDomain(*task))
|
||||
}
|
||||
|
||||
// Update an existing ProjectTask
|
||||
func (ds *PrismaProjectTaskDataSource) Update(ctx context.Context, task entities.ProjectTaskUpdate) E.Either[error, entities.ProjectTask] {
|
||||
updatedTask, err := ds.client.ProjectTaskDbo.FindUnique(
|
||||
db.ProjectTaskDbo.ID.Equals(task.ID),
|
||||
).Update(
|
||||
db.ProjectTaskDbo.Name.SetIfPresent(task.Name),
|
||||
db.ProjectTaskDbo.Description.SetIfPresent(task.Description),
|
||||
db.ProjectTaskDbo.Project.Link(
|
||||
db.ProjectDbo.ID.EqualsIfPresent(task.ProjectID),
|
||||
),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.ProjectTask](handleDBError(err, fmt.Sprintf("Could not update project task with ID %s", task.ID)))
|
||||
}
|
||||
|
||||
if updatedTask == nil {
|
||||
return E.Left[entities.ProjectTask,error](app_error.NewNotFoundError(fmt.Sprintf("ProjectTask with ID %s not found", task.ID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTaskToDomain(*updatedTask))
|
||||
}
|
||||
|
||||
// Delete a ProjectTask
|
||||
func (ds *PrismaProjectTaskDataSource) Delete(ctx context.Context, id string) E.Either[error, entities.ProjectTask] {
|
||||
deletedTask, err := ds.client.ProjectTaskDbo.FindUnique(
|
||||
db.ProjectTaskDbo.ID.Equals(id),
|
||||
).Delete().Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.ProjectTask](handleDBError(err, fmt.Sprintf("Could not delete project task with ID %s", id)))
|
||||
}
|
||||
|
||||
if deletedTask == nil {
|
||||
return E.Left[entities.ProjectTask,error](app_error.NewNotFoundError(fmt.Sprintf("ProjectTask with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTaskToDomain(*deletedTask))
|
||||
}
|
||||
|
||||
// FindAll retrieves all ProjectTasks
|
||||
func (ds *PrismaProjectTaskDataSource) FindAll(ctx context.Context) E.Either[error, []entities.ProjectTask] {
|
||||
tasks, err := ds.client.ProjectTaskDbo.FindMany().Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.ProjectTask](handleDBError(err, "Could not retrieve project tasks"))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTasksToDomain(tasks))
|
||||
}
|
||||
|
||||
// FindByProjectID retrieves all ProjectTasks for a given Project
|
||||
func (ds *PrismaProjectTaskDataSource) FindByProjectID(ctx context.Context, projectID string) E.Either[error, []entities.ProjectTask] {
|
||||
tasks, err := ds.client.ProjectTaskDbo.FindMany(
|
||||
db.ProjectTaskDbo.ProjectID.Equals(projectID),
|
||||
).Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.ProjectTask](handleDBError(err, fmt.Sprintf("Could not retrieve project tasks for project with ID %s", projectID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaProjectTasksToDomain(tasks))
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/app_error"
|
||||
"actatempus_backend/internal/domain/entities"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
E "github.com/IBM/fp-go/either"
|
||||
)
|
||||
|
||||
type PrismaTimeEntryDataSource struct {
|
||||
client *db.PrismaClient
|
||||
}
|
||||
|
||||
func NewPrismaTimeEntryDataSource(client *db.PrismaClient) *PrismaTimeEntryDataSource {
|
||||
return &PrismaTimeEntryDataSource{client: client}
|
||||
}
|
||||
|
||||
// Create a new TimeEntry
|
||||
func (ds *PrismaTimeEntryDataSource) Create(ctx context.Context, entry entities.TimeEntryCreate) E.Either[error, entities.TimeEntry] {
|
||||
createdEntry, err := ds.client.TimeEntryDbo.CreateOne(
|
||||
db.TimeEntryDbo.StartTime.Set(entry.StartTime),
|
||||
db.TimeEntryDbo.User.Link(
|
||||
db.UserDbo.ID.Equals(entry.UserID),
|
||||
), db.TimeEntryDbo.Project.Link(
|
||||
db.ProjectDbo.ID.Equals(entry.ProjectID),
|
||||
),
|
||||
db.TimeEntryDbo.EndTime.SetIfPresent(entry.EndTime),
|
||||
db.TimeEntryDbo.Description.SetIfPresent(entry.Description),
|
||||
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.TimeEntry,error](app_error.NewInternalError(err))
|
||||
}
|
||||
|
||||
if createdEntry == nil {
|
||||
return E.Left[entities.TimeEntry,error](app_error.NewInternalError(fmt.Errorf("Could not create time entry")))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntryToDomain(*createdEntry))
|
||||
}
|
||||
|
||||
// Find TimeEntry by ID
|
||||
func (ds *PrismaTimeEntryDataSource) FindByID(ctx context.Context, id string) E.Either[error, entities.TimeEntry] {
|
||||
entry, err := ds.client.TimeEntryDbo.FindUnique(
|
||||
db.TimeEntryDbo.ID.Equals(id),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.TimeEntry](handleDBError(err, fmt.Sprintf("TimeEntry with ID %s not found", id)))
|
||||
}
|
||||
|
||||
if entry == nil {
|
||||
return E.Left[entities.TimeEntry,error](app_error.NewNotFoundError(fmt.Sprintf("TimeEntry with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntryToDomain(*entry))
|
||||
}
|
||||
|
||||
// Update an existing TimeEntry
|
||||
func (ds *PrismaTimeEntryDataSource) Update(ctx context.Context, entry entities.TimeEntryUpdate) E.Either[error, entities.TimeEntry] {
|
||||
updatedEntry, err := ds.client.TimeEntryDbo.FindUnique(
|
||||
db.TimeEntryDbo.ID.Equals(entry.ID),
|
||||
).Update(
|
||||
db.TimeEntryDbo.StartTime.SetIfPresent(entry.StartTime),
|
||||
db.TimeEntryDbo.EndTime.SetIfPresent(entry.EndTime),
|
||||
db.TimeEntryDbo.Description.SetIfPresent(entry.Description),
|
||||
db.TimeEntryDbo.User.Link(
|
||||
db.UserDbo.ID.EqualsIfPresent(entry.UserID),
|
||||
),
|
||||
db.TimeEntryDbo.Project.Link(
|
||||
db.ProjectDbo.ID.EqualsIfPresent(entry.ProjectID),
|
||||
),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.TimeEntry,error](handleDBError(err, fmt.Sprintf("Could not update time entry with ID %s", entry.ID)))
|
||||
}
|
||||
|
||||
if updatedEntry == nil {
|
||||
return E.Left[entities.TimeEntry,error](app_error.NewNotFoundError(fmt.Sprintf("TimeEntry with ID %s not found", entry.ID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntryToDomain(*updatedEntry))
|
||||
}
|
||||
|
||||
// Delete a TimeEntry
|
||||
func (ds *PrismaTimeEntryDataSource) Delete(ctx context.Context, id string) E.Either[error, entities.TimeEntry] {
|
||||
deletedEntry, err := ds.client.TimeEntryDbo.FindUnique(
|
||||
db.TimeEntryDbo.ID.Equals(id),
|
||||
).Delete().Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.TimeEntry](handleDBError(err, fmt.Sprintf("Could not delete time entry with ID %s", id)))
|
||||
}
|
||||
|
||||
if deletedEntry == nil {
|
||||
return E.Left[entities.TimeEntry,error](app_error.NewNotFoundError(fmt.Sprintf("TimeEntry with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntryToDomain(*deletedEntry))
|
||||
}
|
||||
|
||||
// FindAll retrieves all TimeEntries
|
||||
func (ds *PrismaTimeEntryDataSource) FindAll(ctx context.Context) E.Either[error, []entities.TimeEntry] {
|
||||
entries, err := ds.client.TimeEntryDbo.FindMany().Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.TimeEntry](handleDBError(err, "Could not retrieve time entries"))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntriesToDomain(entries))
|
||||
}
|
||||
|
||||
// FindByUserID retrieves all TimeEntries by UserID
|
||||
func (ds *PrismaTimeEntryDataSource) FindByUserID(ctx context.Context, userID string) E.Either[error, []entities.TimeEntry] {
|
||||
entries, err := ds.client.TimeEntryDbo.FindMany(
|
||||
db.TimeEntryDbo.UserID.Equals(userID),
|
||||
).Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.TimeEntry](handleDBError(err, fmt.Sprintf("Could not retrieve time entries for user with ID %s", userID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntriesToDomain(entries))
|
||||
}
|
||||
|
||||
|
||||
// FindByProjectID retrieves all TimeEntries by ProjectID
|
||||
func (ds *PrismaTimeEntryDataSource) FindByProjectID(ctx context.Context, projectID string) E.Either[error, []entities.TimeEntry] {
|
||||
entries, err := ds.client.TimeEntryDbo.FindMany(
|
||||
db.TimeEntryDbo.ProjectID.Equals(projectID),
|
||||
).Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.TimeEntry](handleDBError(err, fmt.Sprintf("Could not retrieve time entries for project with ID %s", projectID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaTimeEntriesToDomain(entries))
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"actatempus_backend/internal/domain/app_error"
|
||||
"actatempus_backend/internal/domain/entities"
|
||||
"actatempus_backend/internal/infrastructure/data/db"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
E "github.com/IBM/fp-go/either"
|
||||
)
|
||||
|
||||
type PrismaUserDataSource struct {
|
||||
client *db.PrismaClient
|
||||
}
|
||||
|
||||
func NewPrismaUserDataSource(client *db.PrismaClient) *PrismaUserDataSource {
|
||||
return &PrismaUserDataSource{client: client}
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) Create(ctx context.Context, user entities.UserCreate) E.Either[error,entities.User] {
|
||||
createdUser, err := ds.client.UserDbo.CreateOne(
|
||||
db.UserDbo.Name.Set(user.Name),
|
||||
db.UserDbo.Email.Set(user.Email),
|
||||
db.UserDbo.Password.Set(user.Password),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.User,error](app_error.NewInternalError(err))
|
||||
}
|
||||
if createdUser == nil {
|
||||
return E.Left[entities.User,error](app_error.NewInternalError(fmt.Errorf("Could not create user")))
|
||||
}
|
||||
return E.Right[error](mapPrismaUserToDomain(*createdUser))
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) FindByID(ctx context.Context, id string) E.Either[error,entities.User] {
|
||||
user, err := ds.client.UserDbo.FindUnique(
|
||||
db.UserDbo.ID.Equals(id),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.User,error](handleDBError(err, fmt.Sprintf("Query for user with ID %s failed", id)))
|
||||
}
|
||||
|
||||
if user == nil {
|
||||
return E.Left[entities.User,error](app_error.NewNotFoundError(fmt.Sprintf("User with ID %s not found", id)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaUserToDomain(*user))
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) FindByEmail(ctx context.Context, email string) E.Either[error,entities.User]{
|
||||
user, err := ds.client.UserDbo.FindUnique(
|
||||
db.UserDbo.Email.Equals(email),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.User,error](handleDBError(err, fmt.Sprintf("Query for user with email %s failed", email)))
|
||||
|
||||
}
|
||||
|
||||
if user == nil {
|
||||
return E.Left[entities.User,error](app_error.NewNotFoundError(fmt.Sprintf("User with email %s not found", email)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaUserToDomain(*user))
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) Update(ctx context.Context, user entities.UserUpdate) E.Either[error,entities.User] {
|
||||
|
||||
updatedUser, err := ds.client.UserDbo.FindUnique(
|
||||
db.UserDbo.ID.Equals(user.ID),
|
||||
).Update(
|
||||
db.UserDbo.Name.SetIfPresent(user.Name),
|
||||
db.UserDbo.Email.SetIfPresent(user.Email),
|
||||
db.UserDbo.Password.SetIfPresent(user.Password),
|
||||
).Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.User,error](handleDBError(err, fmt.Sprintf("Could not update user with ID %s", user.ID)))
|
||||
}
|
||||
|
||||
if updatedUser == nil {
|
||||
return E.Left[entities.User,error](app_error.NewNotFoundError(fmt.Sprintf("User with ID %s not found", user.ID)))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaUserToDomain(*updatedUser))
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) Delete(ctx context.Context, id string) E.Either[error,entities.User] {
|
||||
deleted, err := ds.client.UserDbo.FindUnique(
|
||||
db.UserDbo.ID.Equals(id),
|
||||
).Delete().Exec(ctx)
|
||||
|
||||
if err != nil {
|
||||
return E.Left[entities.User,error](handleDBError(err, fmt.Sprintf("Could not delete user with ID %s", id)))
|
||||
}
|
||||
|
||||
if deleted == nil {
|
||||
return E.Left[entities.User,error](app_error.NewNotFoundError(fmt.Sprintf("User with ID %s not found", id)))
|
||||
}
|
||||
|
||||
|
||||
return E.Right[error](mapPrismaUserToDomain(*deleted))
|
||||
}
|
||||
|
||||
func (ds *PrismaUserDataSource) FindAll(ctx context.Context) E.Either[error,[]entities.User] {
|
||||
users, err := ds.client.UserDbo.FindMany().Exec(ctx)
|
||||
if err != nil {
|
||||
return E.Left[[]entities.User,error](handleDBError(err, "Could not retrieve users"))
|
||||
}
|
||||
|
||||
return E.Right[error](mapPrismaUsersToDomain(users))
|
||||
}
|
||||
Reference in New Issue
Block a user