server/admin/api_theme.go

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"strconv"

	"srs.epita.fr/fic-server/libfic"
)

var ApiThemesRouting = map[string]DispatchFunction{
	"GET":    listTheme,
	"PATCH":  updateTheme,
	"POST":   creationTheme,
	"DELETE": deletionTheme,
}

type exportedExercice struct {
	Title  string `json:"title"`
	Gain   int64  `json:"gain"`
	Solved int64  `json:"solved"`
	Tried  int64  `json:"tried"`
}

type exportedTheme struct {
	Name      string                      `json:"name"`
	Authors   string                      `json:"authors"`
	Exercices map[string]exportedExercice `json:"exercices"`
}

func exportThemes() (interface{}, error) {
	if themes, err := fic.GetThemes(); err != nil {
		return nil, err
	} else {
		ret := map[string]exportedTheme{}
		for _, theme := range themes {
			if exercices, err := theme.GetExercices(); err != nil {
				return nil, err
			} else {
				exos := map[string]exportedExercice{}
				for _, exercice := range exercices {
					exos[fmt.Sprintf("%d", exercice.Id)] = exportedExercice{
						exercice.Title,
						exercice.Gain,
						exercice.SolvedCount(),
						exercice.TriedTeamCount(),
					}
				}
				ret[fmt.Sprintf("%d", theme.Id)] = exportedTheme{
					theme.Name,
					theme.Authors[:len(theme.Authors)-1],
					exos,
				}
			}
		}

		return ret, nil
	}
}

func bindingFiles() (string, error) {
	if files, err := fic.GetFiles(); err != nil {
		return "", err
        } else {
	        ret := ""
	        for _, file := range files {
			ret += fmt.Sprintf("%s;%s\n", file.GetOrigin(), file.Path)
		}
		return ret, nil
	}
}

func getTheme(args []string) (fic.Theme, error) {
	if tid, err := strconv.Atoi(string(args[0])); err != nil {
		return fic.Theme{}, err
	} else {
		return fic.GetTheme(tid)
	}
}

func getExercice(args []string) (fic.Exercice, error) {
	if theme, err := getTheme(args); err != nil {
		return fic.Exercice{}, err
	} else if eid, err := strconv.Atoi(string(args[1])); err != nil {
		return fic.Exercice{}, err
	} else {
		return theme.GetExercice(eid)
	}
}

func listTheme(args []string, body []byte) (interface{}, error) {
	if len(args) == 3 {
		if e, err := getExercice(args); err != nil {
			return nil, err
		} else {
			if args[2] == "files" {
				return e.GetFiles()
			} else if args[2] == "keys" {
				return e.GetKeys()
			}
		}
	} else if len(args) == 2 {
		if args[1] == "exercices" {
			if theme, err := getTheme(args); err != nil {
				return nil, err
			} else {
				return theme.GetExercices()
			}
		} else {
			return getExercice(args)
		}
	} else if len(args) == 1 {
		if args[0] == "files-bindings" {
			return bindingFiles()
		} else if args[0] == "themes.json" {
			return exportThemes()
		} else {
			return getTheme(args)
		}
	} else if len(args) == 0 {
		// List all themes
		return fic.GetThemes()
	}
	return nil, nil
}

type uploadedTheme struct {
	Name    string
	Authors string
}

func creationTheme(args []string, body []byte) (interface{}, error) {
	if len(args) >= 1 {
		if theme, err := getTheme(args); err != nil {
			return nil, err
		} else {
			return createExercice(theme, args[1:], body)
		}
	} else if len(args) == 0 {
		// Create a new theme
		var ut uploadedTheme
		if err := json.Unmarshal(body, &ut); err != nil {
			return nil, err
		}

		if len(ut.Name) == 0 {
			return nil, errors.New("Theme's name not filled")
		}

		return fic.CreateTheme(ut.Name, ut.Authors)
	} else {
		return nil, nil
	}
}

func updateTheme(args []string, body []byte) (interface{}, error) {
	if len(args) == 2 {
		// Update an exercice
		var ue fic.Exercice
		if err := json.Unmarshal(body, &ue); err != nil {
			return nil, err
		}

		if len(ue.Title) == 0 {
			return nil, errors.New("Exercice's title not filled")
		}

		if _, err := ue.Update(); err != nil {
			return nil, err
		}

		return ue, nil
	} else if len(args) == 1 {
		// Update a theme
		var ut fic.Theme
		if err := json.Unmarshal(body, &ut); err != nil {
			return nil, err
		}

		if len(ut.Name) == 0 {
			return nil, errors.New("Theme's name not filled")
		}

		return ut.Update()
	} else {
		return nil, nil
	}
}

func deletionTheme(args []string, body []byte) (interface{}, error) {
	if len(args) == 2 {
		if exercice, err := getExercice(args); err != nil {
			return nil, err
		} else {
			return exercice.Delete()
		}
	} else if len(args) == 1 {
		if theme, err := getTheme(args); err != nil {
			return nil, err
		} else {
			return theme.Delete()
		}
	} else {
		return nil, nil
	}
}