fic/server
Archived
1
0
Fork 0
Code Issues Pull requests 10 Releases Wiki Activity

Move common structs to libfic

Browse source
This commit is contained in:
nemunaire 2016-01-13 20:25:25 +01:00
commit 92b81e467f
10 changed files with 42 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

16
admin/api_team.go
View file

@ -4,6 +4,8 @@ import (
"encoding/json"
"fmt"
"strconv"
"srs.epita.fr/fic-server/libfic"
)
var ApiTeamsRouting = map[string]DispatchFunction{
@ -25,7 +27,7 @@ type uploadedMember struct {
}
func nginxGenTeam() (string, error) {
if teams, err := GetTeams(); err != nil {
if teams, err := fic.GetTeams(); err != nil {
return "", err
} else {
ret := ""
@ -43,14 +45,14 @@ func listTeam(args []string, body []byte) (interface{}, error) {
return nginxGenTeam()
} else if tid, err := strconv.Atoi(string(args[0])); err != nil {
return nil, err
} else if team, err := GetTeam(tid); err != nil {
} else if team, err := fic.GetTeam(tid); err != nil {
return nil, err
} else {
return team.GetMembers()
}
} else if len(args) == 0 {
// List all teams
return GetTeams()
return fic.GetTeams()
} else {
return nil, nil
}
@ -64,7 +66,7 @@ func creationTeam(args []string, body []byte) (interface{}, error) {
return nil, err
}
return CreateTeam(ut.Name)
return fic.CreateTeam(ut.Name)
} else {
return nil, nil
}
@ -75,7 +77,7 @@ func creationTeamMembers(args []string, body []byte) (interface{}, error) {
// List given team
if tid, err := strconv.Atoi(string(args[0])); err != nil {
return nil, err
} else if team, err := GetTeam(tid); err != nil {
} else if team, err := fic.GetTeam(tid); err != nil {
return nil, err
} else {
var member uploadedMember
@ -94,7 +96,7 @@ func creationTeamMembers(args []string, body []byte) (interface{}, error) {
return nil, err
}
if team, err := CreateTeam(""); err != nil {
if team, err := fic.CreateTeam(""); err != nil {
return nil, err
} else {
for _, member := range members {
@ -114,7 +116,7 @@ func deletionTeam(args []string, body []byte) (interface{}, error) {
if len(args) == 1 {
if tid, err := strconv.Atoi(string(args[0])); err != nil {
return nil, err
} else if team, err := GetTeam(tid); err != nil {
} else if team, err := fic.GetTeam(tid); err != nil {
return nil, err
} else {
return team.Delete()

22
admin/api_theme.go
View file

@ -4,6 +4,8 @@ import (
"encoding/json"
"errors"
"strconv"
"srs.epita.fr/fic-server/libfic"
)
var ApiThemesRouting = map[string]DispatchFunction{
@ -25,19 +27,19 @@ type uploadedExercice struct {
VideoURI string
}
func getTheme(args []string) (Theme, error) {
func getTheme(args []string) (fic.Theme, error) {
if tid, err := strconv.Atoi(string(args[0])); err != nil {
return Theme{}, err
return fic.Theme{}, err
} else {
return GetTheme(tid)
return fic.GetTheme(tid)
}
}
func getExercice(args []string) (Exercice, error) {
func getExercice(args []string) (fic.Exercice, error) {
if theme, err := getTheme(args); err != nil {
return Exercice{}, err
return fic.Exercice{}, err
} else if eid, err := strconv.Atoi(string(args[1])); err != nil {
return Exercice{}, err
return fic.Exercice{}, err
} else {
return theme.GetExercice(eid)
}
@ -50,7 +52,7 @@ func listTheme(args []string, body []byte) (interface{}, error) {
return getTheme(args)
} else if len(args) == 0 {
// List all themes
return GetThemes()
return fic.GetThemes()
} else {
return nil, nil
}
@ -71,9 +73,9 @@ func creationTheme(args []string, body []byte) (interface{}, error) {
return nil, errors.New("Title not filled")
}
var depend *Exercice = nil
var depend *fic.Exercice = nil
if ue.Depend != nil {
if d, err := GetExercice(*ue.Depend); err != nil {
if d, err := fic.GetExercice(*ue.Depend); err != nil {
return nil, err
} else {
depend = &d
@ -93,7 +95,7 @@ func creationTheme(args []string, body []byte) (interface{}, error) {
return nil, errors.New("Theme's name not filled")
}
return CreateTheme(ut.Name)
return fic.CreateTheme(ut.Name)
} else {
return nil, nil
}

109
admin/db.go
View file

@ -1,109 +0,0 @@
package main
import (
"database/sql"
_ "github.com/mattn/go-sqlite3"
)
var db *sql.DB
func DBInit(path string) error {
var err error
if db, err = sql.Open("sqlite3", path); err != nil {
return err
}
_, err = db.Exec(`
PRAGMA foreign_keys=ON;
`)
return err
}
func DBCreate() error {
_, err := db.Exec(`
CREATE TABLE IF NOT EXISTS themes(
id_theme INTEGER NOT NULL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS teams(
id_team INTEGER NOT NULL PRIMARY KEY,
name TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS team_certificates(
id_team INTEGER NOT NULL PRIMARY KEY,
revoked INTEGER NOT NULL,
FOREIGN KEY(id_team) REFERENCES teams(id_team)
);
CREATE TABLE IF NOT EXISTS team_members(
id_member INTEGER NOT NULL PRIMARY KEY,
id_team INTEGER,
firstname TEXT NOT NULL,
lastname TEXT NOT NULL,
nickname TEXT NOT NULL,
company TEXT NOT NULL,
FOREIGN KEY(id_team) REFERENCES teams(id_team)
);
CREATE TABLE IF NOT EXISTS exercices(
id_exercice INTEGER NOT NULL PRIMARY KEY,
id_theme INTEGER NOT NULL,
title TEXT NOT NULL,
statement TEXT NOT NULL,
hint TEXT NOT NULL,
depend INTEGER,
gain INTEGER NOT NULL,
video_uri TEXT NOT NULL,
FOREIGN KEY(id_theme) REFERENCES themes(id_theme),
FOREIGN KEY(depend) REFERENCES exercices(id_exercice)
);
CREATE TABLE IF NOT EXISTS exercice_files(
id_file INTEGER NOT NULL PRIMARY KEY,
path TEXT NOT NULL UNIQUE,
id_exercice INTEGER NOT NULL,
name TEXT NOT NULL,
sha1 BLOB NOT NULL,
FOREIGN KEY(id_exercice) REFERENCES exercices(id_exercice)
);
CREATE TABLE IF NOT EXISTS exercice_keys(
id_key INTEGER NOT NULL PRIMARY KEY,
id_exercice INTEGER NOT NULL,
type TEXT NOT NULL,
value BLOB NOT NULL,
FOREIGN KEY(id_exercice) REFERENCES exercices(id_exercice)
);
CREATE TABLE IF NOT EXISTS exercice_solved(
id_exercice INTEGER NOT NULL,
id_team INTEGER NOT NULL,
time TIMESTAMP NOT NULL,
FOREIGN KEY(id_exercice) REFERENCES exercices(id_exercice),
FOREIGN KEY(id_team) REFERENCES teams(id_team)
);
CREATE TABLE IF NOT EXISTS exercice_tries(
id_exercice INTEGER NOT NULL,
id_team INTEGER NOT NULL,
time TIMESTAMP NOT NULL,
FOREIGN KEY(id_exercice) REFERENCES exercices(id_exercice),
FOREIGN KEY(id_team) REFERENCES teams(id_team)
);
`)
return err
}
func DBClose() error {
return db.Close()
}
func DBPrepare(query string) (*sql.Stmt, error) {
return db.Prepare(query)
}
func DBQuery(query string, args ...interface{}) (*sql.Rows, error) {
return db.Query(query, args...)
}
func DBExec(query string, args ...interface{}) (sql.Result, error) {
return db.Exec(query, args...)
}
func DBQueryRow(query string, args ...interface{}) *sql.Row {
return db.QueryRow(query, args...)
}

111
admin/exercice.go
View file

@ -1,111 +0,0 @@
package main
import (
"time"
)
type Exercice struct {
Id int64 `json:"id"`
Title string `json:"title"`
Statement string `json:"statement"`
Hint string `json:"hint"`
Depend *int64 `json:"depend"`
Gain int64 `json:"gain"`
VideoURI string `json:"videoURI"`
}
func GetExercice(id int) (Exercice, error) {
var e Exercice
if err := DBQueryRow("SELECT id_exercice, title, statement, hint, depend, gain, video_uri FROM exercices WHERE id_exercice = ?", id).Scan(&e.Id, &e.Title, &e.Statement, &e.Hint, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
return Exercice{}, err
}
return e, nil
}
func (t Theme) GetExercice(id int) (Exercice, error) {
var e Exercice
if err := DBQueryRow("SELECT id_exercice, title, statement, hint, depend, gain, video_uri FROM exercices WHERE id_theme = ? AND id_exercice = ?", t.Id, id).Scan(&e.Id, &e.Title, &e.Statement, &e.Hint, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
return Exercice{}, err
}
return e, nil
}
func (t Theme) GetExercices() ([]Exercice, error) {
if rows, err := DBQuery("SELECT id_exercice, title, statement, hint, depend, gain, video_uri FROM teams WHERE id_theme = ?", t.Id); err != nil {
return nil, err
} else {
defer rows.Close()
var exos = make([]Exercice, 0)
for rows.Next() {
var e Exercice
if err := rows.Scan(&e.Id, &e.Title, &e.Statement, &e.Hint, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
return nil, err
}
exos = append(exos, e)
}
if err := rows.Err(); err != nil {
return nil, err
}
return exos, nil
}
}
func (t Theme) AddExercice(title string, statement string, hint string, depend *Exercice, gain int, videoURI string) (Exercice, error) {
var dpd interface{}
if depend == nil {
dpd = nil
} else {
dpd = depend.Id
}
if res, err := DBExec("INSERT INTO exercices (id_theme, title, statement, hint, depend, gain, video_uri) VALUES (?, ?, ?, ?, ?, ?, ?)", t.Id, title, statement, hint, dpd, gain, videoURI); err != nil {
return Exercice{}, err
} else if eid, err := res.LastInsertId(); err != nil {
return Exercice{}, err
} else {
if depend == nil {
return Exercice{eid, title, statement, hint, nil, int64(gain), videoURI}, nil
} else {
return Exercice{eid, title, statement, hint, &depend.Id, int64(gain), videoURI}, nil
}
}
}
func (e Exercice) Update() (int64, error) {
if res, err := DBExec("UPDATE exercices SET title = ?, statement = ?, hint = ?, depend = ?, gain = ?, video_uri = ? WHERE id_exercice = ?", e.Title, e.Statement, e.Hint, e.Depend, e.Gain, e.VideoURI, e.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (e Exercice) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM exercices WHERE id_exercice = ?", e.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (e Exercice) NewTry(t Team) error {
if _, err := DBExec("INSERT INTO exercice_tries (id_exercice, id_team, time) VALUES (?, ?, ?)", e.Id, t.Id, time.Now()); err != nil {
return err
} else {
return nil
}
}
func (e Exercice) Solved(t Team) error {
if _, err := DBExec("INSERT INTO exercice_solved (id_exercice, id_team, time) VALUES (?, ?, ?)", e.Id, t.Id, time.Now()); err != nil {
return err
} else {
return nil
}
}

85
admin/file.go
View file

@ -1,85 +0,0 @@
package main
import (
"crypto/sha1"
"io"
"os"
"path"
)
type EFile struct {
Id int64 `json:"id"`
Path string `json:"path"`
IdExercice int64 `json:"idExercice"`
Name string `json:"name"`
Checksum []byte `json:"checksum"`
}
func (e Exercice) GetFiles() ([]EFile, error) {
if rows, err := DBQuery("SELECT id_file, path, name, sha1 FROM exercice_files WHERE id_exercice = ?", e.Id); err != nil {
return nil, err
} else {
defer rows.Close()
var files = make([]EFile, 0)
for rows.Next() {
var f EFile
f.IdExercice = e.Id
if err := rows.Scan(&f.Id, &f.Path, &f.Name, &f.Checksum); err != nil {
return nil, err
}
files = append(files, f)
}
if err := rows.Err(); err != nil {
return nil, err
}
return files, nil
}
}
func (e Exercice) ImportFile(filePath string) (EFile, error) {
if fd, err := os.Open(filePath); err != nil {
return EFile{}, err
} else {
defer fd.Close()
hash := sha1.New()
if _, err := io.Copy(hash, fd); err != nil {
return EFile{}, err
}
var result []byte
return e.AddFile(filePath, path.Base(filePath), hash.Sum(result))
}
}
func (e Exercice) AddFile(path string, name string, checksum []byte) (EFile, error) {
if res, err := DBExec("INSERT INTO exercice_files (id_exercice, path, name, sha1) VALUES (?, ?, ?, ?)", e.Id, path, name, checksum); err != nil {
return EFile{}, err
} else if fid, err := res.LastInsertId(); err != nil {
return EFile{}, err
} else {
return EFile{fid, path, e.Id, name, checksum}, nil
}
}
func (f EFile) Update() (int64, error) {
if res, err := DBExec("UPDATE exercice_files SET id_exercice = ?, path = ?, name = ?, sha1 = ? WHERE id_file = ?", f.IdExercice, f.Path, f.Name, f.Checksum, f.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (f EFile) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM exercice_files WHERE id_file = ?", f.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}

69
admin/key.go
View file

@ -1,69 +0,0 @@
package main
import (
"crypto/sha512"
)
type Key struct {
Id int64 `json:"id"`
IdExercice int64 `json:"idExercice"`
Type string `json:"type"`
Value [64]byte `json:"value"`
}
func (e Exercice) GetKeys() ([]Key, error) {
if rows, err := DBQuery("SELECT id_key, type, value FROM exercice_keys WHERE id_exercice = ?", e.Id); err != nil {
return nil, err
} else {
defer rows.Close()
var keys = make([]Key, 0)
for rows.Next() {
var k Key
k.IdExercice = e.Id
if err := rows.Scan(&k.Id, &k.IdExercice, &k.Type, &k.Value); err != nil {
return nil, err
}
keys = append(keys, k)
}
if err := rows.Err(); err != nil {
return nil, err
}
return keys, nil
}
}
func (e Exercice) AddRawKey(name string, raw_value string) (Key, error) {
return e.AddKey(name, sha512.Sum512([]byte(raw_value)))
}
func (e Exercice) AddKey(name string, value [64]byte) (Key, error) {
if res, err := DBExec("INSERT INTO exercice_keys (id_exercice, type, value) VALUES (?, ?, ?)", e.Id, name, value); err != nil {
return Key{}, err
} else if kid, err := res.LastInsertId(); err != nil {
return Key{}, err
} else {
return Key{kid, e.Id, name, value}, nil
}
}
func (k Key) Update() (int64, error) {
if res, err := DBExec("UPDATE exercice_keys SET id_exercice = ?, type = ?, value = ? WHERE id_key = ?", k.IdExercice, k.Type, k.Value, k.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (k Key) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM exercice_keys WHERE id_key = ?", k.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}

8
admin/main.go
View file

@ -6,6 +6,8 @@ import (
"log"
"net/http"
"os"
"srs.epita.fr/fic-server/libfic"
)
var SubmissionDir string
@ -19,15 +21,15 @@ func main() {
flag.Parse()
log.Println("Opening database...")
if err := DBInit(*dbfile); err != nil {
if err := fic.DBInit(*dbfile); err != nil {
log.Fatal("Cannot open the database: ", err)
os.Exit(1)
}
defer DBClose()
defer fic.DBClose()
log.Println("Creating database...")
if err := DBCreate(); err != nil {
if err := fic.DBCreate(); err != nil {
log.Fatal("Cannot create database: ", err)
os.Exit(1)

73
admin/member.go
View file

@ -1,73 +0,0 @@
package main
import ()
type Member struct {
Id int64 `json:"id"`
Firstname string `json:"firstname"`
Lastname string `json:"lastname"`
Nickname string `json:"nickname"`
Company string `json:"company"`
}
func (t Team) GetMembers() ([]Member, error) {
if rows, err := DBQuery("SELECT id_member, firstname, lastname, nickname, company FROM team_members WHERE id_team = ?", t.Id); err != nil {
return nil, err
} else {
defer rows.Close()
var members = make([]Member, 0)
for rows.Next() {
var m Member
if err := rows.Scan(&m.Id, &m.Firstname, &m.Lastname, &m.Nickname, &m.Company); err != nil {
return nil, err
}
members = append(members, m)
}
if err := rows.Err(); err != nil {
return nil, err
}
return members, nil
}
}
func (t Team) AddMember(firstname string, lastname string, nickname string, company string) (Member, error) {
if res, err := DBExec("INSERT INTO team_members (id_team, firstname, lastname, nickname, company) VALUES (?, ?, ?, ?, ?)", t.Id, firstname, lastname, nickname, company); err != nil {
return Member{}, err
} else if mid, err := res.LastInsertId(); err != nil {
return Member{}, err
} else {
return Member{mid, firstname, lastname, nickname, company}, nil
}
}
func (t Team) GainMember(m Member) error {
if res, err := DBExec("UPDATE team_members SET id_team = ? WHERE id_member = ?", t.Id, m.Id); err != nil {
return err
} else if _, err := res.RowsAffected(); err != nil {
return err
} else {
return nil
}
}
func (m Member) Update() (int64, error) {
if res, err := DBExec("UPDATE team_members SET firstname = ?, lastname = ?, nickname = ?, company = ? WHERE id_member = ?", m.Firstname, m.Lastname, m.Nickname, m.Company, m.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (m Member) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM team_members WHERE id_member = ?", m.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}

69
admin/team.go
View file

@ -1,69 +0,0 @@
package main
import ()
type Team struct {
Id int64 `json:"id"`
Name string `json:"name"`
}
func GetTeams() ([]Team, error) {
if rows, err := DBQuery("SELECT id_team, name FROM teams"); err != nil {
return nil, err
} else {
defer rows.Close()
var teams = make([]Team, 0)
for rows.Next() {
var t Team
if err := rows.Scan(&t.Id, &t.Name); err != nil {
return nil, err
}
teams = append(teams, t)
}
if err := rows.Err(); err != nil {
return nil, err
}
return teams, nil
}
}
func GetTeam(id int) (Team, error) {
var t Team
if err := DBQueryRow("SELECT id_team, name FROM teams WHERE id_team = ?", id).Scan(&t.Id, &t.Name); err != nil {
return t, err
}
return t, nil
}
func CreateTeam(name string) (Team, error) {
if res, err := DBExec("INSERT INTO teams (name) VALUES (?)", name); err != nil {
return Team{}, err
} else if tid, err := res.LastInsertId(); err != nil {
return Team{}, err
} else {
return Team{tid, name}, nil
}
}
func (t Team) Update() (int64, error) {
if res, err := DBExec("UPDATE teams SET name = ? WHERE id_team = ?", t.Name, t.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (t Team) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM team_members WHERE id_team = ?; DELETE FROM teams WHERE id_team = ?", t.Id, t.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}

69
admin/theme.go
View file

@ -1,69 +0,0 @@
package main
import ()
type Theme struct {
Id int64 `json:"id"`
Name string `json:"name"`
}
func GetThemes() ([]Theme, error) {
if rows, err := DBQuery("SELECT id_theme, name FROM themes"); err != nil {
return nil, err
} else {
defer rows.Close()
var themes = make([]Theme, 0)
for rows.Next() {
var t Theme
if err := rows.Scan(&t.Id, &t.Name); err != nil {
return nil, err
}
themes = append(themes, t)
}
if err := rows.Err(); err != nil {
return nil, err
}
return themes, nil
}
}
func GetTheme(id int) (Theme, error) {
var t Theme
if err := DBQueryRow("SELECT id_theme, name FROM themes WHERE id_theme=?", id).Scan(&t.Id, &t.Name); err != nil {
return t, err
}
return t, nil
}
func CreateTheme(name string) (Theme, error) {
if res, err := DBExec("INSERT INTO themes (name) VALUES (?)", name); err != nil {
return Theme{}, err
} else if tid, err := res.LastInsertId(); err != nil {
return Theme{}, err
} else {
return Theme{tid, name}, nil
}
}
func (t Theme) Update() (int64, error) {
if res, err := DBExec("UPDATE themes SET name = ? WHERE id_team = ?", t.Name, t.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}
func (t Theme) Delete() (int64, error) {
if res, err := DBExec("DELETE FROM themes WHERE id_theme = ?", t.Id); err != nil {
return 0, err
} else if nb, err := res.RowsAffected(); err != nil {
return 0, err
} else {
return nb, err
}
}