Add Department model

handlers/handlers.go

@@ -50,6 +50,8 @@ var (
 		},
 		SigningMethod: jwt.SigningMethodHS256,
 	})
+
+	models = []string{"teachers", "classes", "subjects", "departments", "activities"}
 )
 
 func (pp PathPattern) RedirectPath(model string, id ...uint) string {
@@ -106,7 +108,7 @@ func Handlers() *mux.Router {
 
 	// Generate model handlers
 
-	for _, model := range []string{"teachers", "classes", "subjects", "activities"} {
+	for _, model := range models {
 		generateHandler(r, model)
 	}
 

orm/department.go

@@ -0,0 +1,152 @@
+package orm
+
+import (
+	"net/http"
+
+	"github.com/jinzhu/gorm"
+	"gogs.carducci-dante.gov.it/karmen/core/renderer"
+)
+
+type Department struct {
+	gorm.Model
+	Name     string
+	Subjects []*Subject
+	Teachers []*Teacher
+}
+
+var (
+	selectUniqueDepartmentTeachers = `
+SELECT DISTINCT classes.* FROM activities 
+INNER JOIN classes on classes.id=activities.class_id 
+WHERE teacher_id=?`
+
+	selectUniqueDepartmentSubjects = `
+SELECT DISTINCT subjects.* FROM activities 
+INNER JOIN subjects on subjects.id=activities.subject_id 
+WHERE activities.teacher_id=?`
+)
+
+func (d *Department) GetID() uint { return d.ID }
+
+func GetDepartment(args map[string]string) (interface{}, error) {
+	var department Department
+	if err := DB().First(&department, args["id"]).Error; err != nil {
+		return nil, err
+	}
+	return &department, nil
+}
+
+func GetDepartmentAll(args map[string]string) (interface{}, error) {
+	var department Department
+
+	id := args["id"]
+
+	if err := DB().Where("id = ?", id).Find(&department).Error; err != nil {
+		return nil, err
+	}
+
+	if err := DB().Raw(selectUniqueDepartmentTeachers, id).Scan(&department.Teachers).Error; err != nil {
+		return nil, err
+	}
+
+	if err := DB().Raw(selectUniqueDepartmentSubjects, id).Scan(&department.Subjects).Error; err != nil {
+		return nil, err
+	}
+
+	return &department, nil
+}
+
+func GetDepartments(args map[string]string) (interface{}, error) {
+	var departments []*Department
+	if err := DB().Order("name").Find(&departments).Error; err != nil {
+		return nil, err
+	}
+	return departments, nil
+}
+
+func GetDepartmentsAll(args map[string]string) (interface{}, error) {
+	var departments []*Department
+	if err := DB().Order("name").Find(&departments).Error; err != nil {
+		return nil, err
+	}
+	for _, department := range departments {
+		department.GetTeachers()
+	}
+	for _, department := range departments {
+		department.GetSubjects()
+	}
+	return departments, nil
+}
+
+func SaveDepartment(department interface{}) (interface{}, error) {
+	if err := DB().Omit("Teachers", "Subjects").Save(department).Error; err != nil {
+		return nil, err
+	}
+	return department, nil
+}
+
+func UpdateDepartment(args map[string]string, r *http.Request) (IDer, error) {
+	department, err := GetDepartment(args)
+	if err != nil {
+		return nil, err
+	}
+	err = renderer.Decode(department, r)
+	if err != nil {
+		return nil, err
+	}
+	_, err = SaveDepartment(department)
+	if err != nil {
+		return nil, err
+	}
+	department, err = GetDepartment(args)
+	if err != nil {
+		return nil, err
+	}
+	return department.(*Department), nil
+}
+
+func AddDepartment(args map[string]string, r *http.Request) (IDer, error) {
+	department := new(Department)
+	err := renderer.Decode(department, r)
+	if err != nil {
+		return nil, err
+	}
+	department, err = CreateDepartment(department)
+	if err != nil {
+		return nil, err
+	}
+
+	return department, nil
+}
+
+func CreateDepartment(department *Department) (*Department, error) {
+	if err := DB().Create(department).Error; err != nil {
+		return nil, err
+	}
+	return department, nil
+}
+
+func DeleteDepartment(args map[string]string, r *http.Request) (IDer, error) {
+	department, err := GetDepartment(args)
+	if err != nil {
+		return nil, err
+	}
+	if err := DB().Unscoped().Delete(department.(*Department)).Error; err != nil {
+		return nil, err
+	}
+	return department.(*Department), nil
+}
+
+func (t *Department) GetTeachers() ([]*Teacher, error) {
+	if err := DB().Raw(selectUniqueDepartmentTeachers, t.ID).Scan(&t.Teachers).Error; err != nil {
+		return nil, err
+	}
+	return t.Teachers, nil
+}
+
+func (t *Department) GetSubjects() ([]*Subject, error) {
+	if err := DB().Raw(selectUniqueDepartmentSubjects, t.ID).Scan(&t.Subjects).Error; err != nil {
+		return nil, err
+	}
+	return t.Subjects, nil
+}

orm/mappings.go

@@ -35,6 +35,17 @@ var (
 		"/api/subjects/{id}/update": GetSubjectForUpdate,
 		"/api/subjects/add/":        GetSubjectForAdd,
 
+		// Departments
+		"/departments":             GetDepartmentsAll,
+		"/departments/{id}":        GetDepartmentAll,
+		"/departments/{id}/update": GetDepartment,
+		"/departments/add/":        GetNothing,
+
+		"/api/departments":             GetDepartmentsAll,
+		"/api/departments/{id}":        GetDepartmentAll,
+		"/api/departments/{id}/update": GetDepartment,
+		"/api/departments/add/":        GetNothing,
+
 		// Activity
 		"/activities":             GetActivitiesAll,
 		"/activities/{id}":        GetActivityAll,
@@ -76,6 +87,15 @@ var (
 		"/api/subjects/{id}/delete": DeleteSubject,
 		"/api/subjects/add/":        AddSubject,
 
+		// Departments
+		"/departments/{id}/update": UpdateDepartment,
+		"/departments/{id}/delete": DeleteDepartment,
+		"/departments/add/":        AddDepartment,
+
+		"/api/departments/{id}/update": UpdateDepartment,
+		"/api/departments/{id}/delete": DeleteDepartment,
+		"/api/departments/add/":        AddDepartment,
+
 		// Activity
 		"/activities/{id}/update": UpdateActivity,
 		"/activities/{id}/delete": DeleteActivity,

orm/orm.go

@@ -8,6 +8,10 @@ import (
 	_ "github.com/jinzhu/gorm/dialects/mysql"
 )
 
+type IDer interface {
+	GetID() uint
+}
+
 type Timetable [][]Activity
 
 type Person interface {
@@ -47,13 +51,6 @@ type Student struct {
 	Class *Class
 }
 
-type Department struct {
-	gorm.Model
-	Name     string
-	Subjects []Subject
-	Teachers []Teacher
-}
-
 type GetFn func(map[string]string) (interface{}, error)
 type PostFn func(map[string]string, *http.Request) (IDer, error)
 

orm/orm_test.go

@@ -157,7 +157,7 @@ func (t *testSuite) TestGetTeachersAll() {
 	t.Equal("MATEMATICA", teachers.([]*Teacher)[0].Subjects[0].Name)
 }
 
-func (t *testSuite) TestGetTeacherActivitiesByClass() {
+func (t *testSuite) TestGetTeacherActByClass() {
 	teacher, err := GetTeacher(map[string]string{"id": "1"})
 	t.Nil(err)
 	if !t.Failed() {
@@ -170,52 +170,6 @@ func (t *testSuite) TestGetTeacherActivitiesByClass() {
 
 }
 
-// func (t *testSuite) TestGetClasses() {
-// 	classes, err := GetClasses()
-// 	t.Nil(err)
-// 	t.Equal(1, len(classes))
-
-// 	class := classes[0]
-// 	teachers, err := class.GetTeachers()
-// 	t.Nil(err)
-// 	t.Equal(9, len(teachers))
-// 	t.Equal(9, len(class.Teachers))
-
-// 	teacher := teachers[0]
-// 	t.Equal("AGOSTINO", teacher.Surname)
-
-// 	classes, err = GetClassesAll()
-// 	t.True(len(classes[0].Teachers) > 0)
-// 	if !t.Failed() {
-// 		t.Equal("AGOSTINO", classes[0].Teachers[0].Surname)
-// 	}
-// }
-
-// func (t *testSuite) TestGetClass() {
-// 	class, err := GetClass("1")
-// 	t.Nil(err)
-// 	if !t.Failed() {
-// 		t.Equal("1 A", class.Name)
-
-// 		// Test teachers
-
-// 		t.True(len(class.Teachers) > 0)
-// 		t.Equal("AGOSTINO", class.Teachers[0].Surname)
-// 		t.Equal("PETRUZZELLI", class.Teachers[8].Surname)
-// 		t.Equal("LUNGA", class.Coordinator.Surname)
-// 		t.Equal("DONADONI", class.Minuter.Surname)
-
-// 		// Test activities
-
-// 		t.True(len(class.Activities) > 0)
-// 		t.Equal("1 A", class.Activities[0].Class.Name)
-// 		t.Equal("AGOSTINO", class.Activities[0].Teacher.Surname)
-// 		t.Equal("MATEMATICA", class.Activities[0].Subject.Name)
-// 		t.Equal(2, class.Activities[0].Hours)
-// 	}
-
-// }
-
 func (t *testSuite) TestSaveTeacher() {
 	teacher, err := GetTeacher(map[string]string{"id": "1"})
 	t.Nil(err)
@@ -241,3 +195,20 @@ func (t *testSuite) TestCreateDeleteTeacher() {
 		t.Equal(9, len(teachers.([]*Teacher)))
 	}
 }
+
+func (t *testSuite) TestGetDepartments() {
+	departments, err := GetDepartments(map[string]string{})
+	t.Nil(err)
+	t.Equal(9, len(departments.([]*Department)))
+
+	if !t.Failed() {
+		department := departments.([]*Department)[0]
+		subjects, err := department.GetSubjects()
+		t.Nil(err)
+		t.Equal(1, len(subjects))
+		t.Equal(1, len(department.Subjects))
+
+		subject := subjects[0]
+		t.Equal("MATEMATICA", subject.Name)
+	}
+}

orm/subject.go

@@ -15,17 +15,24 @@ WHERE subject_id=?
 
 type Subject struct {
 	gorm.Model
+
 	Name         string
-	DepartmentId uint
-	Teachers     []*Teacher
-	Activities   []*Activity
+	DepartmentID uint
+
+	Teachers   []*Teacher
+	Activities []*Activity
 }
 
 type SubjectForUpdate struct {
 	Subject Subject
+
+	SelectedDepartment map[uint]string
+	AllDepartments     []*Department
 }
 
-type SubjectForAdd struct{}
+type SubjectForAdd struct {
+	AllDepartments []*Department
+}
 
 func (s *Subject) GetID() uint { return s.ID }
 
@@ -151,9 +158,22 @@ func GetSubjectForUpdate(args map[string]string) (interface{}, error) {
 		return nil, err
 	}
 
+	if err := DB().Find(&data.AllDepartments).Error; err != nil {
+		return nil, err
+	}
+
+	data.SelectedDepartment = make(map[uint]string)
+	data.SelectedDepartment[data.Subject.DepartmentID] = "selected"
+
 	return data, nil
 }
 
 func GetSubjectForAdd(args map[string]string) (interface{}, error) {
-	return nil, nil
+	var data SubjectForAdd
+
+	if err := DB().Find(&data.AllDepartments).Error; err != nil {
+		return nil, err
+	}
+
+	return data, nil
 }

orm/teacher.go

@@ -19,10 +19,6 @@ type Teacher struct {
 	CurrHours   int
 }
 
-type IDer interface {
-	GetID() uint
-}
-
 var (
 	selectDistinctTeachers = `
 SELECT teachers.* FROM activities