arp/graph/converters.go

package graph

import (
	"strconv"
	"time"

	"gogs.dmsc.dev/arp/graph/model"
	"gogs.dmsc.dev/arp/models"
)

// ID helpers for converting between string IDs (GraphQL) and uint IDs (database)
func toID(s string) (uint, error) {
	id, err := strconv.ParseUint(s, 10, 32)
	return uint(id), err
}

// convertUser converts models.User to model.User
func convertUser(u models.User) *model.User {
	roles := make([]*model.Role, len(u.Roles))
	for i, r := range u.Roles {
		roles[i] = &model.Role{
			ID:          strconv.FormatUint(uint64(r.ID), 10),
			Name:        r.Name,
			Description: r.Description,
			Permissions: convertPermissions(r.Permissions),
		}
	}
	return &model.User{
		ID:        strconv.FormatUint(uint64(u.ID), 10),
		Email:     u.Email,
		Password:  u.Password,
		Roles:     roles,
		CreatedAt: u.CreatedAt.String(),
		UpdatedAt: u.UpdatedAt.String(),
	}
}

// convertUsers converts []models.User to []*model.User
func convertUsers(users []models.User) []*model.User {
	result := make([]*model.User, len(users))
	for i, u := range users {
		result[i] = convertUser(u)
	}
	return result
}

// convertNote converts models.Note to model.Note
func convertNote(n models.Note) *model.Note {
	userID := strconv.FormatUint(uint64(n.UserID), 10)
	serviceID := strconv.FormatUint(uint64(n.ServiceID), 10)
	return &model.Note{
		ID:        strconv.FormatUint(uint64(n.ID), 10),
		Title:     n.Title,
		Content:   n.Content,
		UserID:    userID,
		ServiceID: serviceID,
		CreatedAt: n.CreatedAt.String(),
		UpdatedAt: n.UpdatedAt.String(),
	}
}

// convertNotes converts []models.Note to []*model.Note
func convertNotes(notes []models.Note) []*model.Note {
	result := make([]*model.Note, len(notes))
	for i, n := range notes {
		result[i] = convertNote(n)
	}
	return result
}

// convertRole converts models.Role to model.Role
func convertRole(r models.Role) *model.Role {
	permissions := make([]*model.Permission, len(r.Permissions))
	for i, p := range r.Permissions {
		permissions[i] = &model.Permission{
			ID:          strconv.FormatUint(uint64(p.ID), 10),
			Code:        p.Code,
			Description: p.Description,
		}
	}
	return &model.Role{
		ID:          strconv.FormatUint(uint64(r.ID), 10),
		Name:        r.Name,
		Description: r.Description,
		Permissions: permissions,
	}
}

// convertRoles converts []models.Role to []*model.Role
func convertRoles(roles []models.Role) []*model.Role {
	result := make([]*model.Role, len(roles))
	for i, r := range roles {
		result[i] = convertRole(r)
	}
	return result
}

// convertPermission converts models.Permission to model.Permission
func convertPermission(p models.Permission) *model.Permission {
	return &model.Permission{
		ID:          strconv.FormatUint(uint64(p.ID), 10),
		Code:        p.Code,
		Description: p.Description,
	}
}

// convertPermissions converts []models.Permission to []*model.Permission
func convertPermissions(perms []models.Permission) []*model.Permission {
	result := make([]*model.Permission, len(perms))
	for i, p := range perms {
		result[i] = convertPermission(p)
	}
	return result
}

// convertService converts models.Service to model.Service
func convertService(s models.Service) *model.Service {
	var desc *string
	if s.Description != "" {
		desc = &s.Description
	}
	createdByID := strconv.FormatUint(uint64(s.CreatedByID), 10)
	participants := make([]*model.User, len(s.Participants))
	for i, u := range s.Participants {
		participants[i] = convertUser(u)
	}
	tasks := make([]*model.Task, len(s.Tasks))
	for i, t := range s.Tasks {
		tasks[i] = convertTask(t)
	}
	return &model.Service{
		ID:           strconv.FormatUint(uint64(s.ID), 10),
		Name:         s.Name,
		Description:  desc,
		CreatedByID:  createdByID,
		Participants: participants,
		Tasks:        tasks,
		CreatedAt:    s.CreatedAt.String(),
		UpdatedAt:    s.UpdatedAt.String(),
	}
}

