gameui/ai
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gorm

Browse Source
This commit is contained in:
桜華
2023-05-14 07:00:24 +08:00
parent 2423213e9a
commit ee3b60eccc
18 changed files with 273 additions and 1221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
models/Image.go
View File

@@ -1,12 +1,11 @@
package models
import (
"log"
"main/configs"
)
type Image struct {
ID int `json:"id"`
ID int `json:"id" gorm:"primary_key"`
Name string `json:"name"`
Width int `json:"width"`
Height int `json:"height"`
@@ -22,125 +21,6 @@ type Image struct {
UserID int `json:"user_id"`
}
func (image *Image) Create() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO images(name, created_at, updated_at) values(?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
result, err := stmt.Exec(image.Name, image.CreatedAt, image.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
image.ID = int(id)
return nil
}
func (image *Image) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM images WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(image.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (image *Image) Update() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE images SET name = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(image.Name, image.UpdatedAt, image.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (image *Image) Get() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT id, name, created_at, updated_at FROM images WHERE id = ?", image.ID).Scan(&image.ID, &image.Name, &image.CreatedAt, &image.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func QueryImages(page int, pagesize int) (images []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
rows, err := db.Query("SELECT id, name, created_at, updated_at FROM images LIMIT ?, ?", (page-1)*pagesize, pagesize)
if err != nil {
log.Println(err)
return
}
defer rows.Close()
for rows.Next() {
image := Image{}
err := rows.Scan(&image.ID, &image.Name, &image.CreatedAt, &image.UpdatedAt)
if err != nil {
log.Println(err)
return
}
images = append(images, image)
}
return
}
func CountImages() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT COUNT(*) FROM images").Scan(&count)
if err != nil {
log.Println(err)
return
}
return
func init() {
configs.ORMDB().AutoMigrate(&Image{})
}

2
models/ListView.go
View File

@@ -9,7 +9,7 @@ import (
type ListView struct {
Page int `json:"page"`
PageSize int `json:"page_size"`
Total int `json:"total"`
Total int64 `json:"total"`
Next bool `json:"next"`
List []interface{} `json:"list"`
}

45
models/Model.go
View File

@@ -1,7 +1,6 @@
package models
import (
"log"
"main/configs"
)
@@ -25,25 +24,25 @@ func init() {
configs.ORMDB().AutoMigrate(&Model{})
}
func (model *Model) SendToTrain() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE models SET status = ?, progress = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(model.Status, model.Progress, model.UpdatedAt, model.ID)
if err != nil {
log.Println(err)
return err
}
// TODO: 創建一個新線程管理訓練任務
// 將任務放入隊列中, 將自動回調更新任務狀態
return nil
}
//func (model *Model) SendToTrain() error {
// db, err := configs.GetDB()
// if err != nil {
// log.Println(err)
// return err
// }
// defer db.Close()
// stmt, err := db.Prepare("UPDATE models SET status = ?, progress = ?, updated_at = ? WHERE id = ?")
// if err != nil {
// log.Println(err)
// return err
// }
// defer stmt.Close()
// _, err = stmt.Exec(model.Status, model.Progress, model.UpdatedAt, model.ID)
// if err != nil {
// log.Println(err)
// return err
// }
// // TODO: 創建一個新線程管理訓練任務
// // 將任務放入隊列中, 將自動回調更新任務狀態
// return nil
//}

126
models/Server.go
View File

@@ -1,12 +1,11 @@
package models
import (
"log"
"main/configs"
)
type Server struct {
ID int `json:"id"`
ID int `json:"id" gorm:"primary_key"`
Name string `json:"name"`
Type string `json:"type"` // (訓練|推理)
IP string `json:"ip"`
@@ -17,125 +16,6 @@ type Server struct {
UpdatedAt string `json:"updated_at"`
}
func (server *Server) Create() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO servers(name, ip, port, username, password, created_at, updated_at) values(?, ?, ?, ?, ?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
result, err := stmt.Exec(server.Name, server.IP, server.Port, server.Username, server.Password, server.CreatedAt, server.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
server.ID = int(id)
return nil
}
func (server *Server) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM servers WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(server.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (server *Server) Update() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE servers SET name = ?, ip = ?, port = ?, username = ?, password = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(server.Name, server.IP, server.Port, server.Username, server.Password, server.UpdatedAt, server.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (server *Server) Get() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT id, name, ip, port, username, password, created_at, updated_at FROM servers WHERE id = ?", server.ID).Scan(&server.ID, &server.Name, &server.IP, &server.Port, &server.Username, &server.Password, &server.CreatedAt, &server.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func QueryServers(page int, pagesize int) (servers []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
rows, err := db.Query("SELECT id, name, ip, port, username, password, created_at, updated_at FROM servers ORDER BY id DESC LIMIT ?, ?", page*pagesize, pagesize)
if err != nil {
log.Println(err)
return
}
defer rows.Close()
for rows.Next() {
server := Server{}
err := rows.Scan(&server.ID, &server.Name, &server.IP, &server.Port, &server.Username, &server.Password, &server.CreatedAt, &server.UpdatedAt)
if err != nil {
log.Println(err)
continue
}
servers = append(servers, server)
}
return
}
func CountServers() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT COUNT(*) FROM servers").Scan(&count)
if err != nil {
log.Println(err)
return
}
return
func init() {
configs.ORMDB().AutoMigrate(&Server{})
}

187
models/Tag.go
View File

@@ -1,197 +1,16 @@
package models
import (
"log"
"main/configs"
)
type Tag struct {
ID int `json:"id"`
ID int `json:"id" gorm:"primary_key"`
Name string `json:"name"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
}
func (tag *Tag) Create(name string) error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO tags(name, created_at, updated_at) values(?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
result, err := stmt.Exec(name, tag.CreatedAt, tag.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
tag.ID = int(id)
return nil
}
func (tag *Tag) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM tags WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(tag.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (tag *Tag) Update(name string) error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE tags SET name = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(name, tag.UpdatedAt, tag.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (tag *Tag) Get() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT * FROM tags WHERE id = ?", tag.ID).Scan(&tag.ID, &tag.Name, &tag.CreatedAt, &tag.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func GetTags() ([]Tag, error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil, err
}
defer db.Close()
rows, err := db.Query("SELECT * FROM tags")
if err != nil {
log.Println(err)
return nil, err
}
defer rows.Close()
var tags []Tag
for rows.Next() {
var tag Tag
err := rows.Scan(&tag.ID, &tag.Name, &tag.CreatedAt, &tag.UpdatedAt)
if err != nil {
log.Println(err)
return nil, err
}
tags = append(tags, tag)
}
return tags, nil
}
func GetTag(id int) (*Tag, error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil, err
}
defer db.Close()
row := db.QueryRow("SELECT * FROM tags WHERE id = ?", id)
var tag Tag
err = row.Scan(&tag.ID, &tag.Name, &tag.CreatedAt, &tag.UpdatedAt)
if err != nil {
log.Println(err)
return nil, err
}
return &tag, nil
}
func GetTagByName(name string) (*Tag, error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil, err
}
defer db.Close()
row := db.QueryRow("SELECT * FROM tags WHERE name = ?", name)
var tag Tag
err = row.Scan(&tag.ID, &tag.Name, &tag.CreatedAt, &tag.UpdatedAt)
if err != nil {
log.Println(err)
return nil, err
}
return &tag, nil
}
func QueryTags(page, pagesize int) (list []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil
}
defer db.Close()
rows, err := db.Query("SELECT * FROM tags LIMIT ?, ?", page, pagesize)
if err != nil {
log.Println(err)
return nil
}
defer rows.Close()
for rows.Next() {
var tag Tag
err := rows.Scan(&tag.ID, &tag.Name, &tag.CreatedAt, &tag.UpdatedAt)
if err != nil {
log.Println(err)
return nil
}
list = append(list, tag)
}
return list
}
func CountTags() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return 0
}
defer db.Close()
row := db.QueryRow("SELECT COUNT(*) FROM tags")
err = row.Scan(&count)
if err != nil {
log.Println(err)
return 0
}
return count
func init() {
configs.ORMDB().AutoMigrate(&Tag{})
}

230
models/Task.go
View File

@@ -1,13 +1,5 @@
package models
import (
"log"
"main/configs"
"net/http"
"strconv"
"time"
)
type Task struct {
ID int `json:"id"`
Name string `json:"name"`
@@ -19,183 +11,45 @@ type Task struct {
UserID int `json:"user_id"`
}
// 推理任務
func startInferenceTask(task *Task) {
// 獲取一臺可用的 GPU 資源
// ...
// 執行推理任務
// ...
// 更新任務狀態
task.Status = "running"
task.Progress = 0
task.Update()
// 監聽任務狀態
for {
// 延遲 1 秒
time.Sleep(1 * time.Second)
// 查詢任務狀態
resp, err := http.Get("http://localhost:5000/api/v1/tasks/" + strconv.Itoa(task.ID))
if err != nil {
log.Println(err)
continue
}
defer resp.Body.Close()
// 解析任務狀態
// ...
// 更新任務狀態
task.Progress = 100
task.Status = "success"
task.Update()
// 任務結束判定
if task.Progress == 100 {
break
}
}
}
func (task *Task) Create() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO tasks(name, type, created_at, updated_at) values(?, ?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
result, err := stmt.Exec(task.Name, task.Type, task.CreatedAt, task.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
task.ID = int(id)
return nil
}
func (task *Task) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM tasks WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(task.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (task *Task) Update() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE tasks SET name = ?, type = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(task.Name, task.Type, task.UpdatedAt, task.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (task *Task) Get() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT name, type, created_at, updated_at FROM tasks WHERE id = ?", task.ID).Scan(&task.Name, &task.Type, &task.CreatedAt, &task.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func QueryTask(id int) (task Task) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT id, name, type, created_at, updated_at FROM tasks WHERE id = ?", id).Scan(&task.ID, &task.Name, &task.Type, &task.CreatedAt, &task.UpdatedAt)
if err != nil {
log.Println(err)
return
}
return
}
func QueryTasks(page int, pagesize int) (tasks []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
rows, err := db.Query("SELECT id, name, type, created_at, updated_at FROM tasks LIMIT ?, ?", (page-1)*pagesize, pagesize)
if err != nil {
log.Println(err)
return
}
defer rows.Close()
for rows.Next() {
task := Task{}
err := rows.Scan(&task.ID, &task.Name, &task.Type, &task.CreatedAt, &task.UpdatedAt)
if err != nil {
log.Println(err)
return
}
tasks = append(tasks, task)
}
return
}
func CountTasks() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT COUNT(*) FROM tasks").Scan(&count)
if err != nil {
log.Println(err)
return
}
return
}
//// 推理任務
//func startInferenceTask(task *Task) {
//
// // 獲取一臺可用的 GPU 資源
// // ...
//
// // 執行推理任務
// // ...
//
// // 更新任務狀態
// task.Status = "running"
// task.Progress = 0
// task.Update()
//
// // 監聽任務狀態
// for {
// // 延遲 1 秒
// time.Sleep(1 * time.Second)
//
// // 查詢任務狀態
// resp, err := http.Get("http://localhost:5000/api/v1/tasks/" + strconv.Itoa(task.ID))
// if err != nil {
// log.Println(err)
// continue
// }
// defer resp.Body.Close()
//
// // 解析任務狀態
// // ...
//
// // 更新任務狀態
// task.Progress = 100
// task.Status = "success"
// task.Update()
//
// // 任務結束判定
// if task.Progress == 100 {
// break
// }
// }
//
//}

239
models/User.go
View File

@@ -3,14 +3,11 @@ package models
import (
"crypto/md5"
"fmt"
"log"
"main/configs"
"main/utils"
"time"
)
type User struct {
ID int `json:"id"`
ID int `json:"id" gorm:"primary_key"`
Name string `json:"name"`
Email string `json:"email"`
CreatedAt string `json:"created_at"`
@@ -19,241 +16,11 @@ type User struct {
Slat string `json:"-"`
}
func (user *User) Create(name, email, password string) error {
if name == "" || email == "" || password == "" {
return fmt.Errorf("name, email and password can not be empty")
}
user.Slat = utils.RandomString(16)
user.Password = fmt.Sprintf("%x", md5.Sum([]byte(password+user.Slat)))
user.Name = name
user.Email = email
user.CreatedAt = time.Now().Format("2006-01-02 15:04:05")
user.UpdatedAt = user.CreatedAt
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO users(name, email, password, slat, created_at, updated_at) values(?, ?, ?, ?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
result, err := stmt.Exec(user.Name, user.Email, user.Password, user.Slat, user.CreatedAt, user.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
id, err := result.LastInsertId()
if err != nil {
return err
}
user.ID = int(id)
return nil
}
func (user *User) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM users WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(user.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (user *User) Update() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE users SET name = ?, email = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(user.Name, user.Email, user.UpdatedAt, user.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (user *User) RoadByID(id int) (err error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT id, name, email, password, slat, created_at, updated_at FROM users WHERE id = ?", user.ID).Scan(&user.ID, &user.Name, &user.Email, &user.Password, &user.Slat, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (user *User) Get() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
err = db.QueryRow("SELECT id, name, email, password, slat, created_at, updated_at FROM users WHERE id = ?", user.ID).Scan(&user.ID, &user.Name, &user.Email, &user.Password, &user.Slat, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (user *User) GetAll() ([]User, error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil, err
}
defer db.Close()
rows, err := db.Query("SELECT id, name, email, created_at, updated_at FROM users")
if err != nil {
log.Println(err)
return nil, err
}
defer rows.Close()
var users []User
for rows.Next() {
var user User
err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return nil, err
}
users = append(users, user)
}
return users, nil
func init() {
configs.ORMDB().AutoMigrate(&User{})
}
// 驗證用戶密碼
func (user *User) CheckPassword(password string) bool {
return user.Password == fmt.Sprintf("%x", md5.Sum([]byte(password+user.Slat)))
}
// 使用Email和Password驗證登錄
func (user *User) CheckLogin(email, password string) bool {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return false
}
defer db.Close()
err = db.QueryRow("SELECT id, name, email, password, slat, created_at, updated_at FROM users WHERE email = ?", email).Scan(&user.ID, &user.Name, &user.Email, &user.Password, &user.Slat, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return false
}
if user.ID == 0 {
fmt.Println("user not found")
return false
}
if user.Password == "" {
fmt.Println("password is empty")
return false
}
if user.Password == fmt.Sprintf("%x", md5.Sum([]byte(password+user.Slat))) {
return true
}
return false
}
// 獲取用戶實體
func GetUserByEmail(email string) (user User, err error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT id, name, email, password, slat, created_at, updated_at FROM users WHERE email = ?", email).Scan(&user.ID, &user.Name, &user.Email, &user.Password, &user.Slat, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return
}
return
}
func QueryUserByEmail(email string) (user User, err error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT id, name, email, created_at, updated_at FROM users WHERE email = ?", email).Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return
}
return
}
func QueryUsers(page, pagesize int) (list []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
rows, err := db.Query("SELECT id, name, email, created_at, updated_at FROM users LIMIT ?, ?", (page-1)*pagesize, pagesize)
if err != nil {
log.Println(err)
return
}
defer rows.Close()
for rows.Next() {
var user User
err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt)
if err != nil {
log.Println(err)
return
}
list = append(list, user)
}
return
}
func CountUsers() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
err = db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
if err != nil {
log.Println(err)
return
}
return
}

5
models/account.go
View File

@@ -1,6 +1,7 @@
package models
import (
"main/configs"
"net/http"
)
@@ -24,7 +25,7 @@ func AccountRead(w http.ResponseWriter, r *http.Request, cb func(account *Accoun
// 獲取當前session
session := Session{ID: cookie.Value}
if err := session.Get(); err != nil {
if err := configs.ORMDB().Take(&session).Error; err != nil {
w.WriteHeader(http.StatusUnauthorized)
w.Write([]byte("401 - 會話已過期"))
return
@@ -32,7 +33,7 @@ func AccountRead(w http.ResponseWriter, r *http.Request, cb func(account *Accoun
// 獲取當前用戶
user := User{ID: session.UserID}
if err := user.Get(); err != nil {
if err := configs.ORMDB().Model(&user).Select("id, name, email, created_at, updated_at").Find(&user).Error; err != nil {
w.WriteHeader(http.StatusUnauthorized)
w.Write([]byte("401 - 用戶不存在"))
return

141
models/session.go
View File

@@ -1,151 +1,16 @@
package models
import (
"log"
"main/configs"
"time"
)
type Session struct {
ID string `json:"id"`
ID string `json:"id" gorm:"primary_key"`
UserID int `json:"user_id"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
}
func (session *Session) Get() (err error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
row := db.QueryRow("SELECT * FROM sessions WHERE id = ?", session.ID)
err = row.Scan(&session.ID, &session.UserID, &session.CreatedAt, &session.UpdatedAt)
if err != nil {
log.Println(err)
return
}
return
}
func (session *Session) Create() error {
session.CreatedAt = time.Now().Format("2006-01-02 15:04:05")
session.UpdatedAt = session.CreatedAt
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("INSERT INTO sessions (id, user_id, created_at, updated_at) VALUES (?, ?, ?, ?)")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(session.ID, session.UserID, session.CreatedAt, session.UpdatedAt)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (session *Session) Delete() error {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("DELETE FROM sessions WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(session.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func (session *Session) Update() error {
session.UpdatedAt = time.Now().Format("2006-01-02 15:04:05")
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return err
}
defer db.Close()
stmt, err := db.Prepare("UPDATE sessions SET user_id = ?, updated_at = ? WHERE id = ?")
if err != nil {
log.Println(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(session.UpdatedAt, session.UserID, session.ID)
if err != nil {
log.Println(err)
return err
}
return nil
}
func GetSession(id int) (*Session, error) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return nil, err
}
defer db.Close()
row := db.QueryRow("SELECT id, user_id, created_at, updated_at FROM sessions WHERE id = ?", id)
var session Session
if err := row.Scan(&session.ID, &session.UserID, &session.CreatedAt, &session.UpdatedAt); err != nil {
log.Println(err)
return nil, err
}
return &session, nil
}
func QuerySessions(page, pagesize int) (list []interface{}) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
rows, err := db.Query("SELECT id, user_id, created_at, updated_at FROM sessions LIMIT ?, ?", (page-1)*pagesize, pagesize)
if err != nil {
log.Println(err)
return
}
defer rows.Close()
for rows.Next() {
var session Session
if err := rows.Scan(&session.ID, &session.UserID, &session.CreatedAt, &session.UpdatedAt); err != nil {
log.Println(err)
return
}
list = append(list, session)
}
return
}
func CountSessions() (count int) {
db, err := configs.GetDB()
if err != nil {
log.Println(err)
return
}
defer db.Close()
row := db.QueryRow("SELECT COUNT(*) FROM sessions")
if err := row.Scan(&count); err != nil {
log.Println(err)
return
}
return
func init() {
configs.ORMDB().AutoMigrate(&Session{})
}