core/orm/group.go

package orm

import (
	"fmt"
	"log"
	"net/http"

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

type Group struct {
	gorm.Model

	Name string

	Search 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 GetGroupsAll(args map[string]string) (interface{}, error) {
	var groups []*Group
	if err := DB().Debug().Preload("Teachers").Order("name").Find(&groups).Error; 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
	}

	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
	}

	log.Println("Before decoding...", group.(*Group).TeacherIDs)
	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
	}
	log.Println("After decoding...", group.(*Group).TeacherIDs)
	_, err = SaveGroup(group)
	if 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) {
	return nil, 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
	}

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