letter incoming

2025-08-09 18:58:22 +07:00
parent 001d02c587
commit 61d6eed373
37 changed files with 2773 additions and 33 deletions
@@ -0,0 +1,45 @@
+package repository
+
+import (
+	"context"
+
+	"eslogad-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type DispositionRouteRepository struct{ db *gorm.DB }
+
+func NewDispositionRouteRepository(db *gorm.DB) *DispositionRouteRepository {
+	return &DispositionRouteRepository{db: db}
+}
+
+func (r *DispositionRouteRepository) Create(ctx context.Context, e *entities.DispositionRoute) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+func (r *DispositionRouteRepository) Update(ctx context.Context, e *entities.DispositionRoute) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Model(&entities.DispositionRoute{}).Where("id = ?", e.ID).Updates(e).Error
+}
+func (r *DispositionRouteRepository) Get(ctx context.Context, id uuid.UUID) (*entities.DispositionRoute, error) {
+	db := DBFromContext(ctx, r.db)
+	var e entities.DispositionRoute
+	if err := db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+func (r *DispositionRouteRepository) ListByFromDept(ctx context.Context, fromDept uuid.UUID) ([]entities.DispositionRoute, error) {
+	db := DBFromContext(ctx, r.db)
+	var list []entities.DispositionRoute
+	if err := db.WithContext(ctx).Where("from_department_id = ?", fromDept).Order("to_department_id").Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+func (r *DispositionRouteRepository) SetActive(ctx context.Context, id uuid.UUID, isActive bool) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Model(&entities.DispositionRoute{}).Where("id = ?", id).Update("is_active", isActive).Error
+}
@@ -0,0 +1,180 @@
+package repository
+
+import (
+	"context"
+	"time"
+
+	"eslogad-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type LetterIncomingRepository struct{ db *gorm.DB }
+
+func NewLetterIncomingRepository(db *gorm.DB) *LetterIncomingRepository {
+	return &LetterIncomingRepository{db: db}
+}
+
+func (r *LetterIncomingRepository) Create(ctx context.Context, e *entities.LetterIncoming) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+func (r *LetterIncomingRepository) Get(ctx context.Context, id uuid.UUID) (*entities.LetterIncoming, error) {
+	db := DBFromContext(ctx, r.db)
+	var e entities.LetterIncoming
+	if err := db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+
+func (r *LetterIncomingRepository) Update(ctx context.Context, e *entities.LetterIncoming) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Model(&entities.LetterIncoming{}).Where("id = ? AND deleted_at IS NULL", e.ID).Updates(e).Error
+}
+
+func (r *LetterIncomingRepository) SoftDelete(ctx context.Context, id uuid.UUID) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Exec("UPDATE letters_incoming SET deleted_at = CURRENT_TIMESTAMP WHERE id = ? AND deleted_at IS NULL", id).Error
+}
+
+type ListIncomingLettersFilter struct {
+	Status *string
+	Query  *string
+}
+
+func (r *LetterIncomingRepository) List(ctx context.Context, filter ListIncomingLettersFilter, limit, offset int) ([]entities.LetterIncoming, int64, error) {
+	db := DBFromContext(ctx, r.db)
+	query := db.WithContext(ctx).Model(&entities.LetterIncoming{}).Where("deleted_at IS NULL")
+	if filter.Status != nil {
+		query = query.Where("status = ?", *filter.Status)
+	}
+	if filter.Query != nil {
+		q := "%" + *filter.Query + "%"
+		query = query.Where("subject ILIKE ? OR reference_number ILIKE ?", q, q)
+	}
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+	var list []entities.LetterIncoming
+	if err := query.Order("created_at DESC").Limit(limit).Offset(offset).Find(&list).Error; err != nil {
+		return nil, 0, err
+	}
+	return list, total, nil
+}
+
+type LetterIncomingAttachmentRepository struct{ db *gorm.DB }
+
+func NewLetterIncomingAttachmentRepository(db *gorm.DB) *LetterIncomingAttachmentRepository {
+	return &LetterIncomingAttachmentRepository{db: db}
+}
+
+func (r *LetterIncomingAttachmentRepository) CreateBulk(ctx context.Context, list []entities.LetterIncomingAttachment) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(&list).Error
+}
+func (r *LetterIncomingAttachmentRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterIncomingAttachment, error) {
+	db := DBFromContext(ctx, r.db)
+	var list []entities.LetterIncomingAttachment
+	if err := db.WithContext(ctx).Where("letter_id = ?", letterID).Order("uploaded_at ASC").Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+type LetterIncomingActivityLogRepository struct{ db *gorm.DB }
+
+func NewLetterIncomingActivityLogRepository(db *gorm.DB) *LetterIncomingActivityLogRepository {
+	return &LetterIncomingActivityLogRepository{db: db}
+}
+
+func (r *LetterIncomingActivityLogRepository) Create(ctx context.Context, e *entities.LetterIncomingActivityLog) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+
+func (r *LetterIncomingActivityLogRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterIncomingActivityLog, error) {
+	db := DBFromContext(ctx, r.db)
+	var list []entities.LetterIncomingActivityLog
+	if err := db.WithContext(ctx).Where("letter_id = ?", letterID).Order("occurred_at ASC").Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+type LetterDispositionRepository struct{ db *gorm.DB }
+
+func NewLetterDispositionRepository(db *gorm.DB) *LetterDispositionRepository {
+	return &LetterDispositionRepository{db: db}
+}
+func (r *LetterDispositionRepository) Create(ctx context.Context, e *entities.LetterDisposition) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+func (r *LetterDispositionRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterDisposition, error) {
+	db := DBFromContext(ctx, r.db)
+	var list []entities.LetterDisposition
+	if err := db.WithContext(ctx).Where("letter_id = ?", letterID).Order("created_at ASC").Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+type DispositionNoteRepository struct{ db *gorm.DB }
+
+func NewDispositionNoteRepository(db *gorm.DB) *DispositionNoteRepository {
+	return &DispositionNoteRepository{db: db}
+}
+func (r *DispositionNoteRepository) Create(ctx context.Context, e *entities.DispositionNote) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+
+type LetterDispositionActionSelectionRepository struct{ db *gorm.DB }
+
+func NewLetterDispositionActionSelectionRepository(db *gorm.DB) *LetterDispositionActionSelectionRepository {
+	return &LetterDispositionActionSelectionRepository{db: db}
+}
+func (r *LetterDispositionActionSelectionRepository) CreateBulk(ctx context.Context, list []entities.LetterDispositionActionSelection) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(&list).Error
+}
+func (r *LetterDispositionActionSelectionRepository) ListByDisposition(ctx context.Context, dispositionID uuid.UUID) ([]entities.LetterDispositionActionSelection, error) {
+	db := DBFromContext(ctx, r.db)
+	var list []entities.LetterDispositionActionSelection
+	if err := db.WithContext(ctx).Where("disposition_id = ?", dispositionID).Order("created_at ASC").Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+type LetterDiscussionRepository struct{ db *gorm.DB }
+
+func NewLetterDiscussionRepository(db *gorm.DB) *LetterDiscussionRepository {
+	return &LetterDiscussionRepository{db: db}
+}
+func (r *LetterDiscussionRepository) Create(ctx context.Context, e *entities.LetterDiscussion) error {
+	db := DBFromContext(ctx, r.db)
+	return db.WithContext(ctx).Create(e).Error
+}
+func (r *LetterDiscussionRepository) Get(ctx context.Context, id uuid.UUID) (*entities.LetterDiscussion, error) {
+	db := DBFromContext(ctx, r.db)
+	var e entities.LetterDiscussion
+	if err := db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+func (r *LetterDiscussionRepository) Update(ctx context.Context, e *entities.LetterDiscussion) error {
+	db := DBFromContext(ctx, r.db)
+	// ensure edited_at is set when updating
+	if e.EditedAt == nil {
+		now := time.Now()
+		e.EditedAt = &now
+	}
+	return db.WithContext(ctx).Model(&entities.LetterDiscussion{}).
+		Where("id = ?", e.ID).
+		Updates(map[string]interface{}{"message": e.Message, "mentions": e.Mentions, "edited_at": e.EditedAt}).Error
+}
@@ -0,0 +1,114 @@
+package repository
+
+import (
+	"context"
+
+	"eslogad-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type LabelRepository struct{ db *gorm.DB }
+
+func NewLabelRepository(db *gorm.DB) *LabelRepository { return &LabelRepository{db: db} }
+func (r *LabelRepository) Create(ctx context.Context, e *entities.Label) error {
+	return r.db.WithContext(ctx).Create(e).Error
+}
+func (r *LabelRepository) Update(ctx context.Context, e *entities.Label) error {
+	return r.db.WithContext(ctx).Model(&entities.Label{}).Where("id = ?", e.ID).Updates(e).Error
+}
+func (r *LabelRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.Label{}, "id = ?", id).Error
+}
+func (r *LabelRepository) List(ctx context.Context) ([]entities.Label, error) {
+	var list []entities.Label
+	err := r.db.WithContext(ctx).Order("name ASC").Find(&list).Error
+	return list, err
+}
+func (r *LabelRepository) Get(ctx context.Context, id uuid.UUID) (*entities.Label, error) {
+	var e entities.Label
+	if err := r.db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+
+type PriorityRepository struct{ db *gorm.DB }
+
+func NewPriorityRepository(db *gorm.DB) *PriorityRepository { return &PriorityRepository{db: db} }
+func (r *PriorityRepository) Create(ctx context.Context, e *entities.Priority) error {
+	return r.db.WithContext(ctx).Create(e).Error
+}
+func (r *PriorityRepository) Update(ctx context.Context, e *entities.Priority) error {
+	return r.db.WithContext(ctx).Model(&entities.Priority{}).Where("id = ?", e.ID).Updates(e).Error
+}
+func (r *PriorityRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.Priority{}, "id = ?", id).Error
+}
+func (r *PriorityRepository) List(ctx context.Context) ([]entities.Priority, error) {
+	var list []entities.Priority
+	err := r.db.WithContext(ctx).Order("level ASC").Find(&list).Error
+	return list, err
+}
+func (r *PriorityRepository) Get(ctx context.Context, id uuid.UUID) (*entities.Priority, error) {
+	var e entities.Priority
+	if err := r.db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+
+type InstitutionRepository struct{ db *gorm.DB }
+
+func NewInstitutionRepository(db *gorm.DB) *InstitutionRepository {
+	return &InstitutionRepository{db: db}
+}
+func (r *InstitutionRepository) Create(ctx context.Context, e *entities.Institution) error {
+	return r.db.WithContext(ctx).Create(e).Error
+}
+func (r *InstitutionRepository) Update(ctx context.Context, e *entities.Institution) error {
+	return r.db.WithContext(ctx).Model(&entities.Institution{}).Where("id = ?", e.ID).Updates(e).Error
+}
+func (r *InstitutionRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.Institution{}, "id = ?", id).Error
+}
+func (r *InstitutionRepository) List(ctx context.Context) ([]entities.Institution, error) {
+	var list []entities.Institution
+	err := r.db.WithContext(ctx).Order("name ASC").Find(&list).Error
+	return list, err
+}
+func (r *InstitutionRepository) Get(ctx context.Context, id uuid.UUID) (*entities.Institution, error) {
+	var e entities.Institution
+	if err := r.db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
+
+type DispositionActionRepository struct{ db *gorm.DB }
+
+func NewDispositionActionRepository(db *gorm.DB) *DispositionActionRepository {
+	return &DispositionActionRepository{db: db}
+}
+func (r *DispositionActionRepository) Create(ctx context.Context, e *entities.DispositionAction) error {
+	return r.db.WithContext(ctx).Create(e).Error
+}
+func (r *DispositionActionRepository) Update(ctx context.Context, e *entities.DispositionAction) error {
+	return r.db.WithContext(ctx).Model(&entities.DispositionAction{}).Where("id = ?", e.ID).Updates(e).Error
+}
+func (r *DispositionActionRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.DispositionAction{}, "id = ?", id).Error
+}
+func (r *DispositionActionRepository) List(ctx context.Context) ([]entities.DispositionAction, error) {
+	var list []entities.DispositionAction
+	err := r.db.WithContext(ctx).Order("sort_order NULLS LAST, label ASC").Find(&list).Error
+	return list, err
+}
+func (r *DispositionActionRepository) Get(ctx context.Context, id uuid.UUID) (*entities.DispositionAction, error) {
+	var e entities.DispositionAction
+	if err := r.db.WithContext(ctx).First(&e, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &e, nil
+}
@@ -0,0 +1,35 @@
+package repository
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+)
+
+type txKeyType struct{}
+
+var txKey = txKeyType{}
+
+// DBFromContext returns the transactional *gorm.DB from context if present; otherwise returns base.
+func DBFromContext(ctx context.Context, base *gorm.DB) *gorm.DB {
+	if v := ctx.Value(txKey); v != nil {
+		if tx, ok := v.(*gorm.DB); ok && tx != nil {
+			return tx
+		}
+	}
+	return base
+}
+
+type TxManager struct {
+	db *gorm.DB
+}
+
+func NewTxManager(db *gorm.DB) *TxManager { return &TxManager{db: db} }
+
+// WithTransaction runs fn inside a DB transaction, injecting the *gorm.DB tx into ctx.
+func (m *TxManager) WithTransaction(ctx context.Context, fn func(ctx context.Context) error) error {
+	return m.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		ctxTx := context.WithValue(ctx, txKey, tx)
+		return fn(ctxTx)
+	})
+}