// convertServices converts []models.Service to []*model.Service
func convertServices(services []models.Service) []*model.Service {
	result := make([]*model.Service, len(services))
	for i, s := range services {
		result[i] = convertService(s)
	}
	return result
}

// convertTaskStatus converts models.TaskStatus to model.TaskStatus
func convertTaskStatus(ts models.TaskStatus) *model.TaskStatus {
	tasks := make([]*model.Task, len(ts.Tasks))
	for i, t := range ts.Tasks {
		tasks[i] = convertTask(t)
	}
	return &model.TaskStatus{
		ID:        strconv.FormatUint(uint64(ts.ID), 10),
		Code:      ts.Code,
		Label:     ts.Label,
		Tasks:     tasks,
		CreatedAt: ts.CreatedAt.String(),
		UpdatedAt: ts.UpdatedAt.String(),
	}
}

// convertTaskStatuses converts []models.TaskStatus to []*model.TaskStatus
func convertTaskStatuses(statuses []models.TaskStatus) []*model.TaskStatus {
	result := make([]*model.TaskStatus, len(statuses))
	for i, ts := range statuses {
		result[i] = convertTaskStatus(ts)
	}
	return result
}

// convertTask converts models.Task to model.Task
func convertTask(t models.Task) *model.Task {
	var dueDate *string
	if t.DueDate != nil {
		formatted := t.DueDate.Format(time.RFC3339)
		dueDate = &formatted
	}
	var statusID *string
	var status *model.TaskStatus
	if t.Status.ID > 0 {
		sid := strconv.FormatUint(uint64(t.StatusID), 10)
		statusID = &sid
		status = convertTaskStatus(t.Status)
	}
	var assigneeID *string
	var assignee *model.User
	if t.AssigneeID != nil && t.Assignee != nil {
		aid := strconv.FormatUint(uint64(*t.AssigneeID), 10)
		assigneeID = &aid
		assignee = convertUser(*t.Assignee)
	}
	return &model.Task{
		ID:          strconv.FormatUint(uint64(t.ID), 10),
		Title:       t.Title,
		Content:     t.Content,
		CreatedByID: strconv.FormatUint(uint64(t.CreatedByID), 10),
		CreatedBy:   convertUser(t.CreatedBy),
		UpdatedByID: strconv.FormatUint(uint64(t.UpdatedByID), 10),
		UpdatedBy:   convertUser(t.UpdatedBy),
		AssigneeID:  assigneeID,
		Assignee:    assignee,
		StatusID:    statusID,
		Status:      status,
		DueDate:     dueDate,
		Priority:    t.Priority,
		CreatedAt:   t.CreatedAt.String(),
		UpdatedAt:   t.UpdatedAt.String(),
	}
}

// convertTasks converts []models.Task to []*model.Task
func convertTasks(tasks []models.Task) []*model.Task {
	result := make([]*model.Task, len(tasks))
	for i, t := range tasks {
		result[i] = convertTask(t)
	}
	return result
}

// convertChannel converts models.Channel to model.Channel
func convertChannel(c models.Channel) *model.Channel {
	participants := make([]*model.User, len(c.Participants))
	for i, u := range c.Participants {
		participants[i] = convertUser(u)
	}
	return &model.Channel{
		ID:           strconv.FormatUint(uint64(c.ID), 10),
		Participants: participants,
		CreatedAt:    c.CreatedAt.String(),
		UpdatedAt:    c.UpdatedAt.String(),
	}
}

// convertChannels converts []models.Channel to []*model.Channel
func convertChannels(channels []models.Channel) []*model.Channel {
	result := make([]*model.Channel, len(channels))
	for i, c := range channels {
		result[i] = convertChannel(c)
	}
	return result
}

// convertMessage converts models.Message to model.Message
func convertMessage(m models.Message) *model.Message {
	return &model.Message{
		ID:             strconv.FormatUint(uint64(m.ID), 10),
		ConversationID: strconv.FormatUint(uint64(m.ConversationID), 10),
		SenderID:       strconv.FormatUint(uint64(m.SenderID), 10),
		Sender:         convertUser(m.Sender),
		Content:        m.Content,
		SentAt:         m.SentAt.String(),
		CreatedAt:      m.CreatedAt.String(),
		UpdatedAt:      m.UpdatedAt.String(),
	}
}

// convertMessages converts []models.Message to []*model.Message
func convertMessages(messages []models.Message) []*model.Message {
	result := make([]*model.Message, len(messages))
	for i, m := range messages {
		result[i] = convertMessage(m)
	}
	return result
}