rudder-go-sdk/players.go

package rudder

import (
	"context"
	"net/http"
	"net/url"
	"strconv"

	"hub.rudder.build/rudder/rudder-go-sdk/models"
)

type PlayersService struct {
	transport *transport
}

type ListPlayersParameters struct {
	Limit  int
	Offset int
	Search string
}

func (s *PlayersService) List(ctx context.Context, parameters ListPlayersParameters) (*models.ListPlayersResponse, error) {
	query := url.Values{}
	if parameters.Limit > 0 {
		query.Set("limit", strconv.Itoa(parameters.Limit))
	}
	if parameters.Offset > 0 {
		query.Set("offset", strconv.Itoa(parameters.Offset))
	}
	if parameters.Search != "" {
		query.Set("search", parameters.Search)
	}

	var response models.ListPlayersResponse
	if err := s.transport.do(ctx, http.MethodGet, "/players/list", query, nil, &response); err != nil {
		return nil, err
	}
	return &response, nil
}

func (s *PlayersService) Get(ctx context.Context, playerID string) (*models.AdminPlayerDetails, error) {
	var response models.AdminPlayerDetails
	if err := s.transport.do(ctx, http.MethodGet, "/players/"+url.PathEscape(playerID), nil, nil, &response); err != nil {
		return nil, err
	}
	return &response, nil
}

type UpdatePlayersParameters struct {
	IdempotencyKey string
	Items          []models.BatchUpdatePlayersItem
}

func (s *PlayersService) Update(ctx context.Context, parameters UpdatePlayersParameters) ([]models.AdminPlayer, error) {
	body := models.BatchUpdatePlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPatch, "/players", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type BanPlayersParameters struct {
	IdempotencyKey string
	Items          []models.BatchBanPlayersItem
}

func (s *PlayersService) Ban(ctx context.Context, parameters BanPlayersParameters) ([]models.AdminPlayer, error) {
	body := models.BatchBanPlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPost, "/players/ban", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type UnbanPlayersParameters struct {
	IdempotencyKey string
	Items          []models.BatchPlayerItem
}

func (s *PlayersService) Unban(ctx context.Context, parameters UnbanPlayersParameters) ([]models.AdminPlayer, error) {
	body := models.BatchUnbanPlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPost, "/players/unban", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type DeletePlayersParameters struct {
	IdempotencyKey string
	Items          []models.BatchPlayerItem
}

func (s *PlayersService) Delete(ctx context.Context, parameters DeletePlayersParameters) error {
	body := models.BatchDeletePlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}
	return s.transport.do(ctx, http.MethodDelete, "/players", nil, body, nil)
}