jean/time-tracker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add database object models and repositories for Activity, Company, Customer, Project, TimeEntry, and User with GORM integration

Browse Source
This commit is contained in:
Jean Jacques Avril
2025-03-10 07:29:34 +00:00
parent 4dda83904a
commit 17cb4505be
28 changed files with 786 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/internal/infrastructure/persistence/db/ds/activity_datasource.go
+66
View File
@@ -0,0 +1,66 @@
package ds
import (
"context"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type ActivityDatasource struct {
db *gorm.DB
}
func NewActivityDatasource(db *gorm.DB) persistence.ActivityDatasource {
return &ActivityDatasource{db: db}
}
func (r *ActivityDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.Activity, error) {
var activityDBO dbo.ActivityDBO
if err := r.db.WithContext(ctx).First(&activityDBO, "id = ?", id).Error; err != nil {
return nil, err
}
activity := &entities.Activity{
EntityBase: entities.EntityBase{
ID: activityDBO.ID,
CreatedAt: activityDBO.CreatedAt,
UpdatedAt: activityDBO.UpdatedAt,
},
Name: activityDBO.Name,
BillingRate: activityDBO.BillingRate,
}
return activity, nil
}
func (r *ActivityDatasource) Create(ctx context.Context, activity *entities.Activity) error {
activityDBO := dbo.ActivityDBO{
ID: activity.ID,
CreatedAt: activity.CreatedAt,
UpdatedAt: activity.UpdatedAt,
Name: activity.Name,
BillingRate: activity.BillingRate,
}
return r.db.WithContext(ctx).Create(&activityDBO).Error
}
func (r *ActivityDatasource) Update(ctx context.Context, activity *entities.Activity) error {
activityDBO := dbo.ActivityDBO{
ID: activity.ID,
CreatedAt: activity.CreatedAt,
UpdatedAt: activity.UpdatedAt,
Name: activity.Name,
BillingRate: activity.BillingRate,
}
return r.db.WithContext(ctx).Save(&activityDBO).Error
}
func (r *ActivityDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.ActivityDBO{}, "id = ?", id).Error
}
backend/internal/infrastructure/persistence/db/ds/company_datasource.go
+63
View File
@@ -0,0 +1,63 @@
package ds
import (
"context"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type CompanyyDatasource struct {
db *gorm.DB
}
func NewCompanyDatasource(db *gorm.DB) persistence.CompanyDatasource {
return &CompanyyDatasource{db: db}
}
func (r *CompanyyDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.Company, error) {
var companyDBO dbo.CompanyDBO
if err := r.db.WithContext(ctx).First(&companyDBO, "id = ?", id).Error; err != nil {
return nil, err
}
company := &entities.Company{
EntityBase: entities.EntityBase{
ID: companyDBO.ID,
CreatedAt: companyDBO.CreatedAt,
UpdatedAt: companyDBO.UpdatedAt,
},
Name: companyDBO.Name,
}
return company, nil
}
func (r *CompanyyDatasource) Create(ctx context.Context, company *entities.Company) error {
companyDBO := dbo.CompanyDBO{
ID: company.ID,
CreatedAt: company.CreatedAt,
UpdatedAt: company.UpdatedAt,
Name: company.Name,
}
return r.db.WithContext(ctx).Create(&companyDBO).Error
}
func (r *CompanyyDatasource) Update(ctx context.Context, company *entities.Company) error {
companyDBO := dbo.CompanyDBO{
ID: company.ID,
CreatedAt: company.CreatedAt,
UpdatedAt: company.UpdatedAt,
Name: company.Name,
}
return r.db.WithContext(ctx).Save(&companyDBO).Error
}
func (r *CompanyyDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.CompanyDBO{}, "id = ?", id).Error
}
backend/internal/infrastructure/persistence/db/ds/customer_datasource.go
+66
View File
@@ -0,0 +1,66 @@
package ds
import (
"context"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type CustomerDatasource struct {
db *gorm.DB
}
func NewCustomerDatasource(db *gorm.DB) persistence.CustomerDatasource {
return &CustomerDatasource{db: db}
}
func (r *CustomerDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.Customer, error) {
var customerDBO dbo.CustomerDBO
if err := r.db.WithContext(ctx).First(&customerDBO, "id = ?", id).Error; err != nil {
return nil, err
}
customer := &entities.Customer{
EntityBase: entities.EntityBase{
ID: customerDBO.ID,
CreatedAt: customerDBO.CreatedAt,
UpdatedAt: customerDBO.UpdatedAt,
},
Name: customerDBO.Name,
CompanyID: customerDBO.CompanyID,
}
return customer, nil
}
func (r *CustomerDatasource) Create(ctx context.Context, customer *entities.Customer) error {
customerDBO := dbo.CustomerDBO{
ID: customer.ID,
CreatedAt: customer.CreatedAt,
UpdatedAt: customer.UpdatedAt,
Name: customer.Name,
CompanyID: customer.CompanyID,
}
return r.db.WithContext(ctx).Create(&customerDBO).Error
}
func (r *CustomerDatasource) Update(ctx context.Context, customer *entities.Customer) error {
customerDBO := dbo.CustomerDBO{
ID: customer.ID,
CreatedAt: customer.CreatedAt,
UpdatedAt: customer.UpdatedAt,
Name: customer.Name,
CompanyID: customer.CompanyID,
}
return r.db.WithContext(ctx).Save(&customerDBO).Error
}
func (r *CustomerDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.CustomerDBO{}, "id = ?", id).Error
}
backend/internal/infrastructure/persistence/db/ds/project_datasource.go
+66
View File
@@ -0,0 +1,66 @@
package ds
import (
"context"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type ProjectDatasource struct {
db *gorm.DB
}
func NewProjectDatasource(db *gorm.DB) persistence.ProjectDatasource {
return &ProjectDatasource{db: db}
}
func (r *ProjectDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.Project, error) {
var projectDBO dbo.ProjectDBO
if err := r.db.WithContext(ctx).First(&projectDBO, "id = ?", id).Error; err != nil {
return nil, err
}
project := &entities.Project{
EntityBase: entities.EntityBase{
ID: projectDBO.ID,
CreatedAt: projectDBO.CreatedAt,
UpdatedAt: projectDBO.UpdatedAt,
},
Name: projectDBO.Name,
CustomerID: projectDBO.CustomerID,
}
return project, nil
}
func (r *ProjectDatasource) Create(ctx context.Context, project *entities.Project) error {
projectDBO := dbo.ProjectDBO{
ID: project.ID,
CreatedAt: project.CreatedAt,
UpdatedAt: project.UpdatedAt,
Name: project.Name,
CustomerID: project.CustomerID,
}
return r.db.WithContext(ctx).Create(&projectDBO).Error
}
func (r *ProjectDatasource) Update(ctx context.Context, project *entities.Project) error {
projectDBO := dbo.ProjectDBO{
ID: project.ID,
CreatedAt: project.CreatedAt,
UpdatedAt: project.UpdatedAt,
Name: project.Name,
CustomerID: project.CustomerID,
}
return r.db.WithContext(ctx).Save(&projectDBO).Error
}
func (r *ProjectDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.ProjectDBO{}, "id = ?", id).Error
}
backend/internal/infrastructure/persistence/db/ds/timeentry_datasource.go
+109
View File
@@ -0,0 +1,109 @@
package ds
import (
"context"
"time"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type TimeEntryDatasource struct {
db *gorm.DB
}
func NewTimeEntryDatasource(db *gorm.DB) persistence.TimeEntryDatasource {
return &TimeEntryDatasource{db: db}
}
func (r *TimeEntryDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.TimeEntry, error) {
var timeEntryDBO dbo.TimeEntryDBO
if err := r.db.WithContext(ctx).First(&timeEntryDBO, "id = ?", id).Error; err != nil {
return nil, err
}
timeEntry := &entities.TimeEntry{
EntityBase: entities.EntityBase{
ID: timeEntryDBO.ID,
CreatedAt: timeEntryDBO.CreatedAt,
UpdatedAt: timeEntryDBO.UpdatedAt,
},
UserID: timeEntryDBO.UserID,
ProjectID: timeEntryDBO.ProjectID,
ActivityID: timeEntryDBO.ActivityID,
Start: timeEntryDBO.Start,
End: timeEntryDBO.End,
Description: timeEntryDBO.Description,
Billable: timeEntryDBO.Billable,
}
return timeEntry, nil
}
func (r *TimeEntryDatasource) Create(ctx context.Context, timeEntry *entities.TimeEntry) error {
timeEntryDBO := dbo.TimeEntryDBO{
ID: timeEntry.ID,
CreatedAt: timeEntry.CreatedAt,
UpdatedAt: timeEntry.UpdatedAt,
UserID: timeEntry.UserID,
ProjectID: timeEntry.ProjectID,
ActivityID: timeEntry.ActivityID,
Start: timeEntry.Start,
End: timeEntry.End,
Description: timeEntry.Description,
Billable: timeEntry.Billable,
}
return r.db.WithContext(ctx).Create(&timeEntryDBO).Error
}
func (r *TimeEntryDatasource) Update(ctx context.Context, timeEntry *entities.TimeEntry) error {
timeEntryDBO := dbo.TimeEntryDBO{
ID: timeEntry.ID,
CreatedAt: timeEntry.CreatedAt,
UpdatedAt: timeEntry.UpdatedAt,
UserID: timeEntry.UserID,
ProjectID: timeEntry.ProjectID,
ActivityID: timeEntry.ActivityID,
Start: timeEntry.Start,
End: timeEntry.End,
Description: timeEntry.Description,
Billable: timeEntry.Billable,
}
return r.db.WithContext(ctx).Save(&timeEntryDBO).Error
}
func (r *TimeEntryDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.TimeEntryDBO{}, "id = ?", id).Error
}
func (r *TimeEntryDatasource) GetByRange(ctx context.Context, userID ulid.ULID, from time.Time, to time.Time) ([]*entities.TimeEntry, error) {
var timeEntryDBOs []*dbo.TimeEntryDBO
if err := r.db.WithContext(ctx).Where("user_id = ? AND start_time >= ? AND end_time <= ?", userID, from, to).Find(&timeEntryDBOs).Error; err != nil {
return nil, err
}
timeEntries := make([]*entities.TimeEntry, len(timeEntryDBOs))
for i, timeEntryDBO := range timeEntryDBOs {
timeEntries[i] = &entities.TimeEntry{
EntityBase: entities.EntityBase{
ID: timeEntryDBO.ID,
CreatedAt: timeEntryDBO.CreatedAt,
UpdatedAt: timeEntryDBO.UpdatedAt,
},
UserID: timeEntryDBO.UserID,
ProjectID: timeEntryDBO.ProjectID,
ActivityID: timeEntryDBO.ActivityID,
Start: timeEntryDBO.Start,
End: timeEntryDBO.End,
Description: timeEntryDBO.Description,
Billable: timeEntryDBO.Billable,
}
}
return timeEntries, nil
}
backend/internal/infrastructure/persistence/db/ds/user_datasource.go
+97
View File
@@ -0,0 +1,97 @@
package ds
import (
"context"
"github.com/oklog/ulid/v2"
"github.com/timetracker/backend/internal/domain/entities"
"github.com/timetracker/backend/internal/domain/persistence"
"github.com/timetracker/backend/internal/infrastructure/persistence/db/dbo"
"gorm.io/gorm"
)
type UserDatasource struct {
db *gorm.DB
}
func NewUserDatasource(db *gorm.DB) persistence.UserDatasource {
return &UserDatasource{db: db}
}
func (r *UserDatasource) Get(ctx context.Context, id ulid.ULID) (*entities.User, error) {
var userDBO dbo.UserDBO
if err := r.db.WithContext(ctx).First(&userDBO, "id = ?", id).Error; err != nil {
return nil, err
}
user := &entities.User{
EntityBase: entities.EntityBase{
ID: userDBO.ID,
CreatedAt: userDBO.CreatedAt,
UpdatedAt: userDBO.UpdatedAt,
},
Username: userDBO.Username,
Password: userDBO.Password,
Role: userDBO.Role,
CompanyID: userDBO.CompanyID,
HourlyRate: userDBO.HourlyRate,
}
return user, nil
}
func (r *UserDatasource) Create(ctx context.Context, user *entities.User) error {
userDBO := dbo.UserDBO{
ID: user.ID,
CreatedAt: user.CreatedAt,
UpdatedAt: user.UpdatedAt,
Username: user.Username,
Password: user.Password,
Role: user.Role,
CompanyID: user.CompanyID,
HourlyRate: user.HourlyRate,
}
return r.db.WithContext(ctx).Create(&userDBO).Error
}
func (r *UserDatasource) Update(ctx context.Context, user *entities.User) error {
userDBO := dbo.UserDBO{
ID: user.ID,
CreatedAt: user.CreatedAt,
UpdatedAt: user.UpdatedAt,
Username: user.Username,
Password: user.Password,
Role: user.Role,
CompanyID: user.CompanyID,
HourlyRate: user.HourlyRate,
}
return r.db.WithContext(ctx).Save(&userDBO).Error
}
func (r *UserDatasource) Delete(ctx context.Context, id ulid.ULID) error {
return r.db.WithContext(ctx).Delete(&dbo.UserDBO{}, "id = ?", id).Error
}
func (r *UserDatasource) GetByUsername(ctx context.Context, username string) (*entities.User, error) {
var userDBO dbo.UserDBO
if err := r.db.WithContext(ctx).Where("username = ?", username).First(&userDBO).Error; err != nil {
return nil, err
}
user := &entities.User{
EntityBase: entities.EntityBase{
ID: userDBO.ID,
CreatedAt: userDBO.CreatedAt,
UpdatedAt: userDBO.UpdatedAt,
},
Username: userDBO.Username,
Password: userDBO.Password,
Role: userDBO.Role,
CompanyID: userDBO.CompanyID,
HourlyRate: userDBO.HourlyRate,
}
return user, nil
}