wms-be/modules/client/service/client_service.go

package service

import (
	"context"

	"github.com/Caknoooo/go-gin-clean-starter/database/entities"
	"github.com/Caknoooo/go-gin-clean-starter/modules/client/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/client/repository"
	"gorm.io/gorm"
)

type ClientService interface {
	Create(ctx context.Context, client dto.ClientCreateRequest) (dto.ClientResponse, error)
	GetById(ctx context.Context, clientId string) (dto.ClientResponse, error)
	GetByName(ctx context.Context, name string) (dto.ClientResponse, error)
	Update(ctx context.Context, client dto.ClientUpdateRequest, clientId string) (dto.ClientResponse, error)
	Delete(ctx context.Context, clientId string) error
}

type clientService struct {
	db         *gorm.DB
	clientRepo repository.ClientRepository
}

func (s *clientService) Create(ctx context.Context, req dto.ClientCreateRequest) (dto.ClientResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	client := entities.M_Client{
		Name:    req.Name,
		PIC:     req.PIC,
		Phone:   req.Phone,
		Email:   req.Email,
		Address: req.Address,
		Logo:    req.Logo, // []byte, sudah benar untuk simpan file
	}

	createdClient, err := s.clientRepo.Create(ctx, tx, client)
	if err != nil {
		tx.Rollback()
		return dto.ClientResponse{}, err
	}
	err = tx.Commit().Error
	if err != nil {
		tx.Rollback()
		return dto.ClientResponse{}, err
	}

	// Mapping entity ke response (Logo bisa dikonversi ke base64 jika perlu)
	// logoBase64 := ""
	// if len(createdClient.Logo) > 0 {
	// 	logoBase64 = base64.StdEncoding.EncodeToString(createdClient.Logo)
	// }

	return dto.ClientResponse{
		ID:      createdClient.ID.String(),
		Name:    createdClient.Name,
		PIC:     createdClient.PIC,
		Phone:   createdClient.Phone,
		Email:   createdClient.Email,
		Address: createdClient.Address,
		Logo:    req.Logo,
	}, nil
}

func (s *clientService) GetById(ctx context.Context, clientId string) (dto.ClientResponse, error) {
	client, err := s.clientRepo.GetById(ctx, nil, clientId)
	if err != nil {
		return dto.ClientResponse{}, err
	}
	// logoBase64 := ""
	// if len(client.Logo) > 0 {
	// 	logoBase64 = base64.StdEncoding.EncodeToString(client.Logo)
	// }
	return dto.ClientResponse{
		ID:      client.ID.String(),
		Name:    client.Name,
		PIC:     client.PIC,
		Phone:   client.Phone,
		Email:   client.Email,
		Address: client.Address,
		Logo:    client.Logo,
	}, nil
}

func (s *clientService) GetByName(ctx context.Context, name string) (dto.ClientResponse, error) {
	client, err := s.clientRepo.GetByName(ctx, nil, name)
	if err != nil {
		return dto.ClientResponse{}, err
	}
	// logoBase64 := ""
	// if len(client.Logo) > 0 {
	// 	logoBase64 = base64.StdEncoding.EncodeToString(client.Logo)
	// }
	return dto.ClientResponse{
		ID:      client.ID.String(),
		Name:    client.Name,
		PIC:     client.PIC,
		Phone:   client.Phone,
		Email:   client.Email,
		Address: client.Address,
		Logo:    client.Logo,
	}, nil
}

func (s *clientService) Update(ctx context.Context, req dto.ClientUpdateRequest, clientId string) (dto.ClientResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	client, err := s.clientRepo.GetById(ctx, tx, clientId)
	if err != nil {
		tx.Rollback()
		return dto.ClientResponse{}, err
	}
	if req.Name != nil {
		client.Name = *req.Name
	}
	if req.PIC != nil {
		client.PIC = *req.PIC
	}
	if req.Phone != nil {
		client.Phone = *req.Phone
	}
	if req.Email != nil {
		client.Email = *req.Email
	}
	if req.Address != nil {
		client.Address = *req.Address
	}
	if req.Logo != nil {
		client.Logo = *req.Logo
	}
	updatedClient, err := s.clientRepo.Update(ctx, tx, client)
	if err != nil {
		tx.Rollback()
		return dto.ClientResponse{}, err
	}
	err = tx.Commit().Error
	if err != nil {
		tx.Rollback()
		return dto.ClientResponse{}, err
	}
	// logoBase64 := ""
	// if len(updatedClient.Logo) > 0 {
	// 	logoBase64 = base64.StdEncoding.EncodeToString(updatedClient.Logo)
	// }
	return dto.ClientResponse{
		ID:      updatedClient.ID.String(),
		Name:    updatedClient.Name,
		PIC:     updatedClient.PIC,
		Phone:   updatedClient.Phone,
		Email:   updatedClient.Email,
		Address: updatedClient.Address,
		Logo:    updatedClient.Logo,
	}, nil
}

func (s *clientService) Delete(ctx context.Context, clientId string) error {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	err := s.clientRepo.Delete(ctx, tx, clientId)
	if err != nil {
		tx.Rollback()
		return err
	}
	err = tx.Commit().Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return nil
}

func NewClientService(clientRepo repository.ClientRepository, db *gorm.DB) ClientService {
	return &clientService{
		clientRepo: clientRepo,
		db:         db,
	}
}