420 lines
13 KiB
Go
420 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
func declareAPIWorksRoutes(router *gin.RouterGroup) {
|
|
router.GET("/works", func(c *gin.Context) {
|
|
var u *User
|
|
if user, ok := c.Get("LoggedUser"); ok {
|
|
u = user.(*User)
|
|
}
|
|
|
|
var works []*Work
|
|
var err error
|
|
if u == nil {
|
|
works, err = getWorks(fmt.Sprintf("WHERE shown = TRUE AND NOW() > start_availability AND promo = %d ORDER BY start_availability ASC", currentPromo))
|
|
} else if u.IsAdmin {
|
|
works, err = getWorks("ORDER BY promo DESC, start_availability ASC")
|
|
} else {
|
|
works, err = getWorks(fmt.Sprintf("WHERE shown = TRUE AND promo = %d ORDER BY start_availability ASC", u.Promo))
|
|
}
|
|
|
|
if err != nil {
|
|
log.Println("Unable to getWorks:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Impossible de récupérer la liste des travaux. Veuillez réessayer dans quelques instants."})
|
|
return
|
|
}
|
|
|
|
var response []*Work
|
|
if u == nil || u.IsAdmin {
|
|
response = works
|
|
} else {
|
|
for _, w := range works {
|
|
if w.Group == "" || strings.Contains(u.Groups, ","+w.Group+",") {
|
|
w.Group = ""
|
|
response = append(response, w)
|
|
}
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response)
|
|
})
|
|
router.GET("/all_works", func(c *gin.Context) {
|
|
var u *User
|
|
if user, ok := c.Get("LoggedUser"); ok {
|
|
u = user.(*User)
|
|
}
|
|
|
|
var works []*OneWork
|
|
var err error
|
|
if u == nil {
|
|
works, err = allWorks(fmt.Sprintf("WHERE shown = TRUE AND NOW() > start_availability AND promo = %d ORDER BY start_availability ASC, end_availability ASC", currentPromo))
|
|
} else if u.IsAdmin {
|
|
works, err = allWorks("ORDER BY promo DESC, start_availability ASC")
|
|
} else {
|
|
works, err = allWorks(fmt.Sprintf("WHERE shown = TRUE AND promo = %d ORDER BY start_availability ASC, end_availability ASC", u.Promo))
|
|
}
|
|
|
|
if err != nil {
|
|
log.Println("Unable to getWorks:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Impossible de récupérer la liste des travaux. Veuillez réessayer dans quelques instants."})
|
|
return
|
|
}
|
|
|
|
var response []*OneWork
|
|
if u == nil || u.IsAdmin {
|
|
response = works
|
|
} else {
|
|
for _, w := range works {
|
|
if w.Group == "" || strings.Contains(u.Groups, ","+w.Group+",") {
|
|
w.Group = ""
|
|
response = append(response, w)
|
|
}
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response)
|
|
})
|
|
}
|
|
|
|
func declareAPIAdminWorksRoutes(router *gin.RouterGroup) {
|
|
router.POST("/works", func(c *gin.Context) {
|
|
var new Work
|
|
if err := c.ShouldBindJSON(&new); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
if new.Promo == 0 {
|
|
new.Promo = currentPromo
|
|
}
|
|
|
|
work, err := NewWork(new.Title, new.Promo, new.Group, new.Shown, new.SubmissionURL, new.StartAvailability, new.EndAvailability)
|
|
if err != nil {
|
|
log.Println("Unable to NewWork:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during work creation"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, work)
|
|
})
|
|
|
|
worksRoutes := router.Group("/works/:wid")
|
|
worksRoutes.Use(workHandler)
|
|
|
|
worksRoutes.PUT("", func(c *gin.Context) {
|
|
current := c.MustGet("work").(*Work)
|
|
|
|
var new Work
|
|
if err := c.ShouldBindJSON(&new); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
new.Id = current.Id
|
|
|
|
work, err := new.Update()
|
|
if err != nil {
|
|
log.Println("Unable to Update work:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during work update."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, work)
|
|
})
|
|
worksRoutes.DELETE("", func(c *gin.Context) {
|
|
w := c.MustGet("work").(*Work)
|
|
|
|
_, err := w.Delete()
|
|
if err != nil {
|
|
log.Println("Unable to Delte work:", err)
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during work deletion."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, nil)
|
|
})
|
|
|
|
// Grades related to works
|
|
worksRoutes.GET("/grades", func(c *gin.Context) {
|
|
w := c.MustGet("work").(*Work)
|
|
|
|
grades, err := w.GetGrades("")
|
|
if err != nil {
|
|
log.Printf("Unable to GetGrades(wid=%d): %s", w.Id, err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during grades retrieval."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, grades)
|
|
})
|
|
worksRoutes.PUT("/grades", func(c *gin.Context) {
|
|
w := c.MustGet("work").(*Work)
|
|
|
|
var grades []WorkGrade
|
|
if err := c.ShouldBindJSON(&grades); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
|
|
return
|
|
}
|
|
|
|
_, err := w.DeleteGrades()
|
|
if err != nil {
|
|
log.Printf("Unable to DeleteGrades(wid=%d): %s", w.Id, err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during grades deletion."})
|
|
return
|
|
}
|
|
|
|
err = w.AddGrades(grades)
|
|
if err != nil {
|
|
log.Printf("Unable to AddGrades(wid=%d): %s", w.Id, err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during grades erasing."})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, true)
|
|
})
|
|
}
|
|
|
|
func declareAPIAuthWorksRoutes(router *gin.RouterGroup) {
|
|
worksRoutes := router.Group("/works/:wid")
|
|
worksRoutes.Use(workHandler)
|
|
|
|
worksRoutes.GET("", func(c *gin.Context) {
|
|
u := c.MustGet("LoggedUser").(*User)
|
|
w := c.MustGet("work").(*Work)
|
|
|
|
if u.IsAdmin {
|
|
c.JSON(http.StatusOK, w)
|
|
} else if w.Shown && w.StartAvailability.Before(time.Now()) && (w.Group == "" || strings.Contains(u.Groups, ","+w.Group+",")) {
|
|
c.JSON(http.StatusOK, w)
|
|
} else {
|
|
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"errmsg": "Permission denied"})
|
|
}
|
|
})
|
|
|
|
// Grades related to works
|
|
worksRoutes.GET("/score", func(c *gin.Context) {
|
|
u := c.MustGet("LoggedUser").(*User)
|
|
w := c.MustGet("work").(*Work)
|
|
|
|
if g, err := u.GetMyWorkGrade(w); err != nil && errors.Is(err, sql.ErrNoRows) {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Aucune note n'a été attribuée pour ce travail. Avez-vous rendu ce travail ?"})
|
|
} else if err != nil {
|
|
log.Printf("Unable to GetMyWorkGrade(uid=%d;wid=%d): %s", u.Id, w.Id, err.Error())
|
|
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during grade calculation."})
|
|
} else {
|
|
c.JSON(http.StatusOK, g)
|
|
}
|
|
})
|
|
|
|
declareAPIAuthRepositoriesRoutes(worksRoutes)
|
|
}
|
|
|
|
func workHandler(c *gin.Context) {
|
|
if wid, err := strconv.Atoi(string(c.Param("wid"))); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Bad work identifier."})
|
|
return
|
|
} else if work, err := getWork(wid); err != nil {
|
|
c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Work not found."})
|
|
return
|
|
} else {
|
|
c.Set("work", work)
|
|
c.Next()
|
|
}
|
|
}
|
|
|
|
type OneWork struct {
|
|
Kind string `json:"kind"`
|
|
Id int64 `json:"id"`
|
|
Title string `json:"title"`
|
|
Promo uint `json:"promo"`
|
|
Group string `json:"group"`
|
|
Shown bool `json:"shown"`
|
|
Direct *int64 `json:"direct"`
|
|
SubmissionURL *string `json:"submission_url"`
|
|
Corrected bool `json:"corrected"`
|
|
StartAvailability time.Time `json:"start_availability"`
|
|
EndAvailability time.Time `json:"end_availability"`
|
|
}
|
|
|
|
func allWorks(cnd string, param ...interface{}) (items []*OneWork, err error) {
|
|
if rows, errr := DBQuery("SELECT kind, id, title, promo, grp, shown, direct, submission_url, corrected, start_availability, end_availability FROM all_works "+cnd, param...); errr != nil {
|
|
return nil, errr
|
|
} else {
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var w OneWork
|
|
if err = rows.Scan(&w.Kind, &w.Id, &w.Title, &w.Promo, &w.Group, &w.Shown, &w.Direct, &w.SubmissionURL, &w.Corrected, &w.StartAvailability, &w.EndAvailability); err != nil {
|
|
return
|
|
}
|
|
items = append(items, &w)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
type Work struct {
|
|
Id int64 `json:"id"`
|
|
Title string `json:"title"`
|
|
Promo uint `json:"promo"`
|
|
Group string `json:"group"`
|
|
Shown bool `json:"shown"`
|
|
SubmissionURL *string `json:"submission_url"`
|
|
Corrected bool `json:"corrected"`
|
|
StartAvailability time.Time `json:"start_availability"`
|
|
EndAvailability time.Time `json:"end_availability"`
|
|
}
|
|
|
|
func getWorks(cnd string, param ...interface{}) (items []*Work, err error) {
|
|
if rows, errr := DBQuery("SELECT id_work, title, promo, grp, shown, submission_url, corrected, start_availability, end_availability FROM works "+cnd, param...); errr != nil {
|
|
return nil, errr
|
|
} else {
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var w Work
|
|
if err = rows.Scan(&w.Id, &w.Title, &w.Promo, &w.Group, &w.Shown, &w.SubmissionURL, &w.Corrected, &w.StartAvailability, &w.EndAvailability); err != nil {
|
|
return
|
|
}
|
|
items = append(items, &w)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
func getWork(id int) (w *Work, err error) {
|
|
w = new(Work)
|
|
err = DBQueryRow("SELECT id_work, title, promo, grp, shown, submission_url, corrected, start_availability, end_availability FROM works WHERE id_work=?", id).Scan(&w.Id, &w.Title, &w.Promo, &w.Group, &w.Shown, &w.SubmissionURL, &w.Corrected, &w.StartAvailability, &w.EndAvailability)
|
|
return
|
|
}
|
|
|
|
func NewWork(title string, promo uint, group string, shown bool, submissionurl *string, startAvailability time.Time, endAvailability time.Time) (*Work, error) {
|
|
if res, err := DBExec("INSERT INTO works (title, promo, grp, shown, submission_url, start_availability, end_availability) VALUES (?, ?, ?, ?, ?, ?, ?)", title, promo, group, shown, submissionurl, startAvailability, endAvailability); err != nil {
|
|
return nil, err
|
|
} else if wid, err := res.LastInsertId(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return &Work{wid, title, promo, group, shown, submissionurl, false, startAvailability, endAvailability}, nil
|
|
}
|
|
}
|
|
|
|
func (w *Work) Update() (*Work, error) {
|
|
if _, err := DBExec("UPDATE works SET title = ?, promo = ?, grp = ?, shown = ?, submission_url = ?, corrected = ?, start_availability = ?, end_availability = ? WHERE id_work = ?", w.Title, w.Promo, w.Group, w.Shown, w.SubmissionURL, w.Corrected, w.StartAvailability, w.EndAvailability, w.Id); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return w, err
|
|
}
|
|
}
|
|
|
|
func (w *Work) Delete() (int64, error) {
|
|
if res, err := DBExec("DELETE FROM works WHERE id_work = ?", w.Id); err != nil {
|
|
return 0, err
|
|
} else if nb, err := res.RowsAffected(); err != nil {
|
|
return 0, err
|
|
} else {
|
|
return nb, err
|
|
}
|
|
}
|
|
|
|
func ClearWorks() (int64, error) {
|
|
if res, err := DBExec("DELETE FROM works"); err != nil {
|
|
return 0, err
|
|
} else if nb, err := res.RowsAffected(); err != nil {
|
|
return 0, err
|
|
} else {
|
|
return nb, err
|
|
}
|
|
}
|
|
|
|
type WorkGrade struct {
|
|
Id int64 `json:"id"`
|
|
Login string `json:"login,omit_empty"`
|
|
IdUser int64 `json:"id_user,omit_empty"`
|
|
IdWork int64 `json:"id_work,omit_empty"`
|
|
Date time.Time `json:"date"`
|
|
Grade float64 `json:"score"`
|
|
Comment string `json:"comment,omit_empty"`
|
|
}
|
|
|
|
func (w *Work) GetGrades(cnd string, param ...interface{}) (grades []WorkGrade, err error) {
|
|
param = append([]interface{}{w.Id}, param...)
|
|
|
|
if rows, errr := DBQuery("SELECT G.id_gradation, G.id_user, U.login, G.id_work, G.date, G.grade, G.comment FROM user_work_grades G INNER JOIN users U ON U.id_user = G.id_user WHERE id_work = ? "+cnd, param...); errr != nil {
|
|
return nil, errr
|
|
} else {
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var g WorkGrade
|
|
if err = rows.Scan(&g.Id, &g.IdUser, &g.Login, &g.IdWork, &g.Date, &g.Grade, &g.Comment); err != nil {
|
|
return
|
|
}
|
|
grades = append(grades, g)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
func (u *User) GetMyWorkGrade(w *Work) (g WorkGrade, err error) {
|
|
err = DBQueryRow("SELECT id_gradation, id_user, id_work, date, grade, comment FROM user_work_grades WHERE id_work = ? AND id_user = ? ORDER BY date DESC LIMIT 1", w.Id, u.Id).Scan(&g.Id, &g.IdUser, &g.IdWork, &g.Date, &g.Grade, &g.Comment)
|
|
return
|
|
}
|
|
|
|
func (w *Work) AddGrades(grades []WorkGrade) error {
|
|
var zerotime time.Time
|
|
for i, g := range grades {
|
|
if g.IdUser == 0 {
|
|
if u, err := getUserByLogin(g.Login); err != nil {
|
|
return fmt.Errorf("user %q: %w", g.Login, err)
|
|
} else {
|
|
grades[i].IdUser = u.Id
|
|
}
|
|
}
|
|
if zerotime == g.Date {
|
|
grades[i].Date = time.Now()
|
|
}
|
|
}
|
|
|
|
for _, g := range grades {
|
|
if _, err := DBExec("INSERT INTO user_work_grades (id_user, id_work, date, grade, comment) VALUES (?, ?, ?, ?, ?)", g.IdUser, w.Id, g.Date, g.Grade, g.Comment); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (w *Work) DeleteGrades() (int64, error) {
|
|
if res, err := DBExec("DELETE FROM user_work_grades WHERE id_work = ?", w.Id); err != nil {
|
|
return 0, err
|
|
} else if nb, err := res.RowsAffected(); err != nil {
|
|
return 0, err
|
|
} else {
|
|
return nb, err
|
|
}
|
|
}
|