service.go

package history

import (
	"context"
	"time"

	"bitbucket.org/ronte/msg-go-history-messages/pkg/message"
	"bitbucket.org/ronte/msg-go-history-messages/pkg/service/types"
	"bitbucket.org/ronte/msg-gokit-packages/types/uuid"
)

// MaxLimit max pagination limit.
const MaxLimit = 100

type service struct {
	messages message.Repository
}

func (s *service) Save(_ context.Context, eventID, senderID, sessionID uuid.UUID, raw []byte, recipients []uuid.UUID, numOfRead int, createdAt time.Time) (err error) {
	return s.messages.Save(eventID, senderID, sessionID, raw, recipients, numOfRead, createdAt)
}

func (s *service) MarkAsRead(_ context.Context, sessionID uuid.UUID, eventIDs []uuid.UUID) (err error) {
	return s.messages.Read(sessionID, eventIDs)
}

func (s *service) ReadHistory(_ context.Context, sessionID uuid.UUID, from time.Time, offset int64, limit int64, sortType string) (messages []types.Message, meta types.Meta, err error) {
	result, total, err := s.messages.Get(sessionID, from, offset, limit, sortType)
	return assembleMessages(result), types.Meta{
		TotalCount:    total,
		CurrentCount:  int64(len(result)),
		CurrentOffset: offset,
	}, err
}

func (s *service) ReadConversationHistory(_ context.Context, conversationID, sessionID uuid.UUID, from time.Time, offset int64, limit int64, sortType string) (messages []types.Message, meta types.Meta, err error) {
	result, total, err := s.messages.GetByConversation(conversationID, sessionID, from, offset, limit, sortType)
	return assembleMessages(result), types.Meta{
		TotalCount:    total,
		CurrentCount:  int64(len(result)),
		CurrentOffset: offset,
	}, err
}

func (s *service) GetByID(_ context.Context, id uuid.UUID) (message types.Message, err error) {
	ms, err := s.messages.GetByID(id)
	if err != nil {
		return types.Message{}, err
	}
	return assembleMessage(ms), nil
}

func (s *service) UpdatePayload(_ context.Context, id uuid.UUID, raw []byte) (err error) {
	return s.messages.UpdateRaw(id, raw)
}

func (s *service) GetAllMessages(_ context.Context, skip, limit int) (messages []types.Message, count int, err error) {
	if limit > MaxLimit {
		limit = MaxLimit
	}
	result, count, err := s.messages.GetAll(skip, limit)
	return assembleMessages(result), count, err
}

func (s *service) NotReadCount(_ context.Context, sessionID uuid.UUID) (count int, err error) {
	return s.messages.NotReadCount(sessionID)
}

func New(messages message.Repository) *service {
	return &service{messages: messages}
}

func assembleMessage(ms *message.Message) types.Message {
	return types.Message{
		ID:     ms.ID,
		Raw:    ms.Raw,
		Status: ms.Status,
		Time:   ms.Time,
	}
}

func assembleMessages(mss []*message.Message) []types.Message {
	result := make([]types.Message, 0, len(mss))
	for _, ms := range mss {
		result = append(result, assembleMessage(ms))
	}
	return result
}