oef/scripts/subscribe_participants/main.go

package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strings"

	"git.andreafazzi.eu/andrea/oef/client"
	"git.andreafazzi.eu/andrea/oef/orm"
	"github.com/gocarina/gocsv"
	"gopkg.in/yaml.v2"
)

type RegionContest struct {
	Id       uint
	Category string
	Regions  []string
}

type User struct {
	Username string `csv:"username"`
}

var (
	regionContests map[string]([]*RegionContest)
)

func alreadySubscribed(participant *orm.Participant, contestId uint) bool {
	for _, id := range participant.ContestIDs {
		if id == contestId {
			return true
		}
	}
	return false
}

func main() {
	username := flag.String("username", "admin", "Username")
	password := flag.String("password", "admin", "Password")
	subscribe := flag.Bool("subscribe", true, "Subscribe to the given contest")
	region := flag.Bool("region", false, "Region based subscription")
	unsubscribeAll := flag.Bool("unsubscribe-all", false, "Unsubscribe all participants from all contests")

	juniorContestId := flag.Int("jid", 0, "Contest ID for Junior category")
	seniorContestId := flag.Int("sid", 0, "Contest ID for Senior category")

	participantsCSV := flag.String("participants-csv", "", "Import participants from CSV file")
	// contestId := flag.Int("cid", 0, "Subscribe participants to the given contest ID")

	flag.Parse()

	client, err := client.Dial(flag.Arg(0), *username, *password)
	if err != nil {
		panic(err)
	}

	allParticipants := make([]*orm.Participant, 0)

	log.Println("Read all participants...")
	err = client.ReadAll(&allParticipants)
	if err != nil {
		panic(err)
	}

	if *participantsCSV != "" {
		participants := make([]*orm.Participant, 0)
		users := make([]User, 0)
		data, err := ioutil.ReadFile(*participantsCSV)
		if err != nil {
			panic(err)
		}
		if err := gocsv.Unmarshal(strings.NewReader(string(data)), &users); err != nil {
			panic(err)
		}
		for _, u := range users {
			for _, p := range allParticipants {
				if u.Username == p.User.Username {
					participants = append(participants, p)
				}
			}
		}
		allParticipants = participants
	}

	var updated bool

	if *unsubscribeAll {
		for _, participant := range allParticipants {
			participant.ContestIDs = make(orm.ContestIDs, 0)
			id, err := client.Update(participant)
			if err != nil {
				panic(err)
			}
			log.Printf("Successfully updated participant ID %d", id)
		}
		os.Exit(0)
	}

	if *region {
		data, err := ioutil.ReadFile("regions_contests.yaml")
		if err != nil {
			panic(err)
		}
		err = yaml.Unmarshal(data, &regionContests)
		if err != nil {
			panic(err)
		}

		regions_ids := make(map[string](map[string]uint), 0)

		for _, contest := range regionContests["contests"] {
			for _, region := range contest.Regions {
				if regions_ids[region] == nil {
					regions_ids[region] = make(map[string]uint)
				}
				if contest.Category == "Junior" {
					regions_ids[region]["Junior"] = contest.Id
				} else {
					regions_ids[region]["Senior"] = contest.Id
				}
			}
		}

		for _, participant := range allParticipants {
			for _, contest := range participant.Contests {
				participant.ContestIDs = append(participant.ContestIDs, contest.ID)
			}

			if regions_ids[participant.School.Region.Name] == nil {
				panic(fmt.Errorf("Region not found for participant %v", participant))
			}

			contestId := regions_ids[participant.School.Region.Name][participant.Category.Name]

			if !alreadySubscribed(participant, contestId) {
				// log.Printf("Subscribe %s to contest ID %d", participant, contestId)
				participant.ContestIDs = append(participant.ContestIDs, contestId)
				updated = true
			}
			if updated {
				id, err := client.Update(participant)
				if err != nil {
					panic(err)
				}
				log.Printf("Successfully updated participant ID %d", id)
				updated = false
			}
		}

	} else {
		if *subscribe {
			for _, participant := range allParticipants {
				for _, contest := range participant.Contests {
					participant.ContestIDs = append(participant.ContestIDs, contest.ID)
				}

				if *juniorContestId > 0 && participant.Category.Name == "Junior" {
					if !alreadySubscribed(participant, uint(*juniorContestId)) {
						log.Printf("Subscribe %s to contest ID %d", participant, *juniorContestId)
						participant.ContestIDs = append(participant.ContestIDs, uint(*juniorContestId))
						updated = true

					}
				}
				if *seniorContestId > 0 && participant.Category.Name == "Senior" {
					if !alreadySubscribed(participant, uint(*seniorContestId)) {
						log.Printf("Subscribe %s to contest ID %d", participant, *seniorContestId)
						participant.ContestIDs = append(participant.ContestIDs, uint(*seniorContestId))
						updated = true
					}
				}

				if updated {
					id, err := client.Update(participant)
					if err != nil {
						panic(err)
					}
					log.Printf("Successfully updated participant ID %d", id)
					updated = false
				}
			}
		}
	}

	if !updated {
		log.Println("Nothing to do.")
	}

}