karmen/orm/group.go

package orm

import (
	"fmt"
	"net/http"
	"strings"

	"github.com/gobwas/glob"
	"github.com/jinzhu/gorm"
	"gogs.carducci-dante.gov.it/karmen/core/renderer"
)

type Group struct {
	gorm.Model

	Name string

	Query string

	TeacherIDs []uint `schema:"teacher_ids" gorm:"-"`

	Teachers []*Teacher `gorm:"many2many:group_teachers"`
}

type GroupForAdd struct {
	AllTeachers []*Teacher
}

type GroupForUpdate struct {
	Group Group

	AllTeachers []*Teacher

	SelectedTeacher map[uint]string
}

func (g *Group) GetID() uint { return g.ID }

func GetGroups(args map[string]string) (interface{}, error) {
	return GetGroupsAll(args)
}

func GetGroupsAll(args map[string]string) (interface{}, error) {
	var groups []*Group

	if err := DB().Preload("Teachers").Order("name").Find(&groups).Error; err != nil {
		return nil, err
	}

	for _, group := range groups {
		if group.Query != "" {
			err := group.updateTeachersAssociation()
			if err != nil {
				return nil, err
			}
		}

	}

	return groups, nil
}

func GetGroupAll(args map[string]string) (interface{}, error) {
	var group Group

	id := args["id"]

	if err := DB().Preload("Teachers").Where("id = ?", id).Find(&group).Error; err != nil {
		return nil, err
	}

	if group.Query != "" {
		err := group.updateTeachersAssociation()
		if err != nil {
			return nil, err
		}
	}

	return group, nil
}

func GetGroupForUpdate(args map[string]string) (interface{}, error) {
	var data GroupForUpdate

	id := args["id"]

	if err := DB().Preload("Teachers").First(&data.Group, id).Error; err != nil {
		return nil, err
	}

	if err := DB().Find(&data.AllTeachers).Error; err != nil {
		return nil, err
	}

	data.SelectedTeacher = make(map[uint]string)
	for _, t := range data.Group.Teachers {
		data.SelectedTeacher[t.ID] = "selected"
	}

	return data, nil
}

func GetGroupForAdd(args map[string]string) (interface{}, error) {
	var data GroupForAdd

	if err := DB().Find(&data.AllTeachers).Error; err != nil {
		return nil, err
	}

	return data, nil
}

func GetGroup(args map[string]string) (interface{}, error) {
	var group Group

	id := args["id"]

	if err := DB().Preload("Teachers").Where("id = ?", id).Find(&group).Error; err != nil {
		return nil, err
	}

	return &group, nil

}

func UpdateGroup(args map[string]string, r *http.Request) (IDer, error) {
	group, err := GetGroup(args)
	if err != nil {
		return nil, err
	}
	err = renderer.Decode(group, r)
	if err != nil {
		return nil, err
	}

	if err := DB().Where(group.(*Group).TeacherIDs).Find(&group.(*Group).Teachers).Error; err != nil {
		return nil, err
	}

	teachers, err := group.(*Group).executeTeacherQuery()

	group.(*Group).Teachers = append(group.(*Group).Teachers, teachers...)

	_, err = SaveGroup(group)
	if err != nil {
		return nil, err
	}
	if err := DB().Model(group).Association("Teachers").Replace(group.(*Group).Teachers).Error; err != nil {
		return nil, err
	}

	group, err = GetGroup(args)
	if err != nil {
		return nil, err
	}
	return group.(*Group), nil
}

func SaveGroup(group interface{}) (interface{}, error) {
	if err := DB().Save(group).Error; err != nil {
		return nil, err
	}
	return group, nil
}

func DeleteGroup(args map[string]string, r *http.Request) (IDer, error) {
	group, err := GetGroup(args)
	if err != nil {
		return nil, err
	}
	if err := DB().Unscoped().Delete(group.(*Group)).Error; err != nil {
		return nil, err
	}
	return group.(*Group), nil
}

func AddGroup(args map[string]string, r *http.Request) (IDer, error) {
	group := new(Group)
	err := renderer.Decode(group, r)
	if err != nil {
		return nil, err
	}
	group, err = CreateGroup(group)
	if err != nil {
		return nil, err
	}
	return group, nil
}

func CreateGroup(group *Group) (*Group, error) {
	var groups []*Group
	if err := DB().Where("name=?", group.Name).Find(&groups).Error; err != nil {
		return nil, err
	}
	if len(groups) > 0 {
		return nil, fmt.Errorf("Group %s already exists!", group.Name)
	}

	if err := DB().Where(group.TeacherIDs).Find(&group.Teachers).Error; err != nil {
		return nil, err
	}

	teachers, err := group.executeTeacherQuery()
	if err != nil {
		return nil, err
	}
	group.Teachers = append(group.Teachers, teachers...)
	if err := DB().Create(group).Error; err != nil {
		return nil, err
	}
	return group, nil
}

func (group *Group) RestAPIPath() string {
	return "groupes"
}

func (group *Group) updateTeachersAssociation() error {
	teachers, err := group.executeTeacherQuery()
	if err != nil {
		return err
	}
	if err := DB().Model(group).Association("Teachers").Replace(teachers).Error; err != nil {
		return err
	}
	return nil
}

func (group *Group) executeTeacherQuery() ([]*Teacher, error) {
	var (
		result      []*Teacher
		allTeachers []*Teacher
	)

	if group.Query != "" {

		fields := strings.Split(group.Query, " ")

		if err := DB().Find(&allTeachers).Error; err != nil {
			return nil, err
		}

		for _, field := range fields {

			nameValue := strings.Split(field, ":")

			if len(nameValue) < 2 {
				return nil, fmt.Errorf("Error parsing search query %s on field %s", group.Query, field)
			}

			name := nameValue[0]
			value := nameValue[1]

			switch name {
			case "surname":
				g, err := glob.Compile(value)
				if err != nil {
					return nil, err
				}

				for _, t := range allTeachers {
					if g.Match(t.Surname) {
						result = append(result, t)
					}
				}

			case "coordinator":
				for _, t := range allTeachers {
					c, err := t.CoordinatorClasses()
					if err != nil {
						return nil, err
					}
					if len(c) > 0 {
						result = append(result, t)
					}
				}

			}
		}

	}

	return result, nil
}