fic
/
server
2
0
Fork 0
Code Issues Pull Requests 10 Releases Wiki Activity

Add DB objects

This commit is contained in:
nemunaire 2016-01-07 18:43:02 +01:00
parent abd5e2025e
commit 6ec37b83ce
7 changed files with 450 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
admin/api.go
View File

@ -13,8 +13,8 @@ type DispatchFunction func([]string, []byte) (interface{}, error)
var apiRouting = map[string]*(map[string]DispatchFunction){
"version": &ApiVersionRouting,
//"images": &ApiImagesRouting,
//"users": &ApiUsersRouting,
//"themes": &ApiThemesRouting,
//"teams": &ApiTeamsRouting,
}
func ApiRouting(w http.ResponseWriter, r *http.Request) {

83
admin/exercice.go Normal file
View File

@ -0,0 +1,83 @@
package main
import (
"time"
)
type Exercice struct {
id int64
Title string
Statement string
Hint string
depend int64
Gain int64
VideoURI string
}
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) {
if res, err := DBExec("INSERT INTO exercices (id_theme, title, statement, hint, depend, gain, video_uri) VALUES (?, ?, ?, ?, ?, ?, ?)", t.id, title, statement, hint, depend.id, gain, videoURI); err != nil {
return Exercice{}, err
} else if eid, err := res.LastInsertId(); err != nil {
return Exercice{}, err
} 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 Normal file
View File

@ -0,0 +1,85 @@
package main
import (
"crypto/sha1"
"io"
"os"
"path"
)
type EFile struct {
id int64
Path string
id_exercice int64
Name string
Checksum []byte
}
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.id_exercice = 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.id_exercice, 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 Normal file
View File

@ -0,0 +1,69 @@
package main
import (
"crypto/sha512"
)
type Key struct {
id int64
id_exercice int64
Type string
Value [64]byte
}
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.id_exercice = e.id
if err := rows.Scan(&k.id, &k.id_exercice, &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.id_exercice, 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
}
}

73
admin/member.go Normal file
View File

@ -0,0 +1,73 @@
package main
import ()
type Member struct {
id int64
Firstname string
Lastname string
Nickname string
Company string
}
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 Normal file
View File

@ -0,0 +1,69 @@
package main
import ()
type Team struct {
id int64
Name string
}
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 teams WHERE id_teams = ?", 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 Normal file
View File

@ -0,0 +1,69 @@
package main
import ()
type Theme struct {
id int64
Name string
}
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
}
}