merch-api/internal/merch/provider.go

package merch

import (
	"context"
	"merch-api/internal/common"
	"merch-api/pkg/utils"
)

const providerLogHeader string = "[provider]"

type provider struct {
	service *service
	utils   utils.Utils
}

func newProvider(s *service, u utils.Utils) *provider {
	return &provider{
		service: s,
		utils:   u,
	}
}

func (p *provider) GetTasks(ctx context.Context) ([]common.Task, error) {
	rawTasks, err := p.service.repo.getTaskData(ctx)
	if err != nil {
		logErr(providerLogHeader, err)
		return nil, err
	}
	return p.convertTasks(rawTasks), nil
}

func (p *provider) InsertPrices(ctx context.Context, rawPrices []common.Result) error {
	if rawPrices == nil || len(rawPrices) == 0 {
		logDebug(providerLogHeader, "no prices given")
		return nil
	}

	var uuids []string
	for _, rawPrice := range rawPrices {
		uuids = append(uuids, rawPrice.MerchUuid)
	}

	uuidMap, err := p.service.getMerchUuidMap(ctx, uuids)
	if err != nil {
		logErr(serviceLogHeader, err)
		return err
	}

	originIds, _, err := p.service.getOriginsMaps(ctx)
	if err != nil {
		logErr(serviceLogHeader, err)
		return err
	}

	now := p.utils.TimeNowUTC()
	var insertPrices []Price
	for _, rawPrice := range rawPrices {
		insertPrices = append(insertPrices, Price{
			CreatedAt: now,
			UpdatedAt: p.utils.NullTimeFromNow(now),
			MerchId:   uuidMap[rawPrice.MerchUuid],
			OriginId:  originIds[rawPrice.OriginName],
			Price:     int(rawPrice.Price),
		})
	}

	if err = p.service.repo.insertPrices(ctx, insertPrices); err != nil {
		logErr(serviceLogHeader, err)
		return err
	}

	return nil
}

func (p *provider) convertTasks(rawTasks []taskData) []common.Task {
	convert := make(map[string]*common.Task, len(rawTasks))
	for _, item := range rawTasks {
		task, ok := convert[item.MerchUuid]
		if !ok {
			task = &common.Task{
				MerchUuid: item.MerchUuid,
				Origins:   make(map[string]string),
			}
			convert[item.MerchUuid] = task
		}
		task.Origins[item.OriginName] = item.Url
	}

	result := make([]common.Task, 0, len(convert))
	for _, task := range convert {
		result = append(result, *task)
	}

	return result
}