pretix-proxy/src/app/util/pretix.go

package util

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strconv"

	"golang.org/x/exp/slices"
	"ulmer-furs.de/pretix-proxy/v2/app/service"
	"ulmer-furs.de/pretix-proxy/v2/config"
	"ulmer-furs.de/pretix-proxy/v2/entities"
)

func GetPretixOrders(organizer *string, event *string) (*entities.Pretix_Event, error) {
	req, err := http.NewRequest("GET", fmt.Sprintf("https://%s/api/v1/organizers/%s/events/%s/orders", config.Env.Domain, *organizer, *event), nil)
	if err != nil {
		return nil, errors.New("request error")
	}
	req.Header.Add("Authorization", fmt.Sprintf("Token %s", config.Env.ApiKeyPretix))
	resp, err := config.Client.Do(req)
	if err != nil {
		return nil, errors.New("request error")
	}
	respbody, err := io.ReadAll(resp.Body)
	defer resp.Body.Close()
	if err != nil {
		return nil, errors.New("request error")
	}
	var unmarshaled_resp entities.Pretix_Event
	if err := json.Unmarshal(respbody, &unmarshaled_resp); err != nil {
		return nil, errors.New("request error")
	}
	return &unmarshaled_resp, nil
}

func GetAttendieListFromPretixJson(pretixEvent entities.Pretix_Event, event entities.Db_Event) entities.Attendies {
	var attendies entities.Attendies
	var name string

	for _, order := range pretixEvent.Results {

		indexParticipation := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdParticipation })
		indexBadge := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdBadge })
		indexRestaurant := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdRestaurant })
		// Get the Name of the Attendie. We take the Name from the Badge, if none Badge ordered == anonymous
		if indexBadge != -1 {
			indexName := slices.IndexFunc(order.Positions[indexBadge].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdName })
			name = order.Positions[indexBadge].Answers[indexName].Answer
		} else {
			name = "Anonymous"
		}

		indexRole := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdRole })
		role := order.Positions[indexParticipation].Answers[indexRole].OptionIdentifiers

		if slices.Contains(role, *event.OptionIdSuiter) {
			attendies.Suiter = append(attendies.Suiter, name)
		} else if slices.Contains(role, *event.OptionIdSpotter) {
			attendies.Spotter = append(attendies.Spotter, name)
		} else if slices.Contains(role, *event.OptionIdPhotograph) {
			attendies.Photographers = append(attendies.Photographers, name)
		} else if slices.Contains(role, *event.OptionIdGuest) {
			attendies.Guests = append(attendies.Guests, name)
		} else if slices.Contains(role, *event.OptionIdSpecialAnimal) {
			attendies.Suiter = append(attendies.Suiter, name)
			attendies.Photographers = append(attendies.Photographers, name)
		}

		if indexRestaurant != -1 {
			attendies.Restaurant = append(attendies.Restaurant, name)
		}
	}

	return attendies
}

func GetAttendiesFromPretixJsonWithRoleQuestion(pretixEvent *entities.Pretix_Event, event *entities.Db_Event) ([]entities.Db_Attendies, error) {
	var attendies []entities.Db_Attendies
	for _, order := range pretixEvent.Results {
		if order.Status == "c" || order.Status == "e" {
			continue
		}
		var attendie entities.Db_Attendies
		attendie.Event = *event
		if event.ItemIdParticipation == nil {
			return attendies, errors.New("no participation found")
		}
		indexParticipation := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdParticipation })
		if event.ItemIdRestaurant == nil {
			attendie.AttendsRestaurant = false
		} else {
			indexRestaurant := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdRestaurant })
			if indexRestaurant != -1 {
				attendie.AttendsRestaurant = true
			} else {
				attendie.AttendsRestaurant = false
			}
		}

		indexName := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdName })
		attendie.Nickname = order.Positions[indexParticipation].Answers[indexName].Answer

		indexRole := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdRole })
		roleAnswer := order.Positions[indexParticipation].Answers[indexRole].OptionIdentifiers

		if slices.Contains(roleAnswer, *event.OptionIdSuiter) {
			attendie.Role, _ = service.GetRoleByName("Suiter")
		} else if slices.Contains(roleAnswer, *event.OptionIdSpotter) {
			attendie.Role, _ = service.GetRoleByName("Spotter")
		} else if slices.Contains(roleAnswer, *event.OptionIdPhotograph) {
			attendie.Role, _ = service.GetRoleByName("Photograph")
		} else if slices.Contains(roleAnswer, *event.OptionIdSpecialAnimal) {
			attendie.Role, _ = service.GetRoleByName("SpecialAnimal")
		} else if slices.Contains(roleAnswer, *event.OptionIdGuest) {
			attendie.Role, _ = service.GetRoleByName("Guest")
		}

		indexPrivacy := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdPrivacy })
		var err error
		attendie.Privacy, err = strconv.ParseBool(order.Positions[indexParticipation].Answers[indexPrivacy].Answer)
		if err != nil {
			return attendies, err
		}

		attendie.RegistrationTime = order.Datetime

		attendies = append(attendies, attendie)
	}
	return attendies, nil
}

func GetAttendiesFromPretixJsonWithRoleProduct(pretixEvent *entities.Pretix_Event, event *entities.Db_Event) ([]entities.Db_Attendies, error) {
	var attendies []entities.Db_Attendies
	for _, order := range pretixEvent.Results {
		if order.Status == "c" || order.Status == "e" {
			continue
		}
		var attendie entities.Db_Attendies
		attendie.Event = *event
		if event.ItemIdParticipation == nil {
			return attendies, errors.New("no participation found")
		}
		indexParticipation := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdParticipation })
		if event.ItemIdRestaurant == nil {
			attendie.AttendsRestaurant = false
		} else {
			indexRestaurant := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdRestaurant })
			if indexRestaurant != -1 {
				attendie.AttendsRestaurant = true
			} else {
				attendie.AttendsRestaurant = false
			}
		}
		indexRole := slices.IndexFunc(order.Positions, func(p entities.Pretix_Position) bool { return p.Item == *event.ItemIdRole })

		indexName := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdName })
		attendie.Nickname = order.Positions[indexParticipation].Answers[indexName].Answer

		roleProduct := order.Positions[indexRole]

		if roleProduct.Variation == *event.VariationIdSuiter {
			attendie.Role, _ = service.GetRoleByName("Suiter")
		} else if roleProduct.Variation == *event.VariationIdSpotter {
			attendie.Role, _ = service.GetRoleByName("Spotter")
		} else if roleProduct.Variation == *event.VariationIdPhotograph {
			attendie.Role, _ = service.GetRoleByName("Photograph")
		} else if roleProduct.Variation == *event.VariationIdSpecialAnimal {
			attendie.Role, _ = service.GetRoleByName("SpecialAnimal")
		} else if roleProduct.Variation == *event.VariationIdGuest {
			attendie.Role, _ = service.GetRoleByName("Guest")
		}

		indexPrivacy := slices.IndexFunc(order.Positions[indexParticipation].Answers, func(a entities.Pretix_Answer) bool { return a.QuestionsIdentififer == *event.QuestionIdPrivacy })
		var err error
		attendie.Privacy, err = strconv.ParseBool(order.Positions[indexParticipation].Answers[indexPrivacy].Answer)
		if err != nil {
			return attendies, err
		}

		attendies = append(attendies, attendie)
	}
	return attendies, nil
}