From e4ddd0b44564b88e4d524fed5fb1a448a8c6ebae Mon Sep 17 00:00:00 2001 From: w-mj Date: Mon, 3 Apr 2023 22:39:43 +0800 Subject: [PATCH] project controller --- main.go | 1 + src/controller/data_controller.go | 11 +++-- src/controller/project_controller.go | 54 ++++++++++++++++++++ src/model/base_model.go | 2 +- src/model/project_model.go | 74 ++++++++++++++++++++++++++-- src/utils/algorithm_utils.go | 31 ++++++++++++ src/utils/{utils.go => gin_utils.go} | 0 test/test_generic.go | 7 +-- test/testdb.go | 19 +++---- 9 files changed, 174 insertions(+), 25 deletions(-) create mode 100644 src/controller/project_controller.go create mode 100644 src/utils/algorithm_utils.go rename src/utils/{utils.go => gin_utils.go} (100%) diff --git a/main.go b/main.go index b775070..2cf0425 100644 --- a/main.go +++ b/main.go @@ -81,6 +81,7 @@ func main() { r.GET("/images", controller.GetImages) controller.AddDataController(r) + controller.AddProjectController(r) err := r.Run(":8000") if err != nil { diff --git a/src/controller/data_controller.go b/src/controller/data_controller.go index 6c784d5..26046d6 100644 --- a/src/controller/data_controller.go +++ b/src/controller/data_controller.go @@ -2,15 +2,17 @@ package controller import ( "errors" + "fmt" "github.com/gin-gonic/gin" - log "github.com/sirupsen/logrus" "k8s-manager/src/model" "k8s-manager/src/utils" + "math/rand" ) func AddData(username string, data *model.DataModel) (utils.OKType, error) { data.UserName = username - data.Save() + data.AccessInfo = fmt.Sprintf("/data/%s-%s-%d", data.UserName, data.Name, rand.Int()) + data.Create() return utils.OK, nil } @@ -26,13 +28,13 @@ func DeleteData(username string, ID uint) (utils.OKType, error) { } func UpdateData(username string, data *model.DataModel) (utils.OKType, error) { - oldData := model.DataModel{} + oldData := &model.DataModel{} oldData.SetID(data.ID) oldData.Fill() if username != oldData.GetUserName() { return nil, errors.New("wrong username") } - data.Save() + data.Save(oldData) return utils.OK, nil } @@ -40,7 +42,6 @@ func GetData(UserName string, IsPublish bool) (gin.H, error) { data := model.DataModel{} data.UserName = UserName data.IsPublished = IsPublish - log.Info(UserName, IsPublish) if UserName == "" && !IsPublish { return gin.H{"data": []string{}}, nil } diff --git a/src/controller/project_controller.go b/src/controller/project_controller.go new file mode 100644 index 0000000..8b73565 --- /dev/null +++ b/src/controller/project_controller.go @@ -0,0 +1,54 @@ +package controller + +import ( + "errors" + "github.com/gin-gonic/gin" + "k8s-manager/src/model" + "k8s-manager/src/utils" +) + +func AddProject(username string, proj *model.ProjectModel) (utils.OKType, error) { + proj.UserName = username + proj.Create() + return utils.OK, nil +} + +func DeleteProject(username string, ID uint) (utils.OKType, error) { + old := model.ProjectModel{} + old.ID = ID + old.Fill() + if username != old.UserName { + return nil, errors.New("wrong username") + } + old.Delete() + return utils.OK, nil +} + +func UpdateProject(username string, proj *model.ProjectModel) (utils.OKType, error) { + old := &model.ProjectModel{} + old.ID = proj.ID + old.Fill() + if username != old.GetUserName() { + return nil, errors.New("wrong username") + } + proj.Save(old) + return utils.OK, nil +} + +func GetProjects(UserName string, IsPublished bool) (gin.H, error) { + proj := &model.ProjectModel{} + proj.UserName = UserName + proj.IsPublished = IsPublished + if UserName == "" && !IsPublished { + return gin.H{"data": []string{}}, nil + } + ans := proj.Gets() + return gin.H{"data": ans}, nil +} + +func AddProjectController(r *gin.Engine) { + utils.RouteWrapper(r, "POST", "/project", AddProject, []string{"username", "1"}) + utils.RouteWrapper(r, "DELETE", "/project", DeleteProject, []string{"username", "ID"}) + utils.RouteWrapper(r, "PUT", "/project", UpdateProject, []string{"username", "1"}) + utils.RouteWrapper(r, "GET", "/projects", GetProjects, []string{"UserName", "IsPublished"}) +} diff --git a/src/model/base_model.go b/src/model/base_model.go index 7847fad..6767f83 100644 --- a/src/model/base_model.go +++ b/src/model/base_model.go @@ -41,7 +41,7 @@ func (b *BaseModel[T]) Create() { db.Create(p) } -func (b *BaseModel[T]) Save() { +func (b *BaseModel[T]) Save(old *T) { db := k8s_manager.DB() p := (*T)(unsafe.Pointer(b)) db.Save(p) diff --git a/src/model/project_model.go b/src/model/project_model.go index 5912ae8..aaf7f59 100644 --- a/src/model/project_model.go +++ b/src/model/project_model.go @@ -1,23 +1,24 @@ package model import ( - "gorm.io/gorm" + k8s_manager "k8s-manager/src" + "k8s-manager/src/utils" "time" ) type ProjectModel struct { - gorm.Model + BaseModel[ProjectModel] ProjectName string UserName string GroupName string Type string Comment string Doc string - IsPublic bool + IsPublished bool ImageID int Image ImageModel - TrainData []*DataModel `gorm:"many2many:projects_data"` + TrainData []*ProjectTrainDataModel `gorm:"foreignKey:ProjectID"` UserPath string CodePath string @@ -30,6 +31,71 @@ func (*ProjectModel) TableName() string { return "projects" } +type ProjectTrainDataModel struct { + BaseModel[ProjectTrainDataModel] + ProjectID uint + DataID uint + Data *DataModel + MountPath string +} + +func (*ProjectTrainDataModel) TableName() string { + return "project_train_data" +} + +func (p *ProjectModel) Fill() { + db := k8s_manager.DB() + db.Preload("ProjectTrainDataModel").First(p, p.ID) +} + +func (p *ProjectModel) Create() { + db := k8s_manager.DB() + db.Create(p) + for _, d := range p.TrainData { + d.ProjectID = p.ID + db.Create(d) + } +} + +func (p *ProjectModel) Delete() { + db := k8s_manager.DB() + for _, d := range p.TrainData { + db.Delete(d) + } + db.Delete(p) +} + +func (p *ProjectModel) Save(oldProject *ProjectModel) { + db := k8s_manager.DB() + //oldProject := &ProjectModel{} + //oldProject.ID = p.ID + //oldProject.Fill() + + toAdd := utils.Difference(p.TrainData, oldProject.TrainData, func(a, b *ProjectTrainDataModel) bool { return a.ID == b.ID }) + for t := range toAdd { + db.Create(t) + } + + toDel := utils.Difference(oldProject.TrainData, p.TrainData, func(a, b *ProjectTrainDataModel) bool { return a.ID == b.ID }) + for t := range toDel { + db.Delete(t) + } + + toSave := utils.Intersect(oldProject.TrainData, p.TrainData, func(a, b *ProjectTrainDataModel) bool { return a.ID == b.ID }) + for t := range toSave { + db.Save(t) + } + + db.Save(p) +} + +func (p *ProjectModel) Gets() []ProjectModel { + db := k8s_manager.DB() + var ans []ProjectModel + db.Model(&ProjectModel{}).Preload("ProjectTrainDataModel").Where(p).Find(&ans) + return ans +} + type RunningProject struct { Project *ProjectModel StartTime *time.Time diff --git a/src/utils/algorithm_utils.go b/src/utils/algorithm_utils.go new file mode 100644 index 0000000..8f7ca64 --- /dev/null +++ b/src/utils/algorithm_utils.go @@ -0,0 +1,31 @@ +package utils + +func Difference[T any](a, b []T, com func(T, T) bool) []T { + var ans []T + for _, x := range a { + unique := true + for _, y := range b { + if com(x, y) { + unique = false + break + } + } + if unique { + ans = append(ans, x) + } + } + return ans +} + +func Intersect[T any](a, b []T, com func(T, T) bool) []T { + var ans []T + for _, x := range a { + for _, y := range b { + if com(x, y) { + ans = append(ans, x) + break + } + } + } + return ans +} diff --git a/src/utils/utils.go b/src/utils/gin_utils.go similarity index 100% rename from src/utils/utils.go rename to src/utils/gin_utils.go diff --git a/test/test_generic.go b/test/test_generic.go index 53fa5f3..03a4f94 100644 --- a/test/test_generic.go +++ b/test/test_generic.go @@ -1,10 +1,5 @@ package main -import ( - "k8s-manager/src/controller" - "k8s-manager/src/model" -) - func main() { - controller.BaseController[model.DataModel, *model.DataModel]{}.Add(nil) + //controller.BaseController[model.DataModel, *model.DataModel]{}.Add(nil) } diff --git a/test/testdb.go b/test/testdb.go index c200a14..089451e 100644 --- a/test/testdb.go +++ b/test/testdb.go @@ -1,7 +1,6 @@ package main import ( - "encoding/json" "fmt" k8s_manager "k8s-manager/src" "k8s-manager/src/model" @@ -10,9 +9,10 @@ import ( func CreateTables() { db := k8s_manager.DB() err := db.Migrator().AutoMigrate( - &model.ProjectModel{}, - &model.ImageModel{}, - &model.DataModel{}, + //&model.ProjectModel{}, + //&model.ImageModel{}, + //&model.DataModel{}, + &model.ProjectTrainDataModel{}, ) if err != nil { fmt.Println(err) @@ -22,9 +22,10 @@ func CreateTables() { func main() { k8s_manager.InitConfig() - db := k8s_manager.DB() - p := model.ProjectModel{} - db.Preload("TrainData").Where("user_name = ?", "wmj").Find(&p) - j, _ := json.Marshal(&p) - fmt.Println(string(j)) + CreateTables() + // db := k8s_manager.DB() + // p := model.ProjectModel{} + // db.Preload("TrainData").Where("user_name = ?", "wmj").Find(&p) + // j, _ := json.Marshal(&p) + // fmt.Println(string(j)) }