server/remote/challenge-sync-airbus/api.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strconv"
)

type AirbusAPI struct {
	BaseURL   string
	Token     string
	SessionID uint64
}

func (a *AirbusAPI) request(method, endpoint string, data []byte, out interface{}) error {
	var reader *bytes.Reader
	if data != nil {
		reader = bytes.NewReader(data)
	}
	req, err := http.NewRequest(method, a.BaseURL+endpoint, reader)
	if err != nil {
		return fmt.Errorf("unable to prepare request to %q: %w", endpoint, err)
	}

	req.Header.Add("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return fmt.Errorf("error during request execution to %q: %w", endpoint, err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		if out != nil {
			jdec := json.NewDecoder(resp.Body)

			if err := jdec.Decode(out); err != nil {
				return fmt.Errorf("an error occurs when trying to decode response: %w", err)
			}
		}
	} else if all, err := io.ReadAll(resp.Body); err != nil {
		return fmt.Errorf("error returned by the API + error on decoding: %d // %w", resp.StatusCode, err)
	} else {
		return fmt.Errorf("error returned by the API: %d -> %s", resp.StatusCode, all)
	}

	return nil
}

type AirbusUserId int64

func (aui AirbusUserId) String() string {
	return strconv.FormatInt(int64(aui), 10)
}

type AirbusUser struct {
	Id   AirbusUserId `json:"id"`
	Name string       `json:"name"`
}

func (a *AirbusAPI) GetUsers() (users []AirbusUser, err error) {
	err = a.request("GET", fmt.Sprintf("/sessions/%d/users", a.SessionID), nil, &users)
	return
}

func (a *AirbusAPI) GetUserFromName(name string) (*AirbusUser, error) {
	users, err := a.GetUsers()
	if err != nil {
		return nil, fmt.Errorf("unable to retrieve users list: %w", err)
	}

	for _, u := range users {
		if u.Name == name {
			return &u, nil
		}
	}

	return nil, fmt.Errorf("unable to find user %q", name)
}

type AirbusChallengeId int64

func (aci AirbusChallengeId) String() string {
	return strconv.FormatInt(int64(aci), 10)
}

type AirbusChallenge struct {
	Id   AirbusChallengeId `json:"id"`
	Name string            `json:"name"`
}

func (a *AirbusAPI) GetChallenges() (challenges []AirbusChallenge, err error) {
	err = a.request("GET", fmt.Sprintf("/sessions/%d/challenges", a.SessionID), nil, &challenges)
	return
}

func (a *AirbusAPI) GetChallengeFromName(name string) (*AirbusChallenge, error) {
	challenges, err := a.GetChallenges()
	if err != nil {
		return nil, fmt.Errorf("unable to retrieve challenges list: %w", err)
	}

	for _, c := range challenges {
		if c.Name == name {
			return &c, nil
		}
	}

	return nil, fmt.Errorf("unable to find challenge %q", name)
}

func (a *AirbusAPI) ValidateChallengeFromUser(user *AirbusUser, challenge *AirbusChallenge) (err error) {
	err = a.request("GET", fmt.Sprintf("/sessions/%d/%s/%s/validate", a.SessionID, challenge.Id.String(), user.Id.String()), nil, nil)
	return
}

type AirbusUserAwards struct {
	UserId  AirbusUserId `json:"gaming_user_id"`
	Message string       `json:"name"`
	Value   int64        `json:"value"`
}

func (a *AirbusAPI) AwardUser(user *AirbusUser, value int64, message string) (err error) {
	awards := AirbusUserAwards{
		UserId:  user.Id,
		Message: message,
		Value:   value,
	}

	j, err := json.Marshal(awards)
	if err != nil {
		return fmt.Errorf("unable to marshall JSON from awards struct: %w", err)
	}

	err = a.request("POST", fmt.Sprintf("/sessions/%d/awards", a.SessionID), j, nil)
	return
}

type AirbusStats struct {
	Data AirbusStatsData `json:"data"`
}

type AirbusStatsData struct {
	BySessions []AirbusStatsSession `json:"by_sessions"`
}

type AirbusStatsSession struct {
	UUID      AirbusUUID        `json:"uuid"`
	Name      string            `json:"name"`
	Duration  string            `json:"duration"`
	TeamStats []AirbusTeamStats `json:"team_stats"`
}

type AirbusTeamStats struct {
	UUID  AirbusUUID `json:"uuid"`
	Name  string     `json:"name"`
	Score int64      `json:"score"`
}

func (a *AirbusAPI) GetCurrentStats() (stats AirbusStats, err error) {
	err = a.request("GET", "/stats", nil, &stats)
	return
}