gamboupload/loot.go

package main

import (
	"bytes"
	"encoding/csv"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/sqweek/dialog"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

type LootUpload struct {
	Loot    []LootRecord `json:"loot"`
	Players []string     `json:"players"`
}

type LootRecord struct {
	Name      string    `json:"player"`
	ItemID    int       `json:"item_id"`
	ItemName  string    `json:"item_name"`
	RollType  string    `json:"roll_type"`
	Timestamp time.Time `json:"timestamp"`
}

func loot() {
	loots, err := parseLoot()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Print("Enter the matching warcraft logs report id:")
	var reportID string
	_, err = fmt.Scanln(&reportID)
	if err != nil {
		log.Fatal(err)
	}

	players, err := getAttendance(reportID)
	if err != nil {
		log.Fatal(err)
	}

	upload := LootUpload{
		Loot:    loots,
		Players: players,
	}

	err = uploadLoot(upload, "https://forcek.in/loot")
	//err = uploadLootTest(upload)
	if err != nil {
		log.Fatal(err)
	}
}

func parseLoot() ([]LootRecord, error) {
	csvPath, err := dialog.File().Title("Select the csv file").Load()
	if err != nil {
		if errors.Is(err, dialog.ErrCancelled) {
			return nil, fmt.Errorf("cancelled dialog box, exiting")
		} else {
			return nil, err
		}
	}

	csvFile, err := os.Open(csvPath)
	if err != nil {
		return nil, err
	}
	defer csvFile.Close()

	data, err := io.ReadAll(csvFile)
	if err != nil {
		return nil, err
	}

	data = bytes.ReplaceAll(data, []byte("[\"Bullet-Proof\" Vestplate]"), []byte("[Bullet-Proof Vestplate]"))

	csvReader := csv.NewReader(bytes.NewReader(data))
	records, err := csvReader.ReadAll()
	if err != nil {
		return nil, fmt.Errorf("failed to parse csv: %v\n", err)
	}

	loots := make([]LootRecord, 0)
	for i := 1; i < len(records); i++ {
		if strings.Contains(records[i][7], "Personal Loot") {
			continue
		}

		var l = LootRecord{
			Name:     strings.Split(records[i][0], "-")[0],
			ItemName: strings.Trim(records[i][4], "[]"),
		}
		l.ItemID, err = strconv.Atoi(records[i][5])
		if err != nil {
			log.Fatal(err)
		}
		l.Timestamp, err = time.Parse("2006/1/2 15:04:05", fmt.Sprintf("%s %s", records[i][1], records[i][2]))
		if err != nil {
			log.Fatal(err)
		}

		switch records[i][7] {
		case "Mainspec/Need":
			l.RollType = "mainspec"
		case "Offspec":
			l.RollType = "offspec"
		case "Minor Upgrade":
			l.RollType = "minor"
		case "Transmog":
			l.RollType = "transmog"
		default:
			l.RollType = "unknown"
		}

		loots = append(loots, l)
	}

	return loots, nil
}

type WarcraftLog struct {
	Lang               string `json:"lang"`
	Fights             any    `json:"fights"`
	CompleteRaids      any    `json:"complete_raids"`
	Friendlies         any    `json:"friendlies"`
	Enemies            any    `json:"enemies"`
	FriendlyPets       any    `json:"friendly_pets"`
	EnemyPets          any    `json:"enemyPets"`
	LogVersion         int    `json:"logVersion"`
	GameVersion        int    `json:"gameVersion"`
	Phases             any    `json:"phases"`
	Title              string `json:"title"`
	Owner              string `json:"owner"`
	Start              int64  `json:"start"`
	End                int64  `json:"end"`
	Zone               int    `json:"zone"`
	ExportedCharacters []struct {
		ID     int    `json:"id"`
		Name   string `json:"name"`
		Server string `json:"server"`
		Region string `json:"region"`
	} `json:"exportedCharacters"`
}

func getAttendance(reportID string) ([]string, error) {
	logUrl := fmt.Sprintf("https://www.warcraftlogs.com:443/v1/report/fights/%s?api_key=%s", reportID, config.WarcraftLogsApiKey)
	resp, err := http.Get(logUrl)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var wlog WarcraftLog
	err = json.Unmarshal(body, &wlog)
	if err != nil {
		return nil, err
	}

	players := make([]string, 0)
	for _, p := range wlog.ExportedCharacters {
		players = append(players, p.Name)
	}

	return players, nil
}

func uploadLoot(l LootUpload, endpoint string) error {
	marshalled, err := json.Marshal(l)
	if err != nil {
		return err
	}
	fmt.Println(string(marshalled))

	req, err := http.NewRequest("POST", endpoint, bytes.NewBuffer(marshalled))
	if err != nil {
		return err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-API-KEY", config.Apikey)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}

	fmt.Println(resp.Status)
	return nil
}

func uploadLootTest(l LootUpload) error {
	return uploadLoot(l, "http://localhost:3000/loot")
}