apskel-pos-backend/internal/mappers/category_mapper.go

package mappers

import (
	"apskel-pos-be/internal/entities"
	"apskel-pos-be/internal/models"
)

func CategoryEntityToModel(entity *entities.Category) *models.Category {
	if entity == nil {
		return nil
	}

	return &models.Category{
		ID:             entity.ID,
		OrganizationID: entity.OrganizationID,
		OutletID:       entity.OutletID,
		Name:           entity.Name,
		Description:    entity.Description,
		ImageURL:       nil,
		Order:          entity.Order,
		IsActive:       true,
		CreatedAt:      entity.CreatedAt,
		UpdatedAt:      entity.UpdatedAt,
	}
}

func CategoryModelToEntity(model *models.Category) *entities.Category {
	if model == nil {
		return nil
	}

	metadata := entities.Metadata{}
	if model.ImageURL != nil {
		metadata["image_url"] = *model.ImageURL
	}

	return &entities.Category{
		ID:             model.ID,
		OrganizationID: model.OrganizationID,
		OutletID:       model.OutletID,
		Name:           model.Name,
		Description:    model.Description,
		BusinessType:   "restaurant",
		Order:          model.Order,
		Metadata:       metadata,
		CreatedAt:      model.CreatedAt,
		UpdatedAt:      model.UpdatedAt,
	}
}

func CreateCategoryRequestToEntity(req *models.CreateCategoryRequest) *entities.Category {
	if req == nil {
		return nil
	}

	metadata := entities.Metadata{}
	if req.ImageURL != nil {
		metadata["image_url"] = *req.ImageURL
	}

	return &entities.Category{
		OrganizationID:  req.OrganizationID,
		OutletID:        req.OutletID,
		ParentID:        req.ParentID,
		Name:            req.Name,
		Description:     req.Description,
		Order:           req.Order,
		OwnerFeePercent: req.OwnerFeePercent,
		BusinessType:    "restaurant",
		Metadata:        metadata,
	}
}

func CategoryEntityToResponse(entity *entities.Category) *models.CategoryResponse {
	if entity == nil {
		return nil
	}

	// Extract image URL and sort order from metadata
	var imageURL *string

	if entity.Metadata != nil {
		if imgURL, exists := entity.Metadata["image_url"]; exists {
			if imgURLStr, ok := imgURL.(string); ok {
				imageURL = &imgURLStr
			}
		}
	}

	// Parent name is only available when the Parent association is preloaded
	var parentName *string
	if entity.Parent != nil {
		name := entity.Parent.Name
		parentName = &name
	}

	return &models.CategoryResponse{
		ID:              entity.ID,
		OrganizationID:  entity.OrganizationID,
		OutletID:        entity.OutletID,
		ParentID:        entity.ParentID,
		ParentName:      parentName,
		Name:            entity.Name,
		Description:     entity.Description,
		ImageURL:        imageURL,
		Order:           entity.Order,
		OwnerFeePercent: entity.OwnerFeePercent,
		IsActive:        true,
		CreatedAt:       entity.CreatedAt,
		UpdatedAt:       entity.UpdatedAt,
	}
}

func UpdateCategoryEntityFromRequest(entity *entities.Category, req *models.UpdateCategoryRequest) {
	if entity == nil || req == nil {
		return
	}

	if req.Name != nil {
		entity.Name = *req.Name
	}

	if req.Description != nil {
		entity.Description = req.Description
	}

	if entity.Metadata == nil {
		entity.Metadata = make(entities.Metadata)
	}

	if req.ImageURL != nil {
		entity.Metadata["image_url"] = *req.ImageURL
	}

	if req.Order != nil {
		entity.Order = *req.Order
	}

	if req.ClearOwnerFeePercent {
		entity.OwnerFeePercent = nil
	} else if req.OwnerFeePercent != nil {
		entity.OwnerFeePercent = req.OwnerFeePercent
	}

	if req.OutletID != nil {
		entity.OutletID = req.OutletID
	}

	if req.ClearParentID {
		// Drop the preloaded parent too, so the response stops reporting it
		entity.ParentID = nil
		entity.Parent = nil
	} else if req.ParentID != nil {
		entity.ParentID = req.ParentID
	}
}

func CategoryEntitiesToModels(entities []*entities.Category) []*models.Category {
	if entities == nil {
		return nil
	}

	models := make([]*models.Category, len(entities))
	for i, entity := range entities {
		models[i] = CategoryEntityToModel(entity)
	}
	return models
}

func CategoryEntitiesToResponses(entities []*entities.Category) []*models.CategoryResponse {
	if entities == nil {
		return nil
	}

	responses := make([]*models.CategoryResponse, len(entities))
	for i, entity := range entities {
		responses[i] = CategoryEntityToResponse(entity)
	}
	return responses
}