base/internal/repository/postgres/profile/mapper.go

package profile

import (
	"encoding/json"

	"github.com/google/uuid"

	domainProfile "base/internal/domain/profile"
)

func toProfileModel(profile *domainProfile.Profile) (*Model, error) {
	pageSectionOrder, err := json.Marshal(profile.PageSectionOrder)
	if err != nil {
		return nil, err
	}

	var roleID *uuid.UUID
	var roleName *string
	roleLevel := ""
	if profile.Hero.Role != nil {
		roleLevel = profile.Hero.Role.Level
		if profile.Hero.Role.ID != uuid.Nil {
			roleID = &profile.Hero.Role.ID
			roleName = &profile.Hero.Role.Title
		}
	}

	return &Model{
		ID:               profile.ID,
		UserID:           profile.UserID,
		Handle:           profile.Handle,
		RoleID:           roleID,
		RoleName:         roleName,
		RoleLevel:        roleLevel,
		FirstName:        profile.Hero.FirstName,
		LastName:         profile.Hero.LastName,
		Company:          profile.Hero.Company,
		ShortDescription: profile.Hero.ShortDescription,
		ResumeLink:       profile.Hero.ResumeLink,
		CTAEnabled:       profile.Hero.CTAEnabled,
		Avatar:           profile.Hero.Avatar,
		ProfilePicture:   profile.About.ProfilePicture,
		About:            profile.About.About,
		Email:            profile.Contact.Email,
		Phone:            profile.Contact.Phone,
		VisibilityLevel:  profile.PageSetting.VisibilityLevel,
		PageSectionOrder: pageSectionOrder,
		CreatedAt:        profile.CreatedAt,
		UpdatedAt:        profile.UpdatedAt,
	}, nil
}

func toProfileDomain(model *Model, skills []domainProfile.Skill, socialLinks []domainProfile.SocialLink, achievements []domainProfile.Achievement) (*domainProfile.Profile, error) {
	var pageSectionOrder map[string]int
	if len(model.PageSectionOrder) > 0 {
		if err := json.Unmarshal(model.PageSectionOrder, &pageSectionOrder); err != nil {
			return nil, err
		}
	}

	var role *domainProfile.Role

	if model.RoleID != nil && *model.RoleID != uuid.Nil {
		title := ""
		if model.Role != nil {
			title = model.Role.Title
		} else if model.RoleName != nil {
			title = *model.RoleName
		}
		role = &domainProfile.Role{
			ID:    *model.RoleID,
			Title: title,
			Level: model.RoleLevel,
		}
	} else if model.RoleLevel != "" {
		role = &domainProfile.Role{Level: model.RoleLevel}
	}

	hero := domainProfile.Hero{
		Role:             role,
		FirstName:        model.FirstName,
		LastName:         model.LastName,
		Company:          model.Company,
		ShortDescription: model.ShortDescription,
		ResumeLink:       model.ResumeLink,
		CTAEnabled:       model.CTAEnabled,
		Avatar:           model.Avatar,
	}

	about := domainProfile.About{
		ProfilePicture: model.ProfilePicture,
		About:          model.About,
		Achievements:   achievements,
	}

	contact := domainProfile.Contact{
		Email:       model.Email,
		Phone:       model.Phone,
		SocialLinks: socialLinks,
	}

	pageSetting := domainProfile.PageSetting{
		VisibilityLevel: model.VisibilityLevel,
	}

	return &domainProfile.Profile{
		ID:               model.ID,
		UserID:           model.UserID,
		Handle:           model.Handle,
		PageSectionOrder: pageSectionOrder,
		Hero:             hero,
		About:            about,
		Skills:           skills,
		Contact:          contact,
		PageSetting:      pageSetting,
		CreatedAt:        model.CreatedAt,
		UpdatedAt:        model.UpdatedAt,
	}, nil
}

func toSkillModels(profileID uuid.UUID, skills []domainProfile.Skill) []SkillModel {
	models := make([]SkillModel, len(skills))
	for i, skill := range skills {
		models[i] = SkillModel{
			ProfileID: profileID,
			SkillName: skill.SkillName,
			Level:     skill.Level,
		}
	}
	return models
}

func toSkillDomains(models []SkillModel) []domainProfile.Skill {
	skills := make([]domainProfile.Skill, len(models))
	for i, model := range models {
		skills[i] = domainProfile.Skill{
			SkillName: model.SkillName,
			Level:     model.Level,
		}
	}
	return skills
}

func toSocialLinkModels(profileID uuid.UUID, socialLinks []domainProfile.SocialLink) []SocialLinkModel {
	models := make([]SocialLinkModel, len(socialLinks))
	for i, link := range socialLinks {
		models[i] = SocialLinkModel{
			ProfileID: profileID,
			LinkType:  link.LinkType,
			Link:      link.Link,
		}
	}
	return models
}

func toSocialLinkDomains(models []SocialLinkModel) []domainProfile.SocialLink {
	links := make([]domainProfile.SocialLink, len(models))
	for i, model := range models {
		links[i] = domainProfile.SocialLink{
			LinkType: model.LinkType,
			Link:     model.Link,
		}
	}
	return links
}

func toAchievementModels(profileID uuid.UUID, achievements []domainProfile.Achievement) []AchievementModel {
	models := make([]AchievementModel, len(achievements))
	for i, achievement := range achievements {
		models[i] = AchievementModel{
			ProfileID: profileID,
			Title:     achievement.Title,
			Value:     achievement.Value,
			Enabled:   achievement.Enabled,
		}
	}
	return models
}

func toAchievementDomains(models []AchievementModel) []domainProfile.Achievement {
	achievements := make([]domainProfile.Achievement, len(models))
	for i, model := range models {
		achievements[i] = domainProfile.Achievement{
			Title:   model.Title,
			Value:   model.Value,
			Enabled: model.Enabled,
		}
	}
	return achievements
}

func copyProfileFromModel(profile *domainProfile.Profile, model *Model) error {
	profile.ID = model.ID
	profile.Handle = model.Handle
	return nil
}