994 lines
35 KiB
Go
994 lines
35 KiB
Go
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) GetByReferenceNumber(ctx context.Context, refNumber *string) (*entities.LetterIncoming, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var e entities.LetterIncoming
|
|
if err := db.WithContext(ctx).
|
|
Where("reference_number = ? AND deleted_at IS NULL", refNumber).
|
|
First(&e).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &e, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.LetterIncoming, error) {
|
|
return r.Get(ctx, id)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) BulkSoftDelete(ctx context.Context, ids []uuid.UUID) error {
|
|
if len(ids) == 0 {
|
|
return nil
|
|
}
|
|
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Exec("UPDATE letters_incoming SET deleted_at = CURRENT_TIMESTAMP WHERE id IN ? AND deleted_at IS NULL", ids).Error
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) BulkArchive(ctx context.Context, letterIDs []uuid.UUID) (int64, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
now := time.Now()
|
|
result := db.WithContext(ctx).
|
|
Model(&entities.LetterIncoming{}).
|
|
Where("id IN ? AND deleted_at IS NULL", letterIDs).
|
|
Updates(map[string]interface{}{
|
|
"is_archived": true,
|
|
"archived_at": now,
|
|
})
|
|
return result.RowsAffected, result.Error
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) Archive(ctx context.Context, letterID uuid.UUID) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
now := time.Now()
|
|
return db.WithContext(ctx).
|
|
Model(&entities.LetterIncoming{}).
|
|
Where("id = ? AND deleted_at IS NULL", letterID).
|
|
Updates(map[string]interface{}{
|
|
"is_archived": true,
|
|
"archived_at": now,
|
|
}).Error
|
|
}
|
|
|
|
// BulkArchiveForUser archives letters for a specific user only
|
|
func (r *LetterIncomingRepository) BulkArchiveForUser(ctx context.Context, letterIDs []uuid.UUID, userID uuid.UUID) (int64, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
// Archive only the recipient records for the specific user
|
|
// Note: letter_incoming_recipients uses recipient_user_id column
|
|
result := db.WithContext(ctx).
|
|
Model(&entities.LetterIncomingRecipient{}).
|
|
Where("letter_id IN ? AND recipient_user_id = ?", letterIDs, userID).
|
|
Update("is_archived", true)
|
|
return result.RowsAffected, result.Error
|
|
}
|
|
|
|
type ListIncomingLettersFilter struct {
|
|
Status *string
|
|
Query *string
|
|
DepartmentID *uuid.UUID
|
|
UserID *uuid.UUID
|
|
IsRead *bool
|
|
PriorityIDs []uuid.UUID
|
|
IsDispositioned *bool
|
|
IsArchived *bool
|
|
}
|
|
|
|
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")
|
|
|
|
joinedRecipients := false
|
|
needsGroupBy := false
|
|
|
|
if filter.DepartmentID != nil {
|
|
query = query.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id").
|
|
Where("letter_incoming_recipients.recipient_department_id = ?", *filter.DepartmentID)
|
|
joinedRecipients = true
|
|
needsGroupBy = true
|
|
}
|
|
|
|
if filter.UserID != nil && filter.IsRead != nil {
|
|
if !joinedRecipients {
|
|
query = query.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id")
|
|
joinedRecipients = true
|
|
needsGroupBy = true
|
|
}
|
|
query = query.Where("letter_incoming_recipients.recipient_user_id = ?", *filter.UserID)
|
|
|
|
if *filter.IsRead {
|
|
query = query.Where("letter_incoming_recipients.read_at IS NOT NULL")
|
|
} else {
|
|
query = query.Where("letter_incoming_recipients.read_at IS NULL")
|
|
}
|
|
}
|
|
|
|
if filter.DepartmentID != nil && filter.IsDispositioned != nil {
|
|
query = query.Joins("LEFT JOIN letter_incoming_dispositions_department lidd ON lidd.letter_incoming_id = letters_incoming.id AND lidd.department_id = ?", *filter.DepartmentID)
|
|
|
|
if *filter.IsDispositioned {
|
|
query = query.Where("lidd.id IS NOT NULL AND lidd.status != 'pending'")
|
|
} else {
|
|
query = query.Where("lidd.id IS NULL OR lidd.status = 'pending'")
|
|
}
|
|
}
|
|
|
|
if len(filter.PriorityIDs) > 0 {
|
|
query = query.Where("letters_incoming.priority_id IN ?", filter.PriorityIDs)
|
|
}
|
|
|
|
if filter.IsArchived != nil {
|
|
if *filter.IsArchived {
|
|
query = query.Where("letter_incoming_recipients.is_archived = ?", true)
|
|
} else {
|
|
query = query.Where("letter_incoming_recipients.is_archived = ? OR letter_incoming_recipients.is_archived IS NULL", false)
|
|
}
|
|
}
|
|
|
|
if filter.Status != nil {
|
|
query = query.Where("letters_incoming.status = ?", *filter.Status)
|
|
}
|
|
|
|
if filter.Query != nil {
|
|
q := "%" + *filter.Query + "%"
|
|
query = query.Where("letters_incoming.subject ILIKE ? OR letters_incoming.reference_number ILIKE ?", q, q)
|
|
}
|
|
|
|
if needsGroupBy {
|
|
query = query.Group("letters_incoming.id")
|
|
}
|
|
|
|
var total int64
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
// For the actual data fetch, we need to select all columns
|
|
var list []entities.LetterIncoming
|
|
dataQuery := db.WithContext(ctx).Model(&entities.LetterIncoming{}).Where("deleted_at IS NULL")
|
|
|
|
if filter.DepartmentID != nil {
|
|
dataQuery = dataQuery.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id").
|
|
Where("letter_incoming_recipients.recipient_department_id = ?", *filter.DepartmentID)
|
|
}
|
|
|
|
if filter.UserID != nil && filter.IsRead != nil {
|
|
if filter.DepartmentID == nil {
|
|
dataQuery = dataQuery.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id")
|
|
}
|
|
dataQuery = dataQuery.Where("letter_incoming_recipients.recipient_user_id = ?", *filter.UserID)
|
|
|
|
if *filter.IsRead {
|
|
dataQuery = dataQuery.Where("letter_incoming_recipients.read_at IS NOT NULL")
|
|
} else {
|
|
dataQuery = dataQuery.Where("letter_incoming_recipients.read_at IS NULL")
|
|
}
|
|
}
|
|
|
|
if filter.DepartmentID != nil && filter.IsDispositioned != nil {
|
|
dataQuery = dataQuery.Joins("LEFT JOIN letter_incoming_dispositions_department lidd ON lidd.letter_incoming_id = letters_incoming.id AND lidd.department_id = ?", *filter.DepartmentID)
|
|
|
|
if *filter.IsDispositioned {
|
|
dataQuery = dataQuery.Where("lidd.id IS NOT NULL AND lidd.status != 'pending'")
|
|
} else {
|
|
dataQuery = dataQuery.Where("lidd.id IS NULL OR lidd.status = 'pending'")
|
|
}
|
|
}
|
|
|
|
if len(filter.PriorityIDs) > 0 {
|
|
dataQuery = dataQuery.Where("letters_incoming.priority_id IN ?", filter.PriorityIDs)
|
|
}
|
|
|
|
// Apply is_archived filter based on recipient's is_archived field
|
|
//if filter.IsArchived != nil {
|
|
// if *filter.IsArchived {
|
|
// dataQuery = dataQuery.Where("letter_incoming_recipients.is_archived = ?", true)
|
|
// } else {
|
|
// dataQuery = dataQuery.Where("letter_incoming_recipients.is_archived = ? OR letter_incoming_recipients.is_archived IS NULL", false)
|
|
// }
|
|
//}
|
|
if filter.IsArchived != nil {
|
|
if *filter.IsArchived {
|
|
dataQuery = dataQuery.Where("letter_incoming_recipients.is_archived = ?", true)
|
|
} else {
|
|
dataQuery = dataQuery.Where("letter_incoming_recipients.is_archived = ? OR letter_incoming_recipients.is_archived IS NULL", false)
|
|
}
|
|
}
|
|
|
|
if filter.Status != nil {
|
|
dataQuery = dataQuery.Where("letters_incoming.status = ?", *filter.Status)
|
|
}
|
|
|
|
if filter.Query != nil {
|
|
q := "%" + *filter.Query + "%"
|
|
dataQuery = dataQuery.Where("letters_incoming.subject ILIKE ? OR letters_incoming.reference_number ILIKE ?", q, q)
|
|
}
|
|
|
|
if needsGroupBy {
|
|
dataQuery = dataQuery.Group("letters_incoming.id, letters_incoming.letter_number, letters_incoming.reference_number, letters_incoming.subject, letters_incoming.description, letters_incoming.priority_id, letters_incoming.sender_institution_id, letters_incoming.received_date, letters_incoming.due_date, letters_incoming.status, letters_incoming.created_by, letters_incoming.created_at, letters_incoming.updated_at, letters_incoming.deleted_at")
|
|
}
|
|
|
|
if err := dataQuery.Order("letters_incoming.created_at DESC").Limit(limit).Offset(offset).Find(&list).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return list, total, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) ListAll(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")
|
|
|
|
// Apply filters (same as ListAll)
|
|
if len(filter.PriorityIDs) > 0 {
|
|
query = query.Where("letters_incoming.priority_id IN ?", filter.PriorityIDs)
|
|
}
|
|
|
|
if filter.Status != nil {
|
|
query = query.Where("letters_incoming.status = ?", *filter.Status)
|
|
}
|
|
|
|
if filter.Query != nil {
|
|
q := "%" + *filter.Query + "%"
|
|
query = query.Where("letters_incoming.subject ILIKE ? OR letters_incoming.reference_number ILIKE ? OR letters_incoming.letter_number ILIKE ?", q, q, q)
|
|
}
|
|
|
|
// Get total count
|
|
var total int64
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
// Get paginated data with preloaded relations
|
|
var list []entities.LetterIncoming
|
|
if err := query.
|
|
Limit(limit).
|
|
Offset(offset).
|
|
Find(&list).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return list, total, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRepository) Search(ctx context.Context, filters map[string]interface{}, limit, offset int, sortBy, sortOrder string) ([]entities.LetterIncoming, int64, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
query := db.WithContext(ctx).Model(&entities.LetterIncoming{}).Where("deleted_at IS NULL")
|
|
|
|
joinedRecipients := false
|
|
needsGroupBy := false
|
|
|
|
// Apply search filters
|
|
if q, ok := filters["query"]; ok && q != "" {
|
|
searchTerm := "%" + q.(string) + "%"
|
|
query = query.Where("subject ILIKE ? OR reference_number ILIKE ? OR letter_number ILIKE ? OR description ILIKE ? OR sender_name ILIKE ?", searchTerm, searchTerm, searchTerm, searchTerm, searchTerm)
|
|
}
|
|
|
|
if letterNumber, ok := filters["letter_number"]; ok && letterNumber != "" {
|
|
query = query.Where("letter_number ILIKE ?", "%"+letterNumber.(string)+"%")
|
|
}
|
|
|
|
if subject, ok := filters["subject"]; ok && subject != "" {
|
|
query = query.Where("subject ILIKE ?", "%"+subject.(string)+"%")
|
|
}
|
|
|
|
if status, ok := filters["status"]; ok && status != "" {
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
|
|
if priorityID, ok := filters["priority_id"]; ok {
|
|
query = query.Where("priority_id = ?", priorityID)
|
|
}
|
|
|
|
if institutionID, ok := filters["sender_institution_id"]; ok {
|
|
query = query.Where("sender_institution_id = ?", institutionID)
|
|
}
|
|
|
|
if createdBy, ok := filters["created_by"]; ok {
|
|
query = query.Where("created_by = ?", createdBy)
|
|
}
|
|
|
|
if dateFrom, ok := filters["date_from"]; ok {
|
|
query = query.Where("received_date >= ?", dateFrom)
|
|
}
|
|
|
|
if dateTo, ok := filters["date_to"]; ok {
|
|
query = query.Where("received_date <= ?", dateTo)
|
|
}
|
|
|
|
// Apply user context filters if present
|
|
if userContext, ok := filters["user_context"]; ok {
|
|
if ctx, ok := userContext.(map[string]interface{}); ok {
|
|
if userID, ok := ctx["user_id"]; ok {
|
|
// User can see letters where they are recipients
|
|
query = query.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id").
|
|
Where("letter_incoming_recipients.recipient_user_id = ?", userID)
|
|
joinedRecipients = true
|
|
needsGroupBy = true
|
|
}
|
|
if departmentID, ok := ctx["department_id"]; ok {
|
|
// Also include letters for user's department
|
|
if !joinedRecipients {
|
|
query = query.Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id")
|
|
joinedRecipients = true
|
|
needsGroupBy = true
|
|
}
|
|
query = query.Where("letter_incoming_recipients.recipient_department_id = ?", departmentID)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Count total results
|
|
var total int64
|
|
if needsGroupBy {
|
|
// For grouped queries, count distinct letter IDs
|
|
if err := db.WithContext(ctx).Model(&entities.LetterIncoming{}).
|
|
Joins("JOIN letter_incoming_recipients ON letter_incoming_recipients.letter_id = letters_incoming.id").
|
|
Where("letters_incoming.deleted_at IS NULL").
|
|
Distinct("letters_incoming.id").
|
|
Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
} else {
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
}
|
|
|
|
// Apply sorting
|
|
if sortBy == "" {
|
|
sortBy = "created_at"
|
|
}
|
|
if sortOrder == "" {
|
|
sortOrder = "desc"
|
|
}
|
|
|
|
validSortFields := map[string]bool{
|
|
"letter_number": true,
|
|
"subject": true,
|
|
"received_date": true,
|
|
"status": true,
|
|
"created_at": true,
|
|
"updated_at": true,
|
|
}
|
|
|
|
if !validSortFields[sortBy] {
|
|
sortBy = "created_at"
|
|
}
|
|
|
|
if sortOrder != "asc" && sortOrder != "desc" {
|
|
sortOrder = "desc"
|
|
}
|
|
|
|
orderBy := "letters_incoming." + sortBy + " " + sortOrder
|
|
|
|
// Apply grouping if necessary
|
|
if needsGroupBy {
|
|
query = query.Group("letters_incoming.id, letters_incoming.letter_number, letters_incoming.reference_number, " +
|
|
"letters_incoming.subject, letters_incoming.description, letters_incoming.priority_id, " +
|
|
"letters_incoming.sender_institution_id, letters_incoming.received_date, letters_incoming.due_date, " +
|
|
"letters_incoming.status, letters_incoming.created_by, letters_incoming.created_at, " +
|
|
"letters_incoming.updated_at, letters_incoming.deleted_at")
|
|
}
|
|
|
|
// Execute query
|
|
var letters []entities.LetterIncoming
|
|
if err := query.
|
|
Order(orderBy).
|
|
Limit(limit).
|
|
Offset(offset).
|
|
Find(&letters).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return letters, 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
|
|
}
|
|
|
|
func (r *LetterIncomingAttachmentRepository) ListByLetterIDs(ctx context.Context, letterIDs []uuid.UUID) (map[uuid.UUID][]entities.LetterIncomingAttachment, error) {
|
|
if len(letterIDs) == 0 {
|
|
return make(map[uuid.UUID][]entities.LetterIncomingAttachment), nil
|
|
}
|
|
|
|
db := DBFromContext(ctx, r.db)
|
|
var attachments []entities.LetterIncomingAttachment
|
|
if err := db.WithContext(ctx).Where("letter_id IN ?", letterIDs).Order("uploaded_at ASC").Find(&attachments).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Group attachments by letter ID
|
|
result := make(map[uuid.UUID][]entities.LetterIncomingAttachment)
|
|
for _, att := range attachments {
|
|
result[att.LetterID] = append(result[att.LetterID], att)
|
|
}
|
|
|
|
return result, 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 LetterIncomingDispositionRepository struct{ db *gorm.DB }
|
|
|
|
func NewLetterIncomingDispositionRepository(db *gorm.DB) *LetterIncomingDispositionRepository {
|
|
return &LetterIncomingDispositionRepository{db: db}
|
|
}
|
|
func (r *LetterIncomingDispositionRepository) Create(ctx context.Context, e *entities.LetterIncomingDisposition) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Create(e).Error
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.LetterIncomingDisposition, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var e entities.LetterIncomingDisposition
|
|
if err := db.WithContext(ctx).
|
|
Preload("Department").
|
|
Preload("Departments.Department").
|
|
Preload("ActionSelections.Action").
|
|
Preload("DispositionNotes.User").
|
|
First(&e, "id = ?", id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &e, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterIncomingDisposition, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDisposition
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_id = ?", letterID).
|
|
Preload("Department").
|
|
Preload("Departments.Department").
|
|
Preload("ActionSelections.Action").
|
|
Preload("DispositionNotes.User").
|
|
Order("created_at ASC").
|
|
Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionRepository) ListByLetterIDs(ctx context.Context, letterIDs []uuid.UUID) (map[uuid.UUID][]entities.LetterIncomingDisposition, error) {
|
|
if len(letterIDs) == 0 {
|
|
return make(map[uuid.UUID][]entities.LetterIncomingDisposition), nil
|
|
}
|
|
|
|
db := DBFromContext(ctx, r.db)
|
|
var dispositions []entities.LetterIncomingDisposition
|
|
if err := db.WithContext(ctx).Where("letter_id IN ?", letterIDs).
|
|
Preload("Department").
|
|
Preload("Departments.Department").
|
|
Preload("ActionSelections.Action").
|
|
Preload("DispositionNotes.User").
|
|
Order("created_at ASC").
|
|
Find(&dispositions).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Group by letter ID
|
|
result := make(map[uuid.UUID][]entities.LetterIncomingDisposition)
|
|
for i := range dispositions { // Gunakan index, bukan value
|
|
letterID := dispositions[i].LetterID
|
|
result[letterID] = append(result[letterID], dispositions[i])
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionRepository) GetByLetterIncomingID(ctx context.Context, letterIncomingID uuid.UUID) ([]entities.LetterIncomingDisposition, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDisposition
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_id = ?", letterIncomingID).
|
|
Preload("Department").
|
|
Preload("Departments.Department").
|
|
Order("created_at ASC").
|
|
Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
type LetterIncomingDispositionDepartmentRepository struct{ db *gorm.DB }
|
|
|
|
func NewLetterIncomingDispositionDepartmentRepository(db *gorm.DB) *LetterIncomingDispositionDepartmentRepository {
|
|
return &LetterIncomingDispositionDepartmentRepository{db: db}
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) DB(ctx context.Context) *gorm.DB {
|
|
return DBFromContext(ctx, r.db)
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) Create(ctx context.Context, e *entities.LetterIncomingDispositionDepartment) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Create(e).Error
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) CreateBulk(ctx context.Context, list []entities.LetterIncomingDispositionDepartment) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Create(&list).Error
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) Update(ctx context.Context, e *entities.LetterIncomingDispositionDepartment) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Save(e).Error
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var e entities.LetterIncomingDispositionDepartment
|
|
if err := db.WithContext(ctx).
|
|
Preload("Department").
|
|
Preload("LetterIncoming").
|
|
Preload("LetterIncomingDisposition").
|
|
First(&e, "id = ?", id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &e, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) GetByDispositionAndDepartment(ctx context.Context, letterIncomingID, departmentID uuid.UUID) (*entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var e entities.LetterIncomingDispositionDepartment
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_incoming_id = ? AND department_id = ?", letterIncomingID, departmentID).
|
|
Preload("Department").
|
|
Preload("LetterIncoming").
|
|
Preload("LetterIncomingDisposition").
|
|
First(&e).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &e, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) GetByLetterAndDepartment(ctx context.Context, letterID, departmentID uuid.UUID) ([]entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDispositionDepartment
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_incoming_id = ? AND department_id = ?", letterID, departmentID).
|
|
Preload("Department").
|
|
Preload("LetterIncoming").
|
|
Preload("LetterIncomingDisposition").
|
|
Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) ListByDepartmentWithPagination(ctx context.Context, departmentID uuid.UUID, status *string, offset, limit int) ([]entities.LetterIncomingDispositionDepartment, int64, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
query := db.WithContext(ctx).Where("department_id = ?", departmentID)
|
|
|
|
if status != nil && *status != "" {
|
|
query = query.Where("status = ?", *status)
|
|
}
|
|
|
|
var total int64
|
|
if err := query.Model(&entities.LetterIncomingDispositionDepartment{}).Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
var list []entities.LetterIncomingDispositionDepartment
|
|
if err := query.
|
|
Preload("Department").
|
|
Preload("LetterIncoming").
|
|
Preload("LetterIncomingDisposition.Department").
|
|
Offset(offset).
|
|
Limit(limit).
|
|
Order("created_at DESC").
|
|
Find(&list).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
return list, total, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) GetByLetterIncomingID(ctx context.Context, letterIncomingID uuid.UUID) ([]entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDispositionDepartment
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_incoming_id = ?", letterIncomingID).
|
|
Preload("Department").
|
|
Preload("LetterIncoming").
|
|
Preload("LetterIncomingDisposition.Department").
|
|
Order("created_at DESC").
|
|
Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) UpdateStatus(ctx context.Context, id uuid.UUID, status entities.LetterIncomingDispositionDepartmentStatus, notes string, readAt, completedAt *time.Time) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
updates := map[string]interface{}{
|
|
"status": status,
|
|
}
|
|
if readAt != nil {
|
|
updates["read_at"] = readAt
|
|
}
|
|
if completedAt != nil {
|
|
updates["completed_at"] = completedAt
|
|
}
|
|
|
|
if notes != "" {
|
|
updates["notes"] = notes
|
|
}
|
|
return db.WithContext(ctx).Model(&entities.LetterIncomingDispositionDepartment{}).
|
|
Where("id = ?", id).
|
|
Updates(updates).Error
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) ListByDisposition(ctx context.Context, dispositionID uuid.UUID) ([]entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDispositionDepartment
|
|
if err := db.WithContext(ctx).Where("letter_incoming_disposition_id = ?", dispositionID).Order("created_at ASC").Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *LetterIncomingDispositionDepartmentRepository) ListByDispositions(ctx context.Context, dispositionIDs []uuid.UUID) ([]entities.LetterIncomingDispositionDepartment, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterIncomingDispositionDepartment
|
|
if len(dispositionIDs) == 0 {
|
|
return list, nil
|
|
}
|
|
if err := db.WithContext(ctx).Where("letter_incoming_disposition_id IN ?", dispositionIDs).Order("letter_incoming_disposition_id, 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
|
|
}
|
|
|
|
func (r *DispositionNoteRepository) ListByDisposition(ctx context.Context, dispositionID uuid.UUID) ([]entities.DispositionNote, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.DispositionNote
|
|
if err := db.WithContext(ctx).Where("disposition_id = ?", dispositionID).Order("created_at ASC").Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *DispositionNoteRepository) ListByDispositions(ctx context.Context, dispositionIDs []uuid.UUID) ([]entities.DispositionNote, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.DispositionNote
|
|
if len(dispositionIDs) == 0 {
|
|
return list, nil
|
|
}
|
|
if err := db.WithContext(ctx).Where("disposition_id IN ?", dispositionIDs).Order("disposition_id, created_at ASC").Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (r *LetterDispositionActionSelectionRepository) ListByDispositions(ctx context.Context, dispositionIDs []uuid.UUID) ([]entities.LetterDispositionActionSelection, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterDispositionActionSelection
|
|
if len(dispositionIDs) == 0 {
|
|
return list, nil
|
|
}
|
|
if err := db.WithContext(ctx).Where("disposition_id IN ?", dispositionIDs).Order("disposition_id, 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
|
|
}
|
|
|
|
func (r *LetterDiscussionRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterDiscussion, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var list []entities.LetterDiscussion
|
|
if err := db.WithContext(ctx).
|
|
Where("letter_id = ?", letterID).
|
|
Preload("User.Profile").
|
|
Order("created_at ASC").
|
|
Find(&list).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (r *LetterDiscussionRepository) GetUsersByIDs(ctx context.Context, userIDs []uuid.UUID) ([]entities.User, error) {
|
|
if len(userIDs) == 0 {
|
|
return []entities.User{}, nil
|
|
}
|
|
|
|
db := DBFromContext(ctx, r.db)
|
|
var users []entities.User
|
|
if err := db.WithContext(ctx).
|
|
Where("id IN ?", userIDs).
|
|
Preload("Profile").
|
|
Find(&users).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
// recipients
|
|
|
|
type LetterIncomingRecipientRepository struct{ db *gorm.DB }
|
|
|
|
func NewLetterIncomingRecipientRepository(db *gorm.DB) *LetterIncomingRecipientRepository {
|
|
return &LetterIncomingRecipientRepository{db: db}
|
|
}
|
|
func (r *LetterIncomingRecipientRepository) DB(ctx context.Context) *gorm.DB {
|
|
return DBFromContext(ctx, r.db)
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) CreateBulk(ctx context.Context, recs []entities.LetterIncomingRecipient) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
return db.WithContext(ctx).Create(&recs).Error
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) Create(ctx context.Context, recipient *entities.LetterIncomingRecipient) error {
|
|
return r.DB(ctx).Create(recipient).Error
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) Update(ctx context.Context, recipient *entities.LetterIncomingRecipient) error {
|
|
return r.DB(ctx).Save(recipient).Error
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.LetterIncomingRecipient, error) {
|
|
var recipient entities.LetterIncomingRecipient
|
|
if err := r.DB(ctx).Where("id = ?", id).First(&recipient).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &recipient, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) GetByLetterAndDepartment(ctx context.Context, letterID uuid.UUID, departmentID uuid.UUID) (*entities.LetterIncomingRecipient, error) {
|
|
var recipient entities.LetterIncomingRecipient
|
|
if err := r.DB(ctx).Where("letter_id = ? AND recipient_department_id = ?", letterID, departmentID).First(&recipient).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &recipient, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) GetByLetterAndUser(ctx context.Context, letterID uuid.UUID, userID uuid.UUID) (*entities.LetterIncomingRecipient, error) {
|
|
var recipient entities.LetterIncomingRecipient
|
|
if err := r.DB(ctx).Where("letter_id = ? AND recipient_user_id = ?", letterID, userID).First(&recipient).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &recipient, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) ListByLetter(ctx context.Context, letterID uuid.UUID) ([]entities.LetterIncomingRecipient, error) {
|
|
var recipients []entities.LetterIncomingRecipient
|
|
if err := r.DB(ctx).Where("letter_id = ?", letterID).Find(&recipients).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return recipients, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) ListByDepartment(ctx context.Context, departmentID uuid.UUID) ([]entities.LetterIncomingRecipient, error) {
|
|
var recipients []entities.LetterIncomingRecipient
|
|
if err := r.DB(ctx).Where("recipient_department_id = ?", departmentID).Find(&recipients).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return recipients, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) GetLetterIDsByDepartment(ctx context.Context, departmentID uuid.UUID) ([]uuid.UUID, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var letterIDs []uuid.UUID
|
|
if err := db.WithContext(ctx).
|
|
Model(&entities.LetterIncomingRecipient{}).
|
|
Where("recipient_department_id = ?", departmentID).
|
|
Distinct("letter_id").
|
|
Pluck("letter_id", &letterIDs).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return letterIDs, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) CountReadByLetter(ctx context.Context, letterID uuid.UUID) (int, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var count int64
|
|
if err := db.WithContext(ctx).
|
|
Model(&entities.LetterIncomingRecipient{}).
|
|
Where("letter_id = ? AND read_at IS NOT NULL", letterID).
|
|
Count(&count).Error; err != nil {
|
|
return 0, err
|
|
}
|
|
return int(count), nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) CountUnreadByUser(ctx context.Context, userID uuid.UUID) (int, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var count int64
|
|
|
|
sql := `
|
|
SELECT COUNT(*) FROM (
|
|
SELECT * FROM letter_incoming_recipients
|
|
WHERE recipient_user_id = ? AND read_at IS NULL
|
|
AND id IN (
|
|
SELECT id FROM (
|
|
SELECT id, ROW_NUMBER() OVER (PARTITION BY letter_id ORDER BY created_at DESC) as rn
|
|
FROM letter_incoming_recipients
|
|
WHERE recipient_user_id = ?
|
|
) ranked
|
|
WHERE rn = 1
|
|
)
|
|
) result
|
|
`
|
|
|
|
if err := db.WithContext(ctx).Raw(sql, userID, userID).Scan(&count).Error; err != nil {
|
|
return 0, err
|
|
}
|
|
return int(count), nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) MarkAsRead(ctx context.Context, letterID, userID uuid.UUID) error {
|
|
db := DBFromContext(ctx, r.db)
|
|
now := time.Now()
|
|
return db.WithContext(ctx).
|
|
Model(&entities.LetterIncomingRecipient{}).
|
|
Where("letter_id = ? AND recipient_user_id = ?", letterID, userID).
|
|
Update("read_at", now).Error
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) GetByLetterIDsAndUser(ctx context.Context, letterIDs []uuid.UUID, userID uuid.UUID) (map[uuid.UUID]*entities.LetterIncomingRecipient, error) {
|
|
if len(letterIDs) == 0 {
|
|
return make(map[uuid.UUID]*entities.LetterIncomingRecipient), nil
|
|
}
|
|
|
|
db := DBFromContext(ctx, r.db)
|
|
var recipients []entities.LetterIncomingRecipient
|
|
|
|
if err := db.WithContext(ctx).
|
|
Where(`id IN (
|
|
SELECT id FROM (
|
|
SELECT id, ROW_NUMBER() OVER (PARTITION BY letter_id ORDER BY created_at DESC) as rn
|
|
FROM letter_incoming_recipients
|
|
WHERE letter_id IN ? AND recipient_user_id = ?
|
|
) t WHERE rn = 1
|
|
)`, letterIDs, userID).
|
|
Find(&recipients).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result := make(map[uuid.UUID]*entities.LetterIncomingRecipient)
|
|
for i := range recipients {
|
|
result[recipients[i].LetterID] = &recipients[i]
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (r *LetterIncomingRecipientRepository) HasDepartmentAccess(ctx context.Context, letterID uuid.UUID, departmentID uuid.UUID) (bool, error) {
|
|
db := DBFromContext(ctx, r.db)
|
|
var count int64
|
|
if err := db.WithContext(ctx).
|
|
Model(&entities.LetterIncomingRecipient{}).
|
|
Where("letter_id = ? AND recipient_department_id = ?", letterID, departmentID).
|
|
Count(&count).Error; err != nil {
|
|
return false, err
|
|
}
|
|
return count > 0, nil
|
|
}
|