git-sync/crawlab
1
0
Fork 0
mirror of https://github.com/crawlab-team/crawlab.git synced 2026-01-22 17:31:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: fixed dependency errors

Browse Source
This commit is contained in:
Marvin Zhang
2024-11-01 14:08:30 +08:00
parent 8ffba2944d
commit ca5bbe6c8f
56 changed files with 3753 additions and 3791 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/controllers/base_v2.go
View File

@@ -18,7 +18,7 @@ type Action struct {
}
type BaseControllerV2[T any] struct {
modelSvc *service.ModelServiceV2[T]
modelSvc *service.ModelService[T]
actions []Action
}
@@ -229,7 +229,7 @@ func (ctr *BaseControllerV2[T]) getList(c *gin.Context) {
func NewControllerV2[T any](actions ...Action) *BaseControllerV2[T] {
ctr := &BaseControllerV2[T]{
modelSvc: service.NewModelServiceV2[T](),
modelSvc: service.NewModelService[T](),
actions: actions,
}
return ctr

10
core/controllers/base_v2_test.go
View File

@@ -31,7 +31,7 @@ var TestToken string
// SetupTestDB sets up the test database
func SetupTestDB() {
viper.Set("mongo.db", "testdb")
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
u := models.UserV2{
Username: "admin",
}
@@ -68,7 +68,7 @@ func TestBaseControllerV2_GetById(t *testing.T) {
defer CleanupTestDB()
// Insert a test document
id, err := service.NewModelServiceV2[TestModel]().InsertOne(TestModel{Name: "test"})
id, err := service.NewModelService[TestModel]().InsertOne(TestModel{Name: "test"})
assert.NoError(t, err)
// Initialize the controller
@@ -127,7 +127,7 @@ func TestBaseControllerV2_Post(t *testing.T) {
assert.Equal(t, "test", response.Data.Name)
// Check if the document was inserted into the database
result, err := service.NewModelServiceV2[TestModel]().GetById(response.Data.Id)
result, err := service.NewModelService[TestModel]().GetById(response.Data.Id)
assert.NoError(t, err)
assert.Equal(t, "test", result.Name)
}
@@ -137,7 +137,7 @@ func TestBaseControllerV2_DeleteById(t *testing.T) {
defer CleanupTestDB()
// Insert a test document
id, err := service.NewModelServiceV2[TestModel]().InsertOne(TestModel{Name: "test"})
id, err := service.NewModelService[TestModel]().InsertOne(TestModel{Name: "test"})
assert.NoError(t, err)
// Initialize the controller
@@ -160,6 +160,6 @@ func TestBaseControllerV2_DeleteById(t *testing.T) {
assert.Equal(t, http.StatusOK, w.Code)
// Check if the document was deleted from the database
_, err = service.NewModelServiceV2[TestModel]().GetById(id)
_, err = service.NewModelService[TestModel]().GetById(id)
assert.Error(t, err)
}

6
core/controllers/project_v2.go
View File

@@ -25,7 +25,7 @@ func GetProjectList(c *gin.Context) {
sort := MustGetSortOption(c)
// get list
projects, err := service.NewModelServiceV2[models2.ProjectV2]().GetMany(query, &mongo.FindOptions{
projects, err := service.NewModelService[models2.ProjectV2]().GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
@@ -42,7 +42,7 @@ func GetProjectList(c *gin.Context) {
}
// total count
total, err := service.NewModelServiceV2[models2.ProjectV2]().Count(query)
total, err := service.NewModelService[models2.ProjectV2]().Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -61,7 +61,7 @@ func GetProjectList(c *gin.Context) {
}
// spiders
spiders, err := service.NewModelServiceV2[models2.SpiderV2]().GetMany(bson.M{
spiders, err := service.NewModelService[models2.SpiderV2]().GetMany(bson.M{
"project_id": bson.M{
"$in": ids,
},

6
core/controllers/schedule_v2.go
View File

@@ -18,7 +18,7 @@ func PostSchedule(c *gin.Context) {
u := GetUserFromContext(c)
modelSvc := service.NewModelServiceV2[models.ScheduleV2]()
modelSvc := service.NewModelService[models.ScheduleV2]()
s.SetCreated(u.Id)
s.SetUpdated(u.Id)
@@ -60,7 +60,7 @@ func PutScheduleById(c *gin.Context) {
return
}
modelSvc := service.NewModelServiceV2[models.ScheduleV2]()
modelSvc := service.NewModelService[models.ScheduleV2]()
err = modelSvc.ReplaceById(id, s)
if err != nil {
HandleErrorInternalServerError(c, err)
@@ -110,7 +110,7 @@ func postScheduleEnableDisableFunc(isEnable bool) func(c *gin.Context) {
HandleErrorInternalServerError(c, err)
return
}
s, err := service.NewModelServiceV2[models.ScheduleV2]().GetById(id)
s, err := service.NewModelService[models.ScheduleV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return

6
core/controllers/setting_v2.go
View File

@@ -14,7 +14,7 @@ func GetSetting(c *gin.Context) {
key := c.Param("id")
// setting
s, err := service.NewModelServiceV2[models.SettingV2]().GetOne(bson.M{"key": key}, nil)
s, err := service.NewModelService[models.SettingV2]().GetOne(bson.M{"key": key}, nil)
if err != nil {
if errors.Is(err, mongo.ErrNoDocuments) {
HandleSuccess(c)
@@ -47,7 +47,7 @@ func PostSetting(c *gin.Context) {
s.SetCreated(u.Id)
s.SetUpdated(u.Id)
id, err := service.NewModelServiceV2[models.SettingV2]().InsertOne(s)
id, err := service.NewModelService[models.SettingV2]().InsertOne(s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -68,7 +68,7 @@ func PutSetting(c *gin.Context) {
return
}
modelSvc := service.NewModelServiceV2[models.SettingV2]()
modelSvc := service.NewModelService[models.SettingV2]()
// setting
_s, err := modelSvc.GetOne(bson.M{"key": key}, nil)

56
core/controllers/spider_v2.go
View File

@@ -30,7 +30,7 @@ func GetSpiderById(c *gin.Context) {
HandleErrorBadRequest(c, err)
return
}
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorNotFound(c, err)
return
@@ -41,7 +41,7 @@ func GetSpiderById(c *gin.Context) {
}
// stat
s.Stat, err = service.NewModelServiceV2[models2.SpiderStatV2]().GetById(s.Id)
s.Stat, err = service.NewModelService[models2.SpiderStatV2]().GetById(s.Id)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorInternalServerError(c, err)
@@ -51,7 +51,7 @@ func GetSpiderById(c *gin.Context) {
// data collection (compatible to old version) # TODO: remove in the future
if s.ColName == "" && !s.ColId.IsZero() {
col, err := service.NewModelServiceV2[models2.DataCollectionV2]().GetById(s.ColId)
col, err := service.NewModelService[models2.DataCollectionV2]().GetById(s.ColId)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorInternalServerError(c, err)
@@ -64,7 +64,7 @@ func GetSpiderById(c *gin.Context) {
// git
if utils.IsPro() && !s.GitId.IsZero() {
s.Git, err = service.NewModelServiceV2[models2.GitV2]().GetById(s.GitId)
s.Git, err = service.NewModelService[models2.GitV2]().GetById(s.GitId)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorInternalServerError(c, err)
@@ -102,7 +102,7 @@ func getSpiderListWithStats(c *gin.Context) {
sort := MustGetSortOption(c)
// get list
spiders, err := service.NewModelServiceV2[models2.SpiderV2]().GetMany(query, &mongo.FindOptions{
spiders, err := service.NewModelService[models2.SpiderV2]().GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
@@ -129,14 +129,14 @@ func getSpiderListWithStats(c *gin.Context) {
}
// total count
total, err := service.NewModelServiceV2[models2.SpiderV2]().Count(query)
total, err := service.NewModelService[models2.SpiderV2]().Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
spiderStats, err := service.NewModelServiceV2[models2.SpiderStatV2]().GetMany(bson.M{"_id": bson.M{"$in": ids}}, nil)
spiderStats, err := service.NewModelService[models2.SpiderStatV2]().GetMany(bson.M{"_id": bson.M{"$in": ids}}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -170,14 +170,14 @@ func getSpiderListWithStats(c *gin.Context) {
"$in": taskIds,
},
}
tasks, err = service.NewModelServiceV2[models2.TaskV2]().GetMany(queryTask, nil)
tasks, err = service.NewModelService[models2.TaskV2]().GetMany(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// task stats list
taskStats, err := service.NewModelServiceV2[models2.TaskStatV2]().GetMany(queryTask, nil)
taskStats, err := service.NewModelService[models2.TaskStatV2]().GetMany(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -201,7 +201,7 @@ func getSpiderListWithStats(c *gin.Context) {
// git list
var gits []models2.GitV2
if len(gitIds) > 0 && utils.IsPro() {
gits, err = service.NewModelServiceV2[models2.GitV2]().GetMany(bson.M{"_id": bson.M{"$in": gitIds}}, nil)
gits, err = service.NewModelService[models2.GitV2]().GetMany(bson.M{"_id": bson.M{"$in": gitIds}}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -259,7 +259,7 @@ func PostSpider(c *gin.Context) {
// add
s.SetCreated(u.Id)
s.SetUpdated(u.Id)
id, err := service.NewModelServiceV2[models2.SpiderV2]().InsertOne(s)
id, err := service.NewModelService[models2.SpiderV2]().InsertOne(s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -271,7 +271,7 @@ func PostSpider(c *gin.Context) {
st.SetId(id)
st.SetCreated(u.Id)
st.SetUpdated(u.Id)
_, err = service.NewModelServiceV2[models2.SpiderStatV2]().InsertOne(st)
_, err = service.NewModelService[models2.SpiderStatV2]().InsertOne(st)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -308,7 +308,7 @@ func PutSpiderById(c *gin.Context) {
u := GetUserFromContext(c)
modelSvc := service.NewModelServiceV2[models2.SpiderV2]()
modelSvc := service.NewModelService[models2.SpiderV2]()
// save
s.SetUpdated(u.Id)
@@ -336,7 +336,7 @@ func DeleteSpiderById(c *gin.Context) {
}
// spider
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -344,19 +344,19 @@ func DeleteSpiderById(c *gin.Context) {
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spider
err = service.NewModelServiceV2[models2.SpiderV2]().DeleteById(id)
err = service.NewModelService[models2.SpiderV2]().DeleteById(id)
if err != nil {
return err
}
// delete spider stat
err = service.NewModelServiceV2[models2.SpiderStatV2]().DeleteById(id)
err = service.NewModelService[models2.SpiderStatV2]().DeleteById(id)
if err != nil {
return err
}
// related tasks
tasks, err := service.NewModelServiceV2[models2.TaskV2]().GetMany(bson.M{"spider_id": id}, nil)
tasks, err := service.NewModelService[models2.TaskV2]().GetMany(bson.M{"spider_id": id}, nil)
if err != nil {
return err
}
@@ -372,13 +372,13 @@ func DeleteSpiderById(c *gin.Context) {
}
// delete related tasks
err = service.NewModelServiceV2[models2.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
err = service.NewModelService[models2.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
if err != nil {
return err
}
// delete related task stats
err = service.NewModelServiceV2[models2.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
err = service.NewModelService[models2.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
if err != nil {
return err
}
@@ -433,7 +433,7 @@ func DeleteSpiderList(c *gin.Context) {
}
// Fetch spiders before deletion
spiders, err := service.NewModelServiceV2[models2.SpiderV2]().GetMany(bson.M{
spiders, err := service.NewModelService[models2.SpiderV2]().GetMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
@@ -445,7 +445,7 @@ func DeleteSpiderList(c *gin.Context) {
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spiders
if err := service.NewModelServiceV2[models2.SpiderV2]().DeleteMany(bson.M{
if err := service.NewModelService[models2.SpiderV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
@@ -454,7 +454,7 @@ func DeleteSpiderList(c *gin.Context) {
}
// delete spider stats
if err := service.NewModelServiceV2[models2.SpiderStatV2]().DeleteMany(bson.M{
if err := service.NewModelService[models2.SpiderStatV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
@@ -463,7 +463,7 @@ func DeleteSpiderList(c *gin.Context) {
}
// related tasks
tasks, err := service.NewModelServiceV2[models2.TaskV2]().GetMany(bson.M{"spider_id": bson.M{"$in": payload.Ids}}, nil)
tasks, err := service.NewModelService[models2.TaskV2]().GetMany(bson.M{"spider_id": bson.M{"$in": payload.Ids}}, nil)
if err != nil {
return err
}
@@ -479,12 +479,12 @@ func DeleteSpiderList(c *gin.Context) {
}
// delete related tasks
if err := service.NewModelServiceV2[models2.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
if err := service.NewModelService[models2.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
// delete related task stats
if err := service.NewModelServiceV2[models2.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
if err := service.NewModelService[models2.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
@@ -676,7 +676,7 @@ func GetSpiderResults(c *gin.Context) {
return
}
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -716,7 +716,7 @@ func getSpiderFsSvc(s *models2.SpiderV2) (svc interfaces.FsService, err error) {
}
func getSpiderFsSvcById(id primitive.ObjectID) (svc interfaces.FsService, err error) {
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if err != nil {
log.Errorf("failed to get spider: %s", err.Error())
trace.PrintError(err)
@@ -733,7 +733,7 @@ func getSpiderRootPath(c *gin.Context) (rootPath string, err error) {
}
// spider
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if err != nil {
return "", err
}

42
core/controllers/spider_v2_test.go
View File

@@ -62,11 +62,11 @@ func TestGetSpiderById(t *testing.T) {
Name: "Test Spider",
ColName: "test_spiders",
}
id, err := service.NewModelServiceV2[models.SpiderV2]().InsertOne(model)
id, err := service.NewModelService[models.SpiderV2]().InsertOne(model)
require.Nil(t, err)
ts := models.SpiderStatV2{}
ts.SetId(id)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().InsertOne(ts)
_, err = service.NewModelService[models.SpiderStatV2]().InsertOne(ts)
require.Nil(t, err)
req, _ := http.NewRequest("GET", "/spiders/"+id.Hex(), nil)
@@ -97,11 +97,11 @@ func TestUpdateSpiderById(t *testing.T) {
Name: "Test Spider",
ColName: "test_spiders",
}
id, err := service.NewModelServiceV2[models.SpiderV2]().InsertOne(model)
id, err := service.NewModelService[models.SpiderV2]().InsertOne(model)
require.Nil(t, err)
ts := models.SpiderStatV2{}
ts.SetId(id)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().InsertOne(ts)
_, err = service.NewModelService[models.SpiderStatV2]().InsertOne(ts)
require.Nil(t, err)
spiderId := id.Hex()
@@ -124,7 +124,7 @@ func TestUpdateSpiderById(t *testing.T) {
require.Nil(t, err)
assert.Equal(t, payload.Name, response.Data.Name)
svc := service.NewModelServiceV2[models.SpiderV2]()
svc := service.NewModelService[models.SpiderV2]()
resModel, err := svc.GetById(id)
require.Nil(t, err)
assert.Equal(t, payload.Name, resModel.Name)
@@ -144,19 +144,19 @@ func TestDeleteSpiderById(t *testing.T) {
Name: "Test Spider",
ColName: "test_spiders",
}
id, err := service.NewModelServiceV2[models.SpiderV2]().InsertOne(model)
id, err := service.NewModelService[models.SpiderV2]().InsertOne(model)
require.Nil(t, err)
ts := models.SpiderStatV2{}
ts.SetId(id)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().InsertOne(ts)
_, err = service.NewModelService[models.SpiderStatV2]().InsertOne(ts)
require.Nil(t, err)
task := models.TaskV2{}
task.SpiderId = id
taskId, err := service.NewModelServiceV2[models.TaskV2]().InsertOne(task)
taskId, err := service.NewModelService[models.TaskV2]().InsertOne(task)
require.Nil(t, err)
taskStat := models.TaskStatV2{}
taskStat.SetId(taskId)
_, err = service.NewModelServiceV2[models.TaskStatV2]().InsertOne(taskStat)
_, err = service.NewModelService[models.TaskStatV2]().InsertOne(taskStat)
require.Nil(t, err)
req, _ := http.NewRequest("DELETE", "/spiders/"+id.Hex(), nil)
@@ -167,14 +167,14 @@ func TestDeleteSpiderById(t *testing.T) {
assert.Equal(t, http.StatusOK, resp.Code)
_, err = service.NewModelServiceV2[models.SpiderV2]().GetById(id)
_, err = service.NewModelService[models.SpiderV2]().GetById(id)
assert.NotNil(t, err)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().GetById(id)
_, err = service.NewModelService[models.SpiderStatV2]().GetById(id)
assert.NotNil(t, err)
taskCount, err := service.NewModelServiceV2[models.TaskV2]().Count(bson.M{"spider_id": id})
taskCount, err := service.NewModelService[models.TaskV2]().Count(bson.M{"spider_id": id})
require.Nil(t, err)
assert.Equal(t, 0, taskCount)
taskStatCount, err := service.NewModelServiceV2[models.TaskStatV2]().Count(bson.M{"_id": taskId})
taskStatCount, err := service.NewModelService[models.TaskStatV2]().Count(bson.M{"_id": taskId})
require.Nil(t, err)
assert.Equal(t, 0, taskStatCount)
@@ -202,19 +202,19 @@ func TestDeleteSpiderList(t *testing.T) {
var ids []primitive.ObjectID
var taskIds []primitive.ObjectID
for _, model := range modelList {
id, err := service.NewModelServiceV2[models.SpiderV2]().InsertOne(model)
id, err := service.NewModelService[models.SpiderV2]().InsertOne(model)
require.Nil(t, err)
ts := models.SpiderStatV2{}
ts.SetId(id)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().InsertOne(ts)
_, err = service.NewModelService[models.SpiderStatV2]().InsertOne(ts)
require.Nil(t, err)
task := models.TaskV2{}
task.SpiderId = id
taskId, err := service.NewModelServiceV2[models.TaskV2]().InsertOne(task)
taskId, err := service.NewModelService[models.TaskV2]().InsertOne(task)
require.Nil(t, err)
taskStat := models.TaskStatV2{}
taskStat.SetId(taskId)
_, err = service.NewModelServiceV2[models.TaskStatV2]().InsertOne(taskStat)
_, err = service.NewModelService[models.TaskStatV2]().InsertOne(taskStat)
require.Nil(t, err)
ids = append(ids, id)
taskIds = append(taskIds, taskId)
@@ -234,16 +234,16 @@ func TestDeleteSpiderList(t *testing.T) {
assert.Equal(t, http.StatusOK, resp.Code)
spiderCount, err := service.NewModelServiceV2[models.SpiderV2]().Count(bson.M{"_id": bson.M{"$in": ids}})
spiderCount, err := service.NewModelService[models.SpiderV2]().Count(bson.M{"_id": bson.M{"$in": ids}})
require.Nil(t, err)
assert.Equal(t, 0, spiderCount)
spiderStatCount, err := service.NewModelServiceV2[models.SpiderStatV2]().Count(bson.M{"_id": bson.M{"$in": ids}})
spiderStatCount, err := service.NewModelService[models.SpiderStatV2]().Count(bson.M{"_id": bson.M{"$in": ids}})
require.Nil(t, err)
assert.Equal(t, 0, spiderStatCount)
taskCount, err := service.NewModelServiceV2[models.TaskV2]().Count(bson.M{"_id": bson.M{"$in": taskIds}})
taskCount, err := service.NewModelService[models.TaskV2]().Count(bson.M{"_id": bson.M{"$in": taskIds}})
require.Nil(t, err)
assert.Equal(t, 0, taskCount)
taskStatCount, err := service.NewModelServiceV2[models.TaskStatV2]().Count(bson.M{"_id": bson.M{"$in": taskIds}})
taskStatCount, err := service.NewModelService[models.TaskStatV2]().Count(bson.M{"_id": bson.M{"$in": taskIds}})
require.Nil(t, err)
assert.Equal(t, 0, taskStatCount)
}

36
core/controllers/task_v2.go
View File

@@ -32,7 +32,7 @@ func GetTaskById(c *gin.Context) {
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
t, err := service.NewModelService[models.TaskV2]().GetById(id)
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorNotFound(c, err)
return
@@ -50,21 +50,21 @@ func GetTaskById(c *gin.Context) {
// spider
if !t.SpiderId.IsZero() {
t.Spider, _ = service.NewModelServiceV2[models.SpiderV2]().GetById(t.SpiderId)
t.Spider, _ = service.NewModelService[models.SpiderV2]().GetById(t.SpiderId)
}
// schedule
if !t.ScheduleId.IsZero() {
t.Schedule, _ = service.NewModelServiceV2[models.ScheduleV2]().GetById(t.ScheduleId)
t.Schedule, _ = service.NewModelService[models.ScheduleV2]().GetById(t.ScheduleId)
}
// node
if !t.NodeId.IsZero() {
t.Node, _ = service.NewModelServiceV2[models.NodeV2]().GetById(t.NodeId)
t.Node, _ = service.NewModelService[models.NodeV2]().GetById(t.NodeId)
}
// task stat
t.Stat, _ = service.NewModelServiceV2[models.TaskStatV2]().GetById(id)
t.Stat, _ = service.NewModelService[models.TaskStatV2]().GetById(id)
HandleSuccessWithData(c, t)
}
@@ -82,7 +82,7 @@ func GetTaskList(c *gin.Context) {
sort := MustGetSortOption(c)
// get tasks
tasks, err := service.NewModelServiceV2[models.TaskV2]().GetMany(query, &mongo.FindOptions{
tasks, err := service.NewModelService[models.TaskV2]().GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
@@ -111,14 +111,14 @@ func GetTaskList(c *gin.Context) {
}
// total count
total, err := service.NewModelServiceV2[models.TaskV2]().Count(query)
total, err := service.NewModelService[models.TaskV2]().Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
stats, err := service.NewModelServiceV2[models.TaskStatV2]().GetMany(bson.M{
stats, err := service.NewModelService[models.TaskStatV2]().GetMany(bson.M{
"_id": bson.M{
"$in": taskIds,
},
@@ -135,7 +135,7 @@ func GetTaskList(c *gin.Context) {
}
// spider list
spiders, err := service.NewModelServiceV2[models.SpiderV2]().GetMany(bson.M{
spiders, err := service.NewModelService[models.SpiderV2]().GetMany(bson.M{
"_id": bson.M{
"$in": spiderIds,
},
@@ -180,22 +180,22 @@ func DeleteTaskById(c *gin.Context) {
// delete in db
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete task
_, err = service.NewModelServiceV2[models.TaskV2]().GetById(id)
_, err = service.NewModelService[models.TaskV2]().GetById(id)
if err != nil {
return err
}
err = service.NewModelServiceV2[models.TaskV2]().DeleteById(id)
err = service.NewModelService[models.TaskV2]().DeleteById(id)
if err != nil {
return err
}
// delete task stat
_, err = service.NewModelServiceV2[models.TaskStatV2]().GetById(id)
_, err = service.NewModelService[models.TaskStatV2]().GetById(id)
if err != nil {
log2.Warnf("delete task stat error: %s", err.Error())
return nil
}
err = service.NewModelServiceV2[models.TaskStatV2]().DeleteById(id)
err = service.NewModelService[models.TaskStatV2]().DeleteById(id)
if err != nil {
log2.Warnf("delete task stat error: %s", err.Error())
return nil
@@ -227,7 +227,7 @@ func DeleteList(c *gin.Context) {
if err := mongo.RunTransaction(func(context mongo2.SessionContext) error {
// delete tasks
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{
if err := service.NewModelService[models.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
@@ -236,7 +236,7 @@ func DeleteList(c *gin.Context) {
}
// delete task stats
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{
if err := service.NewModelService[models.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
@@ -284,7 +284,7 @@ func PostTaskRun(c *gin.Context) {
}
// spider
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(t.SpiderId)
s, err := service.NewModelService[models.SpiderV2]().GetById(t.SpiderId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -329,7 +329,7 @@ func PostTaskRestart(c *gin.Context) {
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
t, err := service.NewModelService[models.TaskV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -384,7 +384,7 @@ func PostTaskCancel(c *gin.Context) {
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
t, err := service.NewModelService[models.TaskV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return

2
core/controllers/token_v2.go
View File

@@ -26,7 +26,7 @@ func PostToken(c *gin.Context) {
HandleErrorInternalServerError(c, err)
return
}
_, err = service.NewModelServiceV2[models.TokenV2]().InsertOne(t)
_, err = service.NewModelService[models.TokenV2]().InsertOne(t)
if err != nil {
HandleErrorInternalServerError(c, err)
return

10
core/controllers/user_v2.go
View File

@@ -28,13 +28,13 @@ func PostUser(c *gin.Context) {
}
model.SetCreated(u.Id)
model.SetUpdated(u.Id)
id, err := service.NewModelServiceV2[models.UserV2]().InsertOne(model)
id, err := service.NewModelService[models.UserV2]().InsertOne(model)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
result, err := service.NewModelServiceV2[models.UserV2]().GetById(id)
result, err := service.NewModelService[models.UserV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -63,7 +63,7 @@ func PostUserChangePassword(c *gin.Context) {
// get user
u := GetUserFromContext(c)
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
// update password
user, err := modelSvc.GetById(id)
@@ -84,7 +84,7 @@ func PostUserChangePassword(c *gin.Context) {
func GetUserMe(c *gin.Context) {
u := GetUserFromContext(c)
_u, err := service.NewModelServiceV2[models.UserV2]().GetById(u.Id)
_u, err := service.NewModelService[models.UserV2]().GetById(u.Id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
@@ -103,7 +103,7 @@ func PutUserById(c *gin.Context) {
// get user
u := GetUserFromContext(c)
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
// update user
userDb, err := modelSvc.GetById(u.Id)

6
core/controllers/user_v2_test.go
View File

@@ -17,7 +17,7 @@ func TestPostUserChangePassword_Success(t *testing.T) {
SetupTestDB()
defer CleanupTestDB()
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
u := models.UserV2{}
id, err := modelSvc.InsertOne(u)
assert.Nil(t, err)
@@ -43,7 +43,7 @@ func TestGetUserMe_Success(t *testing.T) {
SetupTestDB()
defer CleanupTestDB()
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
u := models.UserV2{}
id, err := modelSvc.InsertOne(u)
assert.Nil(t, err)
@@ -67,7 +67,7 @@ func TestPutUserById_Success(t *testing.T) {
SetupTestDB()
defer CleanupTestDB()
modelSvc := service.NewModelServiceV2[models.UserV2]()
modelSvc := service.NewModelService[models.UserV2]()
u := models.UserV2{}
id, err := modelSvc.InsertOne(u)
assert.Nil(t, err)

16
core/grpc/client/client.go
View File

@@ -37,11 +37,11 @@ type GrpcClient struct {
stop chan struct{}
// clients
NodeClient grpc2.NodeServiceClient
TaskClient grpc2.TaskServiceClient
ModelBaseServiceV2Client grpc2.ModelBaseServiceV2Client
DependencyClient grpc2.DependencyServiceV2Client
MetricClient grpc2.MetricServiceV2Client
NodeClient grpc2.NodeServiceClient
TaskClient grpc2.TaskServiceClient
ModelBaseServiceClient grpc2.ModelBaseServiceClient
DependencyClient grpc2.DependencyServiceClient
MetricClient grpc2.MetricServiceClient
}
func (c *GrpcClient) Start() (err error) {
@@ -84,10 +84,10 @@ func (c *GrpcClient) Stop() (err error) {
func (c *GrpcClient) register() {
c.NodeClient = grpc2.NewNodeServiceClient(c.conn)
c.ModelBaseServiceV2Client = grpc2.NewModelBaseServiceV2Client(c.conn)
c.ModelBaseServiceClient = grpc2.NewModelBaseServiceClient(c.conn)
c.TaskClient = grpc2.NewTaskServiceClient(c.conn)
c.DependencyClient = grpc2.NewDependencyServiceV2Client(c.conn)
c.MetricClient = grpc2.NewMetricServiceV2Client(c.conn)
c.DependencyClient = grpc2.NewDependencyServiceClient(c.conn)
c.MetricClient = grpc2.NewMetricServiceClient(c.conn)
}
func (c *GrpcClient) Context() (ctx context.Context, cancel context.CancelFunc) {

28
core/grpc/server/dependency_service_server.go
View File

@@ -18,12 +18,12 @@ import (
)
type DependencyServiceServer struct {
grpc.UnimplementedDependencyServiceV2Server
grpc.UnimplementedDependencyServiceServer
mu *sync.Mutex
streams map[string]*grpc.DependencyServiceV2_ConnectServer
streams map[string]*grpc.DependencyService_ConnectServer
}
func (svr DependencyServiceServer) Connect(req *grpc.DependencyServiceV2ConnectRequest, stream grpc.DependencyServiceV2_ConnectServer) (err error) {
func (svr DependencyServiceServer) Connect(req *grpc.DependencyServiceConnectRequest, stream grpc.DependencyService_ConnectServer) (err error) {
svr.mu.Lock()
svr.streams[req.NodeKey] = &stream
svr.mu.Unlock()
@@ -39,19 +39,19 @@ func (svr DependencyServiceServer) Connect(req *grpc.DependencyServiceV2ConnectR
}
}
func (svr DependencyServiceServer) Sync(ctx context.Context, request *grpc.DependencyServiceV2SyncRequest) (response *grpc.Response, err error) {
n, err := service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": request.NodeKey}, nil)
func (svr DependencyServiceServer) Sync(ctx context.Context, request *grpc.DependencyServiceSyncRequest) (response *grpc.Response, err error) {
n, err := service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": request.NodeKey}, nil)
if err != nil {
return nil, err
}
depsDb, err := service.NewModelServiceV2[models2.DependencyV2]().GetMany(bson.M{
depsDb, err := service.NewModelService[models2.DependencyV2]().GetMany(bson.M{
"node_id": n.Id,
"type": request.Lang,
}, nil)
if err != nil {
if !errors.Is(err, mongo.ErrNoDocuments) {
log.Errorf("[DependencyServiceV2] get dependencies from db error: %v", err)
log.Errorf("[DependencyService] get dependencies from db error: %v", err)
return nil, err
}
}
@@ -90,7 +90,7 @@ func (svr DependencyServiceServer) Sync(ctx context.Context, request *grpc.Depen
err = mongo2.RunTransaction(func(ctx mongo.SessionContext) (err error) {
if len(depIdsToDelete) > 0 {
err = service.NewModelServiceV2[models2.DependencyV2]().DeleteMany(bson.M{
err = service.NewModelService[models2.DependencyV2]().DeleteMany(bson.M{
"_id": bson.M{"$in": depIdsToDelete},
})
if err != nil {
@@ -101,7 +101,7 @@ func (svr DependencyServiceServer) Sync(ctx context.Context, request *grpc.Depen
}
if len(depsToInsert) > 0 {
_, err = service.NewModelServiceV2[models2.DependencyV2]().InsertMany(depsToInsert)
_, err = service.NewModelService[models2.DependencyV2]().InsertMany(depsToInsert)
if err != nil {
log.Errorf("[DependencyServiceServer] insert dependencies in db error: %v", err)
trace.PrintError(err)
@@ -115,7 +115,7 @@ func (svr DependencyServiceServer) Sync(ctx context.Context, request *grpc.Depen
return nil, err
}
func (svr DependencyServiceServer) UpdateTaskLog(stream grpc.DependencyServiceV2_UpdateTaskLogServer) (err error) {
func (svr DependencyServiceServer) UpdateTaskLog(stream grpc.DependencyService_UpdateTaskLogServer) (err error) {
var t *models2.DependencyTaskV2
for {
req, err := stream.Recv()
@@ -131,7 +131,7 @@ func (svr DependencyServiceServer) UpdateTaskLog(stream grpc.DependencyServiceV2
return err
}
if t == nil {
t, err = service.NewModelServiceV2[models2.DependencyTaskV2]().GetById(taskId)
t, err = service.NewModelService[models2.DependencyTaskV2]().GetById(taskId)
if err != nil {
return err
}
@@ -145,14 +145,14 @@ func (svr DependencyServiceServer) UpdateTaskLog(stream grpc.DependencyServiceV2
l.SetCreated(t.CreatedBy)
logs = append(logs, l)
}
_, err = service.NewModelServiceV2[models2.DependencyLogV2]().InsertMany(logs)
_, err = service.NewModelService[models2.DependencyLogV2]().InsertMany(logs)
if err != nil {
return err
}
}
}
func (svr DependencyServiceServer) GetStream(key string) (stream *grpc.DependencyServiceV2_ConnectServer, err error) {
func (svr DependencyServiceServer) GetStream(key string) (stream *grpc.DependencyService_ConnectServer, err error) {
svr.mu.Lock()
defer svr.mu.Unlock()
stream, ok := svr.streams[key]
@@ -165,7 +165,7 @@ func (svr DependencyServiceServer) GetStream(key string) (stream *grpc.Dependenc
func NewDependencyServerV2() *DependencyServiceServer {
return &DependencyServiceServer{
mu: new(sync.Mutex),
streams: make(map[string]*grpc.DependencyServiceV2_ConnectServer),
streams: make(map[string]*grpc.DependencyService_ConnectServer),
}
}

8
core/grpc/server/metric_service_server.go
View File

@@ -12,12 +12,12 @@ import (
)
type MetricServiceServer struct {
grpc.UnimplementedMetricServiceV2Server
grpc.UnimplementedMetricServiceServer
}
func (svr MetricServiceServer) Send(_ context.Context, req *grpc.MetricServiceV2SendRequest) (res *grpc.Response, err error) {
func (svr MetricServiceServer) Send(_ context.Context, req *grpc.MetricServiceSendRequest) (res *grpc.Response, err error) {
log.Info("[MetricServiceServer] received metric from node: " + req.NodeKey)
n, err := service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
n, err := service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
if err != nil {
log.Errorf("[MetricServiceServer] error getting node: %v", err)
return HandleError(err)
@@ -40,7 +40,7 @@ func (svr MetricServiceServer) Send(_ context.Context, req *grpc.MetricServiceV2
NetworkBytesRecvRate: req.NetworkBytesRecvRate,
}
metric.CreatedAt = time.Unix(req.Timestamp, 0)
_, err = service.NewModelServiceV2[models2.MetricV2]().InsertOne(metric)
_, err = service.NewModelService[models2.MetricV2]().InsertOne(metric)
if err != nil {
log.Errorf("[MetricServiceServer] error inserting metric: %v", err)
return HandleError(err)

46
core/grpc/server/model_base_service_v2_server.go → core/grpc/server/model_base_service_server.go
View File

@@ -33,16 +33,16 @@ func GetOneInstanceModel(typeName string) any {
return typeOneNameModelMap[typeName]
}
type ModelBaseServiceServerV2 struct {
grpc.UnimplementedModelBaseServiceV2Server
type ModelBaseServiceServer struct {
grpc.UnimplementedModelBaseServiceServer
}
func (svr ModelBaseServiceServerV2) GetById(_ context.Context, req *grpc.ModelServiceV2GetByIdRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) GetById(_ context.Context, req *grpc.ModelServiceGetByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
modelSvc := service.NewModelServiceWithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetById(id)
if err != nil {
return HandleError(err)
@@ -50,7 +50,7 @@ func (svr ModelBaseServiceServerV2) GetById(_ context.Context, req *grpc.ModelSe
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) GetOne(_ context.Context, req *grpc.ModelServiceV2GetOneRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) GetOne(_ context.Context, req *grpc.ModelServiceGetOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -61,7 +61,7 @@ func (svr ModelBaseServiceServerV2) GetOne(_ context.Context, req *grpc.ModelSer
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
modelSvc := service.NewModelServiceWithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetOne(query, &options)
if err != nil {
return HandleError(err)
@@ -69,7 +69,7 @@ func (svr ModelBaseServiceServerV2) GetOne(_ context.Context, req *grpc.ModelSer
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) GetMany(_ context.Context, req *grpc.ModelServiceV2GetManyRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) GetMany(_ context.Context, req *grpc.ModelServiceGetManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -80,7 +80,7 @@ func (svr ModelBaseServiceServerV2) GetMany(_ context.Context, req *grpc.ModelSe
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
modelSvc := service.NewModelServiceWithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetMany(query, &options)
if err != nil {
return HandleError(err)
@@ -88,7 +88,7 @@ func (svr ModelBaseServiceServerV2) GetMany(_ context.Context, req *grpc.ModelSe
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) DeleteById(_ context.Context, req *grpc.ModelServiceV2DeleteByIdRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) DeleteById(_ context.Context, req *grpc.ModelServiceDeleteByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
@@ -101,7 +101,7 @@ func (svr ModelBaseServiceServerV2) DeleteById(_ context.Context, req *grpc.Mode
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) DeleteOne(_ context.Context, req *grpc.ModelServiceV2DeleteOneRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) DeleteOne(_ context.Context, req *grpc.ModelServiceDeleteOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -115,7 +115,7 @@ func (svr ModelBaseServiceServerV2) DeleteOne(_ context.Context, req *grpc.Model
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) DeleteMany(_ context.Context, req *grpc.ModelServiceV2DeleteManyRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) DeleteMany(_ context.Context, req *grpc.ModelServiceDeleteManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -129,7 +129,7 @@ func (svr ModelBaseServiceServerV2) DeleteMany(_ context.Context, req *grpc.Mode
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateById(_ context.Context, req *grpc.ModelServiceV2UpdateByIdRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) UpdateById(_ context.Context, req *grpc.ModelServiceUpdateByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
@@ -147,7 +147,7 @@ func (svr ModelBaseServiceServerV2) UpdateById(_ context.Context, req *grpc.Mode
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateOne(_ context.Context, req *grpc.ModelServiceV2UpdateOneRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) UpdateOne(_ context.Context, req *grpc.ModelServiceUpdateOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -166,7 +166,7 @@ func (svr ModelBaseServiceServerV2) UpdateOne(_ context.Context, req *grpc.Model
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateMany(_ context.Context, req *grpc.ModelServiceV2UpdateManyRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) UpdateMany(_ context.Context, req *grpc.ModelServiceUpdateManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -185,7 +185,7 @@ func (svr ModelBaseServiceServerV2) UpdateMany(_ context.Context, req *grpc.Mode
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) ReplaceById(_ context.Context, req *grpc.ModelServiceV2ReplaceByIdRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) ReplaceById(_ context.Context, req *grpc.ModelServiceReplaceByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
@@ -205,7 +205,7 @@ func (svr ModelBaseServiceServerV2) ReplaceById(_ context.Context, req *grpc.Mod
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) ReplaceOne(_ context.Context, req *grpc.ModelServiceV2ReplaceOneRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) ReplaceOne(_ context.Context, req *grpc.ModelServiceReplaceOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -226,7 +226,7 @@ func (svr ModelBaseServiceServerV2) ReplaceOne(_ context.Context, req *grpc.Mode
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) InsertOne(_ context.Context, req *grpc.ModelServiceV2InsertOneRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) InsertOne(_ context.Context, req *grpc.ModelServiceInsertOneRequest) (res *grpc.Response, err error) {
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelValuePtr := reflect.New(modelType).Interface()
@@ -242,7 +242,7 @@ func (svr ModelBaseServiceServerV2) InsertOne(_ context.Context, req *grpc.Model
return HandleSuccessWithData(r.InsertedID)
}
func (svr ModelBaseServiceServerV2) InsertMany(_ context.Context, req *grpc.ModelServiceV2InsertManyRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) InsertMany(_ context.Context, req *grpc.ModelServiceInsertManyRequest) (res *grpc.Response, err error) {
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelsSliceType := reflect.SliceOf(modelType)
@@ -268,7 +268,7 @@ func (svr ModelBaseServiceServerV2) InsertMany(_ context.Context, req *grpc.Mode
return HandleSuccessWithData(r.InsertedIDs)
}
func (svr ModelBaseServiceServerV2) Count(_ context.Context, req *grpc.ModelServiceV2CountRequest) (res *grpc.Response, err error) {
func (svr ModelBaseServiceServer) Count(_ context.Context, req *grpc.ModelServiceCountRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
@@ -281,10 +281,10 @@ func (svr ModelBaseServiceServerV2) Count(_ context.Context, req *grpc.ModelServ
return HandleSuccessWithData(count)
}
func GetModelService[T any](typeName string) *service.ModelServiceV2[T] {
return service.NewModelServiceV2WithColName[T](typeNameColNameMap[typeName])
func GetModelService[T any](typeName string) *service.ModelService[T] {
return service.NewModelServiceWithColName[T](typeNameColNameMap[typeName])
}
func NewModelBaseServiceV2Server() *ModelBaseServiceServerV2 {
return &ModelBaseServiceServerV2{}
func NewModelBaseServiceServer() *ModelBaseServiceServer {
return &ModelBaseServiceServer{}
}

12
core/grpc/server/node_service_server.go
View File

@@ -41,13 +41,13 @@ func (svr NodeServiceServer) Register(_ context.Context, req *grpc.NodeServiceRe
// find in db
var node *models.NodeV2
node, err = service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
node, err = service.NewModelService[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
if err == nil {
// register existing
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
err = service.NewModelService[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return HandleError(err)
}
@@ -65,7 +65,7 @@ func (svr NodeServiceServer) Register(_ context.Context, req *grpc.NodeServiceRe
}
node.SetCreated(primitive.NilObjectID)
node.SetUpdated(primitive.NilObjectID)
node.Id, err = service.NewModelServiceV2[models.NodeV2]().InsertOne(*node)
node.Id, err = service.NewModelService[models.NodeV2]().InsertOne(*node)
if err != nil {
return HandleError(err)
}
@@ -83,7 +83,7 @@ func (svr NodeServiceServer) Register(_ context.Context, req *grpc.NodeServiceRe
// SendHeartbeat from worker to master
func (svr NodeServiceServer) SendHeartbeat(_ context.Context, req *grpc.NodeServiceSendHeartbeatRequest) (res *grpc.Response, err error) {
// find in db
node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
node, err := service.NewModelService[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
if err != nil {
if errors2.Is(err, mongo.ErrNoDocuments) {
return HandleError(errors.ErrorNodeNotExists)
@@ -96,7 +96,7 @@ func (svr NodeServiceServer) SendHeartbeat(_ context.Context, req *grpc.NodeServ
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
err = service.NewModelService[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return HandleError(err)
}
@@ -116,7 +116,7 @@ func (svr NodeServiceServer) Subscribe(request *grpc.NodeServiceSubscribeRequest
log.Infof("[NodeServiceServer] master received subscribe request from node[%s]", request.NodeKey)
// find in db
node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": request.NodeKey}, nil)
node, err := service.NewModelService[models.NodeV2]().GetOne(bson.M{"key": request.NodeKey}, nil)
if err != nil {
log.Errorf("[NodeServiceServer] error getting node: %v", err)
return err

10
core/grpc/server/server.go
View File

@@ -34,7 +34,7 @@ type GrpcServer struct {
// servers
NodeSvr *NodeServiceServer
TaskSvr *TaskServiceServer
ModelBaseServiceSvr *ModelBaseServiceServerV2
ModelBaseServiceSvr *ModelBaseServiceServer
DependencySvr *DependencyServiceServer
MetricSvr *MetricServiceServer
}
@@ -106,10 +106,10 @@ func (svr *GrpcServer) Stop() (err error) {
func (svr *GrpcServer) register() (err error) {
grpc2.RegisterNodeServiceServer(svr.svr, *svr.NodeSvr)
grpc2.RegisterModelBaseServiceV2Server(svr.svr, *svr.ModelBaseServiceSvr)
grpc2.RegisterModelBaseServiceServer(svr.svr, *svr.ModelBaseServiceSvr)
grpc2.RegisterTaskServiceServer(svr.svr, *svr.TaskSvr)
grpc2.RegisterDependencyServiceV2Server(svr.svr, *svr.DependencySvr)
grpc2.RegisterMetricServiceV2Server(svr.svr, *svr.MetricSvr)
grpc2.RegisterDependencyServiceServer(svr.svr, *svr.DependencySvr)
grpc2.RegisterMetricServiceServer(svr.svr, *svr.MetricSvr)
return nil
}
@@ -141,7 +141,7 @@ func NewGrpcServer() (svr *GrpcServer, err error) {
if err != nil {
return nil, err
}
svr.ModelBaseServiceSvr = NewModelBaseServiceV2Server()
svr.ModelBaseServiceSvr = NewModelBaseServiceServer()
svr.TaskSvr, err = NewTaskServiceServer()
if err != nil {
return nil, err

20
core/grpc/server/task_service_server.go
View File

@@ -110,7 +110,7 @@ func (svr TaskServiceServer) FetchTask(ctx context.Context, request *grpc.TaskSe
if nodeKey == "" {
return nil, errors.New("invalid node key")
}
n, err := service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
n, err := service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil {
return nil, trace.TraceError(err)
}
@@ -124,7 +124,7 @@ func (svr TaskServiceServer) FetchTask(ctx context.Context, request *grpc.TaskSe
}
if err := mongo.RunTransactionWithContext(ctx, func(sc mongo2.SessionContext) (err error) {
// fetch task for the given node
t, err := service.NewModelServiceV2[models2.TaskV2]().GetOne(bson.M{
t, err := service.NewModelService[models2.TaskV2]().GetOne(bson.M{
"node_id": n.Id,
"status": constants.TaskStatusPending,
}, opts)
@@ -138,7 +138,7 @@ func (svr TaskServiceServer) FetchTask(ctx context.Context, request *grpc.TaskSe
}
// fetch task for any node
t, err = service.NewModelServiceV2[models2.TaskV2]().GetOne(bson.M{
t, err = service.NewModelService[models2.TaskV2]().GetOne(bson.M{
"node_id": primitive.NilObjectID,
"status": constants.TaskStatusPending,
}, opts)
@@ -177,7 +177,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
var args []any
// task
task, err := service.NewModelServiceV2[models2.TaskV2]().GetById(taskId)
task, err := service.NewModelService[models2.TaskV2]().GetById(taskId)
if err != nil {
log.Errorf("task not found: %s", request.TaskId)
return nil, trace.TraceError(err)
@@ -185,7 +185,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
args = append(args, task)
// task stat
taskStat, err := service.NewModelServiceV2[models2.TaskStatV2]().GetById(task.Id)
taskStat, err := service.NewModelService[models2.TaskStatV2]().GetById(task.Id)
if err != nil {
log.Errorf("task stat not found for task: %s", request.TaskId)
return nil, trace.TraceError(err)
@@ -193,7 +193,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
args = append(args, taskStat)
// spider
spider, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(task.SpiderId)
spider, err := service.NewModelService[models2.SpiderV2]().GetById(task.SpiderId)
if err != nil {
log.Errorf("spider not found for task: %s", request.TaskId)
return nil, trace.TraceError(err)
@@ -201,7 +201,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
args = append(args, spider)
// node
node, err := service.NewModelServiceV2[models2.NodeV2]().GetById(task.NodeId)
node, err := service.NewModelService[models2.NodeV2]().GetById(task.NodeId)
if err != nil {
return nil, trace.TraceError(err)
}
@@ -210,7 +210,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
// schedule
var schedule *models2.ScheduleV2
if !task.ScheduleId.IsZero() {
schedule, err = service.NewModelServiceV2[models2.ScheduleV2]().GetById(task.ScheduleId)
schedule, err = service.NewModelService[models2.ScheduleV2]().GetById(task.ScheduleId)
if err != nil {
log.Errorf("schedule not found for task: %s", request.TaskId)
return nil, trace.TraceError(err)
@@ -219,7 +219,7 @@ func (svr TaskServiceServer) SendNotification(_ context.Context, request *grpc.T
}
// settings
settings, err := service.NewModelServiceV2[models2.NotificationSettingV2]().GetMany(bson.M{
settings, err := service.NewModelService[models2.NotificationSettingV2]().GetMany(bson.M{
"enabled": true,
"trigger": bson.M{
"$regex": constants.NotificationTriggerPatternTask,
@@ -288,7 +288,7 @@ func (svr TaskServiceServer) handleInsertLogs(taskId primitive.ObjectID, msg *gr
func (svr TaskServiceServer) saveTask(t *models2.TaskV2) (err error) {
t.SetUpdated(t.CreatedBy)
return service.NewModelServiceV2[models2.TaskV2]().ReplaceById(t.Id, *t)
return service.NewModelService[models2.TaskV2]().ReplaceById(t.Id, *t)
}
func NewTaskServiceServer() (res *TaskServiceServer, err error) {

2
core/middlewares/auth_v2.go
View File

@@ -17,7 +17,7 @@ func AuthorizationMiddlewareV2() gin.HandlerFunc {
return func(c *gin.Context) {
// disable auth for test
if viper.GetBool("auth.disabled") {
u, err := service.NewModelServiceV2[models.UserV2]().GetOne(bson.M{"username": constants.DefaultAdminUsername}, nil)
u, err := service.NewModelService[models.UserV2]().GetOne(bson.M{"username": constants.DefaultAdminUsername}, nil)
if err != nil {
utils.HandleErrorInternalServerError(c, err)
return

72
core/models/client/model_service_v2.go → core/models/client/model_service.go
View File

@@ -19,16 +19,16 @@ var (
mu sync.Mutex
)
type ModelServiceV2[T any] struct {
type ModelService[T any] struct {
cfg interfaces.NodeConfigService
c *client.GrpcClient
modelType string
}
func (svc *ModelServiceV2[T]) GetById(id primitive.ObjectID) (model *T, err error) {
func (svc *ModelService[T]) GetById(id primitive.ObjectID) (model *T, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
res, err := svc.c.ModelBaseServiceV2Client.GetById(ctx, &grpc.ModelServiceV2GetByIdRequest{
res, err := svc.c.ModelBaseServiceClient.GetById(ctx, &grpc.ModelServiceGetByIdRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Id: id.Hex(),
@@ -39,7 +39,7 @@ func (svc *ModelServiceV2[T]) GetById(id primitive.ObjectID) (model *T, err erro
return svc.deserializeOne(res)
}
func (svc *ModelServiceV2[T]) GetOne(query bson.M, options *mongo.FindOptions) (model *T, err error) {
func (svc *ModelService[T]) GetOne(query bson.M, options *mongo.FindOptions) (model *T, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
@@ -50,7 +50,7 @@ func (svc *ModelServiceV2[T]) GetOne(query bson.M, options *mongo.FindOptions) (
if err != nil {
return nil, err
}
res, err := svc.c.ModelBaseServiceV2Client.GetOne(ctx, &grpc.ModelServiceV2GetOneRequest{
res, err := svc.c.ModelBaseServiceClient.GetOne(ctx, &grpc.ModelServiceGetOneRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -62,7 +62,7 @@ func (svc *ModelServiceV2[T]) GetOne(query bson.M, options *mongo.FindOptions) (
return svc.deserializeOne(res)
}
func (svc *ModelServiceV2[T]) GetMany(query bson.M, options *mongo.FindOptions) (models []T, err error) {
func (svc *ModelService[T]) GetMany(query bson.M, options *mongo.FindOptions) (models []T, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
@@ -73,7 +73,7 @@ func (svc *ModelServiceV2[T]) GetMany(query bson.M, options *mongo.FindOptions)
if err != nil {
return nil, err
}
res, err := svc.c.ModelBaseServiceV2Client.GetMany(ctx, &grpc.ModelServiceV2GetManyRequest{
res, err := svc.c.ModelBaseServiceClient.GetMany(ctx, &grpc.ModelServiceGetManyRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -85,10 +85,10 @@ func (svc *ModelServiceV2[T]) GetMany(query bson.M, options *mongo.FindOptions)
return svc.deserializeMany(res)
}
func (svc *ModelServiceV2[T]) DeleteById(id primitive.ObjectID) (err error) {
func (svc *ModelService[T]) DeleteById(id primitive.ObjectID) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
_, err = svc.c.ModelBaseServiceV2Client.DeleteById(ctx, &grpc.ModelServiceV2DeleteByIdRequest{
_, err = svc.c.ModelBaseServiceClient.DeleteById(ctx, &grpc.ModelServiceDeleteByIdRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Id: id.Hex(),
@@ -99,14 +99,14 @@ func (svc *ModelServiceV2[T]) DeleteById(id primitive.ObjectID) (err error) {
return nil
}
func (svc *ModelServiceV2[T]) DeleteOne(query bson.M) (err error) {
func (svc *ModelService[T]) DeleteOne(query bson.M) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.DeleteOne(ctx, &grpc.ModelServiceV2DeleteOneRequest{
_, err = svc.c.ModelBaseServiceClient.DeleteOne(ctx, &grpc.ModelServiceDeleteOneRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -117,14 +117,14 @@ func (svc *ModelServiceV2[T]) DeleteOne(query bson.M) (err error) {
return nil
}
func (svc *ModelServiceV2[T]) DeleteMany(query bson.M) (err error) {
func (svc *ModelService[T]) DeleteMany(query bson.M) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.DeleteMany(ctx, &grpc.ModelServiceV2DeleteManyRequest{
_, err = svc.c.ModelBaseServiceClient.DeleteMany(ctx, &grpc.ModelServiceDeleteManyRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -135,14 +135,14 @@ func (svc *ModelServiceV2[T]) DeleteMany(query bson.M) (err error) {
return nil
}
func (svc *ModelServiceV2[T]) UpdateById(id primitive.ObjectID, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateById(id primitive.ObjectID, update bson.M) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
updateData, err := json.Marshal(update)
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.UpdateById(ctx, &grpc.ModelServiceV2UpdateByIdRequest{
_, err = svc.c.ModelBaseServiceClient.UpdateById(ctx, &grpc.ModelServiceUpdateByIdRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Id: id.Hex(),
@@ -154,7 +154,7 @@ func (svc *ModelServiceV2[T]) UpdateById(id primitive.ObjectID, update bson.M) (
return nil
}
func (svc *ModelServiceV2[T]) UpdateOne(query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateOne(query bson.M, update bson.M) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
@@ -165,7 +165,7 @@ func (svc *ModelServiceV2[T]) UpdateOne(query bson.M, update bson.M) (err error)
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.UpdateOne(ctx, &grpc.ModelServiceV2UpdateOneRequest{
_, err = svc.c.ModelBaseServiceClient.UpdateOne(ctx, &grpc.ModelServiceUpdateOneRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -177,7 +177,7 @@ func (svc *ModelServiceV2[T]) UpdateOne(query bson.M, update bson.M) (err error)
return nil
}
func (svc *ModelServiceV2[T]) UpdateMany(query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateMany(query bson.M, update bson.M) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
@@ -188,7 +188,7 @@ func (svc *ModelServiceV2[T]) UpdateMany(query bson.M, update bson.M) (err error
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.UpdateMany(ctx, &grpc.ModelServiceV2UpdateManyRequest{
_, err = svc.c.ModelBaseServiceClient.UpdateMany(ctx, &grpc.ModelServiceUpdateManyRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -197,14 +197,14 @@ func (svc *ModelServiceV2[T]) UpdateMany(query bson.M, update bson.M) (err error
return nil
}
func (svc *ModelServiceV2[T]) ReplaceById(id primitive.ObjectID, model T) (err error) {
func (svc *ModelService[T]) ReplaceById(id primitive.ObjectID, model T) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
modelData, err := json.Marshal(model)
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.ReplaceById(ctx, &grpc.ModelServiceV2ReplaceByIdRequest{
_, err = svc.c.ModelBaseServiceClient.ReplaceById(ctx, &grpc.ModelServiceReplaceByIdRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Id: id.Hex(),
@@ -216,7 +216,7 @@ func (svc *ModelServiceV2[T]) ReplaceById(id primitive.ObjectID, model T) (err e
return nil
}
func (svc *ModelServiceV2[T]) ReplaceOne(query bson.M, model T) (err error) {
func (svc *ModelService[T]) ReplaceOne(query bson.M, model T) (err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
@@ -227,7 +227,7 @@ func (svc *ModelServiceV2[T]) ReplaceOne(query bson.M, model T) (err error) {
if err != nil {
return err
}
_, err = svc.c.ModelBaseServiceV2Client.ReplaceOne(ctx, &grpc.ModelServiceV2ReplaceOneRequest{
_, err = svc.c.ModelBaseServiceClient.ReplaceOne(ctx, &grpc.ModelServiceReplaceOneRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -239,14 +239,14 @@ func (svc *ModelServiceV2[T]) ReplaceOne(query bson.M, model T) (err error) {
return nil
}
func (svc *ModelServiceV2[T]) InsertOne(model T) (id primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertOne(model T) (id primitive.ObjectID, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
modelData, err := json.Marshal(model)
if err != nil {
return primitive.NilObjectID, err
}
res, err := svc.c.ModelBaseServiceV2Client.InsertOne(ctx, &grpc.ModelServiceV2InsertOneRequest{
res, err := svc.c.ModelBaseServiceClient.InsertOne(ctx, &grpc.ModelServiceInsertOneRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Model: modelData,
@@ -262,14 +262,14 @@ func (svc *ModelServiceV2[T]) InsertOne(model T) (id primitive.ObjectID, err err
//return primitive.ObjectIDFromHex(idStr)
}
func (svc *ModelServiceV2[T]) InsertMany(models []T) (ids []primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertMany(models []T) (ids []primitive.ObjectID, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
modelsData, err := json.Marshal(models)
if err != nil {
return nil, err
}
res, err := svc.c.ModelBaseServiceV2Client.InsertMany(ctx, &grpc.ModelServiceV2InsertManyRequest{
res, err := svc.c.ModelBaseServiceClient.InsertMany(ctx, &grpc.ModelServiceInsertManyRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Models: modelsData,
@@ -280,14 +280,14 @@ func (svc *ModelServiceV2[T]) InsertMany(models []T) (ids []primitive.ObjectID,
return deserialize[[]primitive.ObjectID](res)
}
func (svc *ModelServiceV2[T]) Count(query bson.M) (total int, err error) {
func (svc *ModelService[T]) Count(query bson.M) (total int, err error) {
ctx, cancel := svc.c.Context()
defer cancel()
queryData, err := json.Marshal(query)
if err != nil {
return 0, err
}
res, err := svc.c.ModelBaseServiceV2Client.Count(ctx, &grpc.ModelServiceV2CountRequest{
res, err := svc.c.ModelBaseServiceClient.Count(ctx, &grpc.ModelServiceCountRequest{
NodeKey: svc.cfg.GetNodeKey(),
ModelType: svc.modelType,
Query: queryData,
@@ -298,11 +298,11 @@ func (svc *ModelServiceV2[T]) Count(query bson.M) (total int, err error) {
return deserialize[int](res)
}
func (svc *ModelServiceV2[T]) GetCol() (col *mongo.Col) {
func (svc *ModelService[T]) GetCol() (col *mongo.Col) {
return nil
}
func (svc *ModelServiceV2[T]) deserializeOne(res *grpc.Response) (result *T, err error) {
func (svc *ModelService[T]) deserializeOne(res *grpc.Response) (result *T, err error) {
r, err := deserialize[T](res)
if err != nil {
return nil, err
@@ -310,7 +310,7 @@ func (svc *ModelServiceV2[T]) deserializeOne(res *grpc.Response) (result *T, err
return &r, err
}
func (svc *ModelServiceV2[T]) deserializeMany(res *grpc.Response) (results []T, err error) {
func (svc *ModelService[T]) deserializeMany(res *grpc.Response) (results []T, err error) {
return deserialize[[]T](res)
}
@@ -322,7 +322,7 @@ func deserialize[T any](res *grpc.Response) (result T, err error) {
return result, nil
}
func NewModelServiceV2[T any]() *ModelServiceV2[T] {
func NewModelService[T any]() *ModelService[T] {
mu.Lock()
defer mu.Unlock()
@@ -334,7 +334,7 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
onceMap[typeName] = new(sync.Once)
}
var instance *ModelServiceV2[T]
var instance *ModelService[T]
c := client.GetGrpcClient()
if !c.IsStarted() {
@@ -345,7 +345,7 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
}
onceMap[typeName].Do(func() {
instance = &ModelServiceV2[T]{
instance = &ModelService[T]{
cfg: nodeconfig.GetNodeConfigService(),
c: c,
modelType: typeName,
@@ -353,5 +353,5 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
instanceMap[typeName] = instance
})
return instanceMap[typeName].(*ModelServiceV2[T])
return instanceMap[typeName].(*ModelService[T])
}

80
core/models/client/model_service_v2_test.go → core/models/client/model_service_test.go
View File

@@ -43,7 +43,7 @@ func stopSvr(svr *server.GrpcServer) {
}
}
func TestModelServiceV2_GetById(t *testing.T) {
func TestModelService_GetById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -54,7 +54,7 @@ func TestModelServiceV2_GetById(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -64,14 +64,14 @@ func TestModelServiceV2_GetById(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
res, err := clientSvc.GetById(m.Id)
require.Nil(t, err)
assert.Equal(t, res.Id, m.Id)
assert.Equal(t, res.Name, m.Name)
}
func TestModelServiceV2_GetOne(t *testing.T) {
func TestModelService_GetOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -82,7 +82,7 @@ func TestModelServiceV2_GetOne(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -92,14 +92,14 @@ func TestModelServiceV2_GetOne(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
res, err := clientSvc.GetOne(bson.M{"name": m.Name}, nil)
require.Nil(t, err)
assert.Equal(t, res.Id, m.Id)
assert.Equal(t, res.Name, m.Name)
}
func TestModelServiceV2_GetMany(t *testing.T) {
func TestModelService_GetMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -110,7 +110,7 @@ func TestModelServiceV2_GetMany(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -120,7 +120,7 @@ func TestModelServiceV2_GetMany(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
res, err := clientSvc.GetMany(bson.M{"name": m.Name}, nil)
require.Nil(t, err)
assert.Equal(t, len(res), 1)
@@ -128,7 +128,7 @@ func TestModelServiceV2_GetMany(t *testing.T) {
assert.Equal(t, res[0].Name, m.Name)
}
func TestModelServiceV2_DeleteById(t *testing.T) {
func TestModelService_DeleteById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -139,7 +139,7 @@ func TestModelServiceV2_DeleteById(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -149,7 +149,7 @@ func TestModelServiceV2_DeleteById(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.DeleteById(m.Id)
require.Nil(t, err)
@@ -158,7 +158,7 @@ func TestModelServiceV2_DeleteById(t *testing.T) {
require.Nil(t, res)
}
func TestModelServiceV2_DeleteOne(t *testing.T) {
func TestModelService_DeleteOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -169,7 +169,7 @@ func TestModelServiceV2_DeleteOne(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -179,7 +179,7 @@ func TestModelServiceV2_DeleteOne(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.DeleteOne(bson.M{"name": m.Name})
require.Nil(t, err)
@@ -188,7 +188,7 @@ func TestModelServiceV2_DeleteOne(t *testing.T) {
require.Nil(t, res)
}
func TestModelServiceV2_DeleteMany(t *testing.T) {
func TestModelService_DeleteMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -199,7 +199,7 @@ func TestModelServiceV2_DeleteMany(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -209,7 +209,7 @@ func TestModelServiceV2_DeleteMany(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.DeleteMany(bson.M{"name": m.Name})
require.Nil(t, err)
@@ -218,7 +218,7 @@ func TestModelServiceV2_DeleteMany(t *testing.T) {
assert.Equal(t, len(res), 0)
}
func TestModelServiceV2_UpdateById(t *testing.T) {
func TestModelService_UpdateById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -229,7 +229,7 @@ func TestModelServiceV2_UpdateById(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -239,7 +239,7 @@ func TestModelServiceV2_UpdateById(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.UpdateById(m.Id, bson.M{"$set": bson.M{"name": "New Name"}})
require.Nil(t, err)
@@ -248,7 +248,7 @@ func TestModelServiceV2_UpdateById(t *testing.T) {
assert.Equal(t, res.Name, "New Name")
}
func TestModelServiceV2_UpdateOne(t *testing.T) {
func TestModelService_UpdateOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -259,7 +259,7 @@ func TestModelServiceV2_UpdateOne(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -269,7 +269,7 @@ func TestModelServiceV2_UpdateOne(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.UpdateOne(bson.M{"name": m.Name}, bson.M{"$set": bson.M{"name": "New Name"}})
require.Nil(t, err)
@@ -278,7 +278,7 @@ func TestModelServiceV2_UpdateOne(t *testing.T) {
assert.Equal(t, res.Name, "New Name")
}
func TestModelServiceV2_UpdateMany(t *testing.T) {
func TestModelService_UpdateMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -292,7 +292,7 @@ func TestModelServiceV2_UpdateMany(t *testing.T) {
m2 := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
_, err = modelSvc.InsertOne(m1)
require.Nil(t, err)
_, err = modelSvc.InsertOne(m2)
@@ -303,7 +303,7 @@ func TestModelServiceV2_UpdateMany(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
err = clientSvc.UpdateMany(bson.M{"name": "Test Name"}, bson.M{"$set": bson.M{"name": "New Name"}})
require.Nil(t, err)
@@ -312,7 +312,7 @@ func TestModelServiceV2_UpdateMany(t *testing.T) {
assert.Equal(t, len(res), 2)
}
func TestModelServiceV2_ReplaceById(t *testing.T) {
func TestModelService_ReplaceById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -323,7 +323,7 @@ func TestModelServiceV2_ReplaceById(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -333,7 +333,7 @@ func TestModelServiceV2_ReplaceById(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
m.Name = "New Name"
err = clientSvc.ReplaceById(m.Id, m)
require.Nil(t, err)
@@ -343,7 +343,7 @@ func TestModelServiceV2_ReplaceById(t *testing.T) {
assert.Equal(t, res.Name, "New Name")
}
func TestModelServiceV2_ReplaceOne(t *testing.T) {
func TestModelService_ReplaceOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -354,7 +354,7 @@ func TestModelServiceV2_ReplaceOne(t *testing.T) {
m := models.TestModelV2{
Name: "Test Name",
}
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
id, err := modelSvc.InsertOne(m)
require.Nil(t, err)
m.SetId(id)
@@ -364,7 +364,7 @@ func TestModelServiceV2_ReplaceOne(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
m.Name = "New Name"
err = clientSvc.ReplaceOne(bson.M{"name": "Test Name"}, m)
require.Nil(t, err)
@@ -374,7 +374,7 @@ func TestModelServiceV2_ReplaceOne(t *testing.T) {
assert.Equal(t, res.Name, "New Name")
}
func TestModelServiceV2_InsertOne(t *testing.T) {
func TestModelService_InsertOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -386,7 +386,7 @@ func TestModelServiceV2_InsertOne(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
m := models.TestModelV2{
Name: "Test Name",
}
@@ -398,7 +398,7 @@ func TestModelServiceV2_InsertOne(t *testing.T) {
assert.Equal(t, res.Name, m.Name)
}
func TestModelServiceV2_InsertMany(t *testing.T) {
func TestModelService_InsertMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -410,7 +410,7 @@ func TestModelServiceV2_InsertMany(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
testModels := []models.TestModelV2{
{Name: "Test Name 1"},
{Name: "Test Name 2"},
@@ -425,7 +425,7 @@ func TestModelServiceV2_InsertMany(t *testing.T) {
}
}
func TestModelServiceV2_Count(t *testing.T) {
func TestModelService_Count(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svr, err := server.NewGrpcServer()
@@ -433,7 +433,7 @@ func TestModelServiceV2_Count(t *testing.T) {
go startSvr(svr)
defer stopSvr(svr)
modelSvc := service.NewModelServiceV2[models.TestModelV2]()
modelSvc := service.NewModelService[models.TestModelV2]()
for i := 0; i < 5; i++ {
_, err = modelSvc.InsertOne(models.TestModelV2{
Name: "Test Name",
@@ -446,7 +446,7 @@ func TestModelServiceV2_Count(t *testing.T) {
require.Nil(t, err)
c.Connect()
clientSvc := client.NewModelServiceV2[models.TestModelV2]()
clientSvc := client.NewModelService[models.TestModelV2]()
count, err := clientSvc.Count(bson.M{})
require.Nil(t, err)

76
core/models/service/base_service_v2.go → core/models/service/base_service.go
View File

@@ -20,11 +20,11 @@ var (
mu sync.Mutex
)
type ModelServiceV2[T any] struct {
type ModelService[T any] struct {
col *mongo.Col
}
func (svc *ModelServiceV2[T]) GetById(id primitive.ObjectID) (model *T, err error) {
func (svc *ModelService[T]) GetById(id primitive.ObjectID) (model *T, err error) {
var result T
err = svc.col.FindId(id).One(&result)
if err != nil {
@@ -33,7 +33,7 @@ func (svc *ModelServiceV2[T]) GetById(id primitive.ObjectID) (model *T, err erro
return &result, nil
}
func (svc *ModelServiceV2[T]) GetByIdContext(ctx context.Context, id primitive.ObjectID) (model *T, err error) {
func (svc *ModelService[T]) GetByIdContext(ctx context.Context, id primitive.ObjectID) (model *T, err error) {
var result T
err = svc.col.GetCollection().FindOne(ctx, bson.M{"_id": id}).Decode(&result)
if err != nil {
@@ -42,7 +42,7 @@ func (svc *ModelServiceV2[T]) GetByIdContext(ctx context.Context, id primitive.O
return &result, nil
}
func (svc *ModelServiceV2[T]) GetOne(query bson.M, options *mongo.FindOptions) (model *T, err error) {
func (svc *ModelService[T]) GetOne(query bson.M, options *mongo.FindOptions) (model *T, err error) {
var result T
err = svc.col.Find(query, options).One(&result)
if err != nil {
@@ -51,7 +51,7 @@ func (svc *ModelServiceV2[T]) GetOne(query bson.M, options *mongo.FindOptions) (
return &result, nil
}
func (svc *ModelServiceV2[T]) GetOneContext(ctx context.Context, query bson.M, opts *mongo.FindOptions) (model *T, err error) {
func (svc *ModelService[T]) GetOneContext(ctx context.Context, query bson.M, opts *mongo.FindOptions) (model *T, err error) {
var result T
_opts := &options.FindOneOptions{}
if opts != nil {
@@ -70,7 +70,7 @@ func (svc *ModelServiceV2[T]) GetOneContext(ctx context.Context, query bson.M, o
return &result, nil
}
func (svc *ModelServiceV2[T]) GetMany(query bson.M, options *mongo.FindOptions) (models []T, err error) {
func (svc *ModelService[T]) GetMany(query bson.M, options *mongo.FindOptions) (models []T, err error) {
var result []T
err = svc.col.Find(query, options).All(&result)
if err != nil {
@@ -79,7 +79,7 @@ func (svc *ModelServiceV2[T]) GetMany(query bson.M, options *mongo.FindOptions)
return result, nil
}
func (svc *ModelServiceV2[T]) GetManyContext(ctx context.Context, query bson.M, opts *mongo.FindOptions) (models []T, err error) {
func (svc *ModelService[T]) GetManyContext(ctx context.Context, query bson.M, opts *mongo.FindOptions) (models []T, err error) {
var result []T
_opts := &options.FindOptions{}
if opts != nil {
@@ -110,85 +110,85 @@ func (svc *ModelServiceV2[T]) GetManyContext(ctx context.Context, query bson.M,
return result, nil
}
func (svc *ModelServiceV2[T]) DeleteById(id primitive.ObjectID) (err error) {
func (svc *ModelService[T]) DeleteById(id primitive.ObjectID) (err error) {
return svc.col.DeleteId(id)
}
func (svc *ModelServiceV2[T]) DeleteByIdContext(ctx context.Context, id primitive.ObjectID) (err error) {
func (svc *ModelService[T]) DeleteByIdContext(ctx context.Context, id primitive.ObjectID) (err error) {
_, err = svc.col.GetCollection().DeleteOne(ctx, bson.M{"_id": id})
return err
}
func (svc *ModelServiceV2[T]) DeleteOne(query bson.M) (err error) {
func (svc *ModelService[T]) DeleteOne(query bson.M) (err error) {
_, err = svc.col.GetCollection().DeleteOne(svc.col.GetContext(), query)
return err
}
func (svc *ModelServiceV2[T]) DeleteOneContext(ctx context.Context, query bson.M) (err error) {
func (svc *ModelService[T]) DeleteOneContext(ctx context.Context, query bson.M) (err error) {
_, err = svc.col.GetCollection().DeleteOne(ctx, query)
return err
}
func (svc *ModelServiceV2[T]) DeleteMany(query bson.M) (err error) {
func (svc *ModelService[T]) DeleteMany(query bson.M) (err error) {
_, err = svc.col.GetCollection().DeleteMany(svc.col.GetContext(), query, nil)
return err
}
func (svc *ModelServiceV2[T]) DeleteManyContext(ctx context.Context, query bson.M) (err error) {
func (svc *ModelService[T]) DeleteManyContext(ctx context.Context, query bson.M) (err error) {
_, err = svc.col.GetCollection().DeleteMany(ctx, query, nil)
return err
}
func (svc *ModelServiceV2[T]) UpdateById(id primitive.ObjectID, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateById(id primitive.ObjectID, update bson.M) (err error) {
return svc.col.UpdateId(id, update)
}
func (svc *ModelServiceV2[T]) UpdateByIdContext(ctx context.Context, id primitive.ObjectID, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateByIdContext(ctx context.Context, id primitive.ObjectID, update bson.M) (err error) {
_, err = svc.col.GetCollection().UpdateOne(ctx, bson.M{"_id": id}, update)
return err
}
func (svc *ModelServiceV2[T]) UpdateOne(query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateOne(query bson.M, update bson.M) (err error) {
_, err = svc.col.GetCollection().UpdateOne(svc.col.GetContext(), query, update)
return err
}
func (svc *ModelServiceV2[T]) UpdateOneContext(ctx context.Context, query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateOneContext(ctx context.Context, query bson.M, update bson.M) (err error) {
_, err = svc.col.GetCollection().UpdateOne(ctx, query, update)
return err
}
func (svc *ModelServiceV2[T]) UpdateMany(query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateMany(query bson.M, update bson.M) (err error) {
_, err = svc.col.GetCollection().UpdateMany(svc.col.GetContext(), query, update)
return err
}
func (svc *ModelServiceV2[T]) UpdateManyContext(ctx context.Context, query bson.M, update bson.M) (err error) {
func (svc *ModelService[T]) UpdateManyContext(ctx context.Context, query bson.M, update bson.M) (err error) {
_, err = svc.col.GetCollection().UpdateMany(ctx, query, update)
return err
}
func (svc *ModelServiceV2[T]) ReplaceById(id primitive.ObjectID, model T) (err error) {
func (svc *ModelService[T]) ReplaceById(id primitive.ObjectID, model T) (err error) {
_, err = svc.col.GetCollection().ReplaceOne(svc.col.GetContext(), bson.M{"_id": id}, model)
return err
}
func (svc *ModelServiceV2[T]) ReplaceByIdContext(ctx context.Context, id primitive.ObjectID, model T) (err error) {
func (svc *ModelService[T]) ReplaceByIdContext(ctx context.Context, id primitive.ObjectID, model T) (err error) {
_, err = svc.col.GetCollection().ReplaceOne(ctx, bson.M{"_id": id}, model)
return err
}
func (svc *ModelServiceV2[T]) ReplaceOne(query bson.M, model T) (err error) {
func (svc *ModelService[T]) ReplaceOne(query bson.M, model T) (err error) {
_, err = svc.col.GetCollection().ReplaceOne(svc.col.GetContext(), query, model)
return err
}
func (svc *ModelServiceV2[T]) ReplaceOneContext(ctx context.Context, query bson.M, model T) (err error) {
func (svc *ModelService[T]) ReplaceOneContext(ctx context.Context, query bson.M, model T) (err error) {
_, err = svc.col.GetCollection().ReplaceOne(ctx, query, model)
return err
}
func (svc *ModelServiceV2[T]) InsertOne(model T) (id primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertOne(model T) (id primitive.ObjectID, err error) {
m := any(&model).(interfaces.Model)
if m.GetId().IsZero() {
m.SetId(primitive.NewObjectID())
@@ -200,7 +200,7 @@ func (svc *ModelServiceV2[T]) InsertOne(model T) (id primitive.ObjectID, err err
return res.InsertedID.(primitive.ObjectID), nil
}
func (svc *ModelServiceV2[T]) InsertOneContext(ctx context.Context, model T) (id primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertOneContext(ctx context.Context, model T) (id primitive.ObjectID, err error) {
m := any(&model).(interfaces.Model)
if m.GetId().IsZero() {
m.SetId(primitive.NewObjectID())
@@ -212,7 +212,7 @@ func (svc *ModelServiceV2[T]) InsertOneContext(ctx context.Context, model T) (id
return res.InsertedID.(primitive.ObjectID), nil
}
func (svc *ModelServiceV2[T]) InsertMany(models []T) (ids []primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertMany(models []T) (ids []primitive.ObjectID, err error) {
var _models []any
for _, model := range models {
m := any(&model).(interfaces.Model)
@@ -231,7 +231,7 @@ func (svc *ModelServiceV2[T]) InsertMany(models []T) (ids []primitive.ObjectID,
return ids, nil
}
func (svc *ModelServiceV2[T]) InsertManyContext(ctx context.Context, models []T) (ids []primitive.ObjectID, err error) {
func (svc *ModelService[T]) InsertManyContext(ctx context.Context, models []T) (ids []primitive.ObjectID, err error) {
var _models []any
for _, model := range models {
m := any(&model).(interfaces.Model)
@@ -250,11 +250,11 @@ func (svc *ModelServiceV2[T]) InsertManyContext(ctx context.Context, models []T)
return ids, nil
}
func (svc *ModelServiceV2[T]) Count(query bson.M) (total int, err error) {
func (svc *ModelService[T]) Count(query bson.M) (total int, err error) {
return svc.col.Count(query)
}
func (svc *ModelServiceV2[T]) GetCol() (col *mongo.Col) {
func (svc *ModelService[T]) GetCol() (col *mongo.Col) {
return svc.col
}
@@ -271,8 +271,8 @@ func getCollectionName[T any]() string {
return field.Tag.Get("collection")
}
// NewModelServiceV2 return singleton instance of ModelServiceV2
func NewModelServiceV2[T any]() *ModelServiceV2[T] {
// NewModelService return singleton instance of ModelService
func NewModelService[T any]() *ModelService[T] {
typeName := fmt.Sprintf("%T", *new(T))
mu.Lock()
@@ -282,19 +282,19 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
onceMap[typeName] = new(sync.Once)
}
var instance *ModelServiceV2[T]
var instance *ModelService[T]
onceMap[typeName].Do(func() {
collectionName := getCollectionName[T]()
collection := mongo.GetMongoCol(collectionName)
instance = &ModelServiceV2[T]{col: collection}
instance = &ModelService[T]{col: collection}
instanceMap[typeName] = instance
})
return instanceMap[typeName].(*ModelServiceV2[T])
return instanceMap[typeName].(*ModelService[T])
}
func NewModelServiceV2WithColName[T any](colName string) *ModelServiceV2[T] {
func NewModelServiceWithColName[T any](colName string) *ModelService[T] {
mu.Lock()
defer mu.Unlock()
@@ -302,13 +302,13 @@ func NewModelServiceV2WithColName[T any](colName string) *ModelServiceV2[T] {
onceColNameMap[colName] = new(sync.Once)
}
var instance *ModelServiceV2[T]
var instance *ModelService[T]
onceColNameMap[colName].Do(func() {
collection := mongo.GetMongoCol(colName)
instance = &ModelServiceV2[T]{col: collection}
instance = &ModelService[T]{col: collection}
instanceMap[colName] = instance
})
return instanceMap[colName].(*ModelServiceV2[T])
return instanceMap[colName].(*ModelService[T])
}

24
core/models/service/base_service_v2_test.go → core/models/service/base_service_test.go
View File

@@ -41,7 +41,7 @@ func TestModelServiceV2(t *testing.T) {
defer teardownTestDB()
t.Run("GetById", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "GetById Test"}
id, err := svc.InsertOne(testModel)
@@ -54,7 +54,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("GetOne", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "GetOne Test"}
_, err := svc.InsertOne(testModel)
@@ -67,7 +67,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("GetMany", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModels := []TestModel{
{Name: "GetMany Test 1"},
{Name: "GetMany Test 2"},
@@ -83,7 +83,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("InsertOne", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "InsertOne Test"}
id, err := svc.InsertOne(testModel)
@@ -92,7 +92,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("InsertMany", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModels := []TestModel{
{Name: "InsertMany Test 1"},
{Name: "InsertMany Test 2"},
@@ -104,7 +104,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("UpdateById", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "UpdateById Test"}
id, err := svc.InsertOne(testModel)
@@ -122,7 +122,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("UpdateOne", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "UpdateOne Test"}
_, err := svc.InsertOne(testModel)
@@ -140,7 +140,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("UpdateMany", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModels := []TestModel{
{Name: "UpdateMany Test 1"},
{Name: "UpdateMany Test 2"},
@@ -161,7 +161,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("DeleteById", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "DeleteById Test"}
id, err := svc.InsertOne(testModel)
@@ -178,7 +178,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("DeleteOne", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModel := TestModel{Name: "DeleteOne Test"}
_, err := svc.InsertOne(testModel)
@@ -195,7 +195,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("DeleteMany", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModels := []TestModel{
{Name: "DeleteMany Test 1"},
{Name: "DeleteMany Test 2"},
@@ -215,7 +215,7 @@ func TestModelServiceV2(t *testing.T) {
})
t.Run("Count", func(t *testing.T) {
svc := service.NewModelServiceV2[TestModel]()
svc := service.NewModelService[TestModel]()
testModels := []TestModel{
{Name: "Count Test 1"},
{Name: "Count Test 2"},

18
core/node/service/master_service.go
View File

@@ -133,7 +133,7 @@ func (svc *MasterService) SetMonitorInterval(duration time.Duration) {
func (svc *MasterService) Register() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
nodeName := svc.GetConfigService().GetNodeName()
node, err := service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
node, err := service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil && err.Error() == mongo2.ErrNoDocuments.Error() {
// not exists
log.Infof("master[%s] does not exist in db", nodeKey)
@@ -149,7 +149,7 @@ func (svc *MasterService) Register() (err error) {
}
node.SetCreated(primitive.NilObjectID)
node.SetUpdated(primitive.NilObjectID)
id, err := service.NewModelServiceV2[models2.NodeV2]().InsertOne(node)
id, err := service.NewModelService[models2.NodeV2]().InsertOne(node)
if err != nil {
return err
}
@@ -161,7 +161,7 @@ func (svc *MasterService) Register() (err error) {
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models2.NodeV2]().ReplaceById(node.Id, *node)
err = service.NewModelService[models2.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}
@@ -227,7 +227,7 @@ func (svc *MasterService) getAllWorkerNodes() (nodes []models2.NodeV2, err error
"key": bson.M{"$ne": svc.cfgSvc.GetNodeKey()}, // not self
"active": true, // active
}
nodes, err = service.NewModelServiceV2[models2.NodeV2]().GetMany(query, nil)
nodes, err = service.NewModelService[models2.NodeV2]().GetMany(query, nil)
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
return nil, nil
@@ -239,7 +239,7 @@ func (svc *MasterService) getAllWorkerNodes() (nodes []models2.NodeV2, err error
func (svc *MasterService) updateMasterNodeStatus() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
node, err := service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
node, err := service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil {
return err
}
@@ -250,7 +250,7 @@ func (svc *MasterService) updateMasterNodeStatus() (err error) {
node.ActiveAt = time.Now()
newStatus := node.Status
err = service.NewModelServiceV2[models2.NodeV2]().ReplaceById(node.Id, *node)
err = service.NewModelService[models2.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}
@@ -268,7 +268,7 @@ func (svc *MasterService) setWorkerNodeOffline(node *models2.NodeV2) {
node.Status = constants.NodeStatusOffline
node.Active = false
err := backoff.Retry(func() error {
return service.NewModelServiceV2[models2.NodeV2]().ReplaceById(node.Id, *node)
return service.NewModelService[models2.NodeV2]().ReplaceById(node.Id, *node)
}, backoff.WithMaxRetries(backoff.NewConstantBackOff(1*time.Second), 3))
if err != nil {
trace.PrintError(err)
@@ -302,12 +302,12 @@ func (svc *MasterService) updateNodeAvailableRunners(node *models2.NodeV2) (err
"node_id": node.Id,
"status": constants.TaskStatusRunning,
}
runningTasksCount, err := service.NewModelServiceV2[models2.TaskV2]().Count(query)
runningTasksCount, err := service.NewModelService[models2.TaskV2]().Count(query)
if err != nil {
return trace.TraceError(err)
}
node.AvailableRunners = node.MaxRunners - runningTasksCount
err = service.NewModelServiceV2[models2.NodeV2]().ReplaceById(node.Id, *node)
err = service.NewModelService[models2.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}

2
core/node/service/worker_service.go
View File

@@ -90,7 +90,7 @@ func (svc *WorkerService) register() {
log.Fatalf("failed to register worker[%s] to master: %v", svc.cfgSvc.GetNodeKey(), err)
panic(err)
}
svc.n, err = client2.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": svc.GetConfigService().GetNodeKey()}, nil)
svc.n, err = client2.NewModelService[models.NodeV2]().GetOne(bson.M{"key": svc.GetConfigService().GetNodeKey()}, nil)
if err != nil {
log.Fatalf("failed to get node: %v", err)
panic(err)

10
core/notification/service_v2.go
View File

@@ -28,7 +28,7 @@ func (svc *ServiceV2) Send(s *models.NotificationSettingV2, args ...any) {
for _, chId := range s.ChannelIds {
go func(chId primitive.ObjectID) {
defer wg.Done()
ch, err := service.NewModelServiceV2[models.NotificationChannelV2]().GetById(chId)
ch, err := service.NewModelService[models.NotificationChannelV2]().GetById(chId)
if err != nil {
log.Errorf("[NotificationServiceV2] get channel error: %v", err)
return
@@ -362,7 +362,7 @@ func (svc *ServiceV2) getUsernameById(id primitive.ObjectID) (username string) {
if id.IsZero() {
return ""
}
u, err := service.NewModelServiceV2[models.UserV2]().GetById(id)
u, err := service.NewModelService[models.UserV2]().GetById(id)
if err != nil {
log.Errorf("[NotificationServiceV2] get user error: %v", err)
return ""
@@ -434,7 +434,7 @@ func (svc *ServiceV2) SendNodeNotification(node *models.NodeV2) {
args = append(args, node)
// settings
settings, err := service.NewModelServiceV2[models.NotificationSettingV2]().GetMany(bson.M{
settings, err := service.NewModelService[models.NotificationSettingV2]().GetMany(bson.M{
"enabled": true,
"trigger": bson.M{
"$regex": constants.NotificationTriggerPatternNode,
@@ -482,7 +482,7 @@ func (svc *ServiceV2) createRequest(s *models.NotificationSettingV2, ch *models.
}
r.SetCreatedAt(time.Now())
r.SetUpdatedAt(time.Now())
r.Id, err = service.NewModelServiceV2[models.NotificationRequestV2]().InsertOne(r)
r.Id, err = service.NewModelService[models.NotificationRequestV2]().InsertOne(r)
if err != nil {
log.Errorf("[NotificationServiceV2] save request error: %v", err)
return nil, err
@@ -502,7 +502,7 @@ func (svc *ServiceV2) saveRequest(r *models.NotificationRequestV2, err error) {
r.Status = StatusSuccess
}
r.SetUpdatedAt(time.Now())
err = service.NewModelServiceV2[models.NotificationRequestV2]().ReplaceById(r.Id, *r)
err = service.NewModelService[models.NotificationRequestV2]().ReplaceById(r.Id, *r)
if err != nil {
log.Errorf("[NotificationServiceV2] save request error: %v", err)
}

6
core/schedule/service_v2.go
View File

@@ -19,7 +19,7 @@ import (
type ServiceV2 struct {
// dependencies
interfaces.WithConfigPath
modelSvc *service.ModelServiceV2[models2.ScheduleV2]
modelSvc *service.ModelService[models2.ScheduleV2]
adminSvc *admin.Service
// settings variables
@@ -191,7 +191,7 @@ func (svc *ServiceV2) schedule(id primitive.ObjectID) (fn func()) {
}
// spider
spider, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(s.SpiderId)
spider, err := service.NewModelService[models2.SpiderV2]().GetById(s.SpiderId)
if err != nil {
trace.PrintError(err)
return
@@ -250,7 +250,7 @@ func NewScheduleServiceV2() (svc2 *ServiceV2, err error) {
if err != nil {
return nil, err
}
svc.modelSvc = service.NewModelServiceV2[models2.ScheduleV2]()
svc.modelSvc = service.NewModelService[models2.ScheduleV2]()
// logger
svc.logger = NewLogger()

6
core/spider/admin/service.go
View File

@@ -28,7 +28,7 @@ type Service struct {
func (svc *Service) Schedule(id primitive.ObjectID, opts *interfaces.SpiderRunOptions) (taskIds []primitive.ObjectID, err error) {
// spider
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err := service.NewModelService[models2.SpiderV2]().GetById(id)
if err != nil {
return nil, err
}
@@ -95,7 +95,7 @@ func (svc *Service) getNodeIds(opts *interfaces.SpiderRunOptions) (nodeIds []pri
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := service.NewModelServiceV2[models2.NodeV2]().GetMany(query, nil)
nodes, err := service.NewModelService[models2.NodeV2]().GetMany(query, nil)
if err != nil {
return nil, err
}
@@ -119,7 +119,7 @@ func (svc *Service) isMultiTask(opts *interfaces.SpiderRunOptions) (res bool) {
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := service.NewModelServiceV2[models2.NodeV2]().GetMany(query, nil)
nodes, err := service.NewModelService[models2.NodeV2]().GetMany(query, nil)
if err != nil {
trace.PrintError(err)
return false

4
core/system/service_v2.go
View File

@@ -20,7 +20,7 @@ func (svc *ServiceV2) Init() (err error) {
}
func (svc *ServiceV2) initData() (err error) {
total, err := service.NewModelServiceV2[models.SettingV2]().Count(bson.M{
total, err := service.NewModelService[models.SettingV2]().Count(bson.M{
"key": "site_title",
})
if err != nil {
@@ -40,7 +40,7 @@ func (svc *ServiceV2) initData() (err error) {
},
},
}
_, err = service.NewModelServiceV2[models.SettingV2]().InsertMany(settings)
_, err = service.NewModelService[models.SettingV2]().InsertMany(settings)
if err != nil {
return err
}

18
core/task/handler/runner.go
View File

@@ -306,7 +306,7 @@ func (r *Runner) configureEnv() {
}
// global environment variables
envs, err := client.NewModelServiceV2[models.EnvironmentV2]().GetMany(nil, nil)
envs, err := client.NewModelService[models.EnvironmentV2]().GetMany(nil, nil)
if err != nil {
trace.PrintError(err)
return
@@ -501,12 +501,12 @@ func (r *Runner) updateTask(status string, e error) (err error) {
r.t.Error = e.Error()
}
if r.svc.GetNodeConfigService().IsMaster() {
err = service.NewModelServiceV2[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
err = service.NewModelService[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
if err != nil {
return err
}
} else {
err = client.NewModelServiceV2[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
err = client.NewModelService[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
if err != nil {
return err
}
@@ -555,7 +555,7 @@ func (r *Runner) writeLogLines(lines []string) {
}
func (r *Runner) _updateTaskStat(status string) {
ts, err := client.NewModelServiceV2[models.TaskStatV2]().GetById(r.tid)
ts, err := client.NewModelService[models.TaskStatV2]().GetById(r.tid)
if err != nil {
trace.PrintError(err)
return
@@ -576,13 +576,13 @@ func (r *Runner) _updateTaskStat(status string) {
ts.TotalDuration = ts.EndTs.Sub(ts.BaseModelV2.CreatedAt).Milliseconds()
}
if r.svc.GetNodeConfigService().IsMaster() {
err = service.NewModelServiceV2[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
err = service.NewModelService[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
if err != nil {
trace.PrintError(err)
return
}
} else {
err = client.NewModelServiceV2[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
err = client.NewModelService[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
if err != nil {
trace.PrintError(err)
return
@@ -605,7 +605,7 @@ func (r *Runner) sendNotification() {
func (r *Runner) _updateSpiderStat(status string) {
// task stat
ts, err := client.NewModelServiceV2[models.TaskStatV2]().GetById(r.tid)
ts, err := client.NewModelService[models.TaskStatV2]().GetById(r.tid)
if err != nil {
trace.PrintError(err)
return
@@ -643,13 +643,13 @@ func (r *Runner) _updateSpiderStat(status string) {
// perform update
if r.svc.GetNodeConfigService().IsMaster() {
err = service.NewModelServiceV2[models.SpiderStatV2]().UpdateById(r.s.Id, update)
err = service.NewModelService[models.SpiderStatV2]().UpdateById(r.s.Id, update)
if err != nil {
trace.PrintError(err)
return
}
} else {
err = client.NewModelServiceV2[models.SpiderStatV2]().UpdateById(r.s.Id, update)
err = client.NewModelService[models.SpiderStatV2]().UpdateById(r.s.Id, update)
if err != nil {
trace.PrintError(err)
return

26
core/task/handler/service.go
View File

@@ -110,7 +110,7 @@ func (svc *Service) fetchAndRunTasks() {
t.Error = err.Error()
t.Status = constants.TaskStatusError
t.SetUpdated(t.CreatedBy)
_ = client.NewModelServiceV2[models2.TaskV2]().ReplaceById(t.Id, *t)
_ = client.NewModelService[models2.TaskV2]().ReplaceById(t.Id, *t)
continue
}
continue
@@ -154,9 +154,9 @@ func (svc *Service) GetCurrentNode() (n *models2.NodeV2, err error) {
// current node
if svc.cfgSvc.IsMaster() {
n, err = service.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
n, err = service.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
} else {
n, err = client.NewModelServiceV2[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
n, err = client.NewModelService[models2.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
}
if err != nil {
return nil, err
@@ -167,9 +167,9 @@ func (svc *Service) GetCurrentNode() (n *models2.NodeV2, err error) {
func (svc *Service) GetTaskById(id primitive.ObjectID) (t *models2.TaskV2, err error) {
if svc.cfgSvc.IsMaster() {
t, err = service.NewModelServiceV2[models2.TaskV2]().GetById(id)
t, err = service.NewModelService[models2.TaskV2]().GetById(id)
} else {
t, err = client.NewModelServiceV2[models2.TaskV2]().GetById(id)
t, err = client.NewModelService[models2.TaskV2]().GetById(id)
}
if err != nil {
return nil, err
@@ -181,9 +181,9 @@ func (svc *Service) GetTaskById(id primitive.ObjectID) (t *models2.TaskV2, err e
func (svc *Service) UpdateTask(t *models2.TaskV2) (err error) {
t.SetUpdated(t.CreatedBy)
if svc.cfgSvc.IsMaster() {
err = service.NewModelServiceV2[models2.TaskV2]().ReplaceById(t.Id, *t)
err = service.NewModelService[models2.TaskV2]().ReplaceById(t.Id, *t)
} else {
err = client.NewModelServiceV2[models2.TaskV2]().ReplaceById(t.Id, *t)
err = client.NewModelService[models2.TaskV2]().ReplaceById(t.Id, *t)
}
if err != nil {
return err
@@ -193,9 +193,9 @@ func (svc *Service) UpdateTask(t *models2.TaskV2) (err error) {
func (svc *Service) GetSpiderById(id primitive.ObjectID) (s *models2.SpiderV2, err error) {
if svc.cfgSvc.IsMaster() {
s, err = service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err = service.NewModelService[models2.SpiderV2]().GetById(id)
} else {
s, err = client.NewModelServiceV2[models2.SpiderV2]().GetById(id)
s, err = client.NewModelService[models2.SpiderV2]().GetById(id)
}
if err != nil {
return nil, err
@@ -217,13 +217,13 @@ func (svc *Service) getRunnerCount() (count int) {
},
}
if svc.cfgSvc.IsMaster() {
count, err = service.NewModelServiceV2[models2.TaskV2]().Count(query)
count, err = service.NewModelService[models2.TaskV2]().Count(query)
if err != nil {
trace.PrintError(err)
return
}
} else {
count, err = client.NewModelServiceV2[models2.TaskV2]().Count(query)
count, err = client.NewModelService[models2.TaskV2]().Count(query)
if err != nil {
trace.PrintError(err)
return
@@ -273,9 +273,9 @@ func (svc *Service) updateNodeStatus() (err error) {
// save node
n.SetUpdated(n.CreatedBy)
if svc.cfgSvc.IsMaster() {
err = service.NewModelServiceV2[models2.NodeV2]().ReplaceById(n.Id, *n)
err = service.NewModelService[models2.NodeV2]().ReplaceById(n.Id, *n)
} else {
err = client.NewModelServiceV2[models2.NodeV2]().ReplaceById(n.Id, *n)
err = client.NewModelService[models2.NodeV2]().ReplaceById(n.Id, *n)
}
if err != nil {
return err

20
core/task/scheduler/service.go
View File

@@ -44,7 +44,7 @@ func (svc *Service) Enqueue(t *models2.TaskV2, by primitive.ObjectID) (t2 *model
t.SetUpdated(by)
// add task
taskModelSvc := service.NewModelServiceV2[models2.TaskV2]()
taskModelSvc := service.NewModelService[models2.TaskV2]()
t.Id, err = taskModelSvc.InsertOne(*t)
if err != nil {
return nil, err
@@ -57,7 +57,7 @@ func (svc *Service) Enqueue(t *models2.TaskV2, by primitive.ObjectID) (t2 *model
ts.SetUpdated(by)
// add task stat
_, err = service.NewModelServiceV2[models2.TaskStatV2]().InsertOne(ts)
_, err = service.NewModelService[models2.TaskStatV2]().InsertOne(ts)
if err != nil {
return nil, trace.TraceError(err)
}
@@ -68,7 +68,7 @@ func (svc *Service) Enqueue(t *models2.TaskV2, by primitive.ObjectID) (t2 *model
func (svc *Service) Cancel(id, by primitive.ObjectID, force bool) (err error) {
// task
t, err := service.NewModelServiceV2[models2.TaskV2]().GetById(id)
t, err := service.NewModelService[models2.TaskV2]().GetById(id)
if err != nil {
log.Errorf("task not found: %s", id.Hex())
return err
@@ -145,18 +145,18 @@ func (svc *Service) SaveTask(t *models2.TaskV2, by primitive.ObjectID) (err erro
if t.Id.IsZero() {
t.SetCreated(by)
t.SetUpdated(by)
_, err = service.NewModelServiceV2[models2.TaskV2]().InsertOne(*t)
_, err = service.NewModelService[models2.TaskV2]().InsertOne(*t)
return err
} else {
t.SetUpdated(by)
return service.NewModelServiceV2[models2.TaskV2]().ReplaceById(t.Id, *t)
return service.NewModelService[models2.TaskV2]().ReplaceById(t.Id, *t)
}
}
// initTaskStatus initialize task status of existing tasks
func (svc *Service) initTaskStatus() {
// set status of running tasks as TaskStatusAbnormal
runningTasks, err := service.NewModelServiceV2[models2.TaskV2]().GetMany(bson.M{
runningTasks, err := service.NewModelService[models2.TaskV2]().GetMany(bson.M{
"status": bson.M{
"$in": []string{
constants.TaskStatusPending,
@@ -186,7 +186,7 @@ func (svc *Service) isMasterNode(t *models2.TaskV2) (ok bool, err error) {
if t.NodeId.IsZero() {
return false, trace.TraceError(errors.ErrorTaskNoNodeId)
}
n, err := service.NewModelServiceV2[models2.NodeV2]().GetById(t.NodeId)
n, err := service.NewModelService[models2.NodeV2]().GetById(t.NodeId)
if err != nil {
if errors2.Is(err, mongo2.ErrNoDocuments) {
return false, trace.TraceError(errors.ErrorTaskNodeNotFound)
@@ -199,7 +199,7 @@ func (svc *Service) isMasterNode(t *models2.TaskV2) (ok bool, err error) {
func (svc *Service) cleanupTasks() {
for {
// task stats over 30 days ago
taskStats, err := service.NewModelServiceV2[models2.TaskStatV2]().GetMany(bson.M{
taskStats, err := service.NewModelService[models2.TaskStatV2]().GetMany(bson.M{
"created_ts": bson.M{
"$lt": time.Now().Add(-30 * 24 * time.Hour),
},
@@ -217,14 +217,14 @@ func (svc *Service) cleanupTasks() {
if len(ids) > 0 {
// remove tasks
if err := service.NewModelServiceV2[models2.TaskV2]().DeleteMany(bson.M{
if err := service.NewModelService[models2.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)
}
// remove task stats
if err := service.NewModelServiceV2[models2.TaskStatV2]().DeleteMany(bson.M{
if err := service.NewModelService[models2.TaskStatV2]().DeleteMany(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)

6
core/task/stats/service.go
View File

@@ -98,13 +98,13 @@ func (svc *Service) getDatabaseServiceItem(taskId primitive.ObjectID) (item *dat
}
// task
t, err := service.NewModelServiceV2[models2.TaskV2]().GetById(taskId)
t, err := service.NewModelService[models2.TaskV2]().GetById(taskId)
if err != nil {
return nil, err
}
// spider
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(t.SpiderId)
s, err := service.NewModelService[models2.SpiderV2]().GetById(t.SpiderId)
if err != nil {
return nil, err
}
@@ -137,7 +137,7 @@ func (svc *Service) getDatabaseServiceItem(taskId primitive.ObjectID) (item *dat
}
func (svc *Service) updateTaskStats(id primitive.ObjectID, resultCount int) {
err := service.NewModelServiceV2[models2.TaskStatV2]().UpdateById(id, bson.M{
err := service.NewModelService[models2.TaskStatV2]().UpdateById(id, bson.M{
"$inc": bson.M{
"result_count": resultCount,
},

4
core/user/service_v2.go
View File

@@ -20,7 +20,7 @@ import (
type ServiceV2 struct {
jwtSecret string
jwtSigningMethod jwt.SigningMethod
modelSvc *service.ModelServiceV2[models.UserV2]
modelSvc *service.ModelService[models.UserV2]
}
func (svc *ServiceV2) Init() (err error) {
@@ -171,7 +171,7 @@ func (svc *ServiceV2) getSecretFunc() jwt.Keyfunc {
func newUserServiceV2() (svc *ServiceV2, err error) {
// service
svc = &ServiceV2{
modelSvc: service.NewModelServiceV2[models.UserV2](),
modelSvc: service.NewModelService[models.UserV2](),
jwtSecret: "crawlab",
jwtSigningMethod: jwt.SigningMethodHS256,
}