更新导出任务

# Conflicts:
#	adaptor/AIComputing/AICore/api/AICore.api
#	adaptor/AIComputing/AICore/api/internal/handler/routes.go
#	adaptor/AIComputing/AICore/api/internal/types/types.go
#	adaptor/AIComputing/modelarts/rpc/modelarts/modelarts.pb.go

adaptor/AIComputing/AICore/api/aicore.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/config"
+	"PCM/adaptor/AIComputing/AICore/api/internal/handler"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+var configFile = flag.String("f", "adaptor/AIComputing/AICore/api/etc/aicore-api.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+
+	server := rest.MustNewServer(c.RestConf)
+	defer server.Stop()
+
+	ctx := svc.NewServiceContext(c)
+	handler.RegisterHandlers(server, ctx)
+
+	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
+	server.Start()
+}

adaptor/AIComputing/AICore/api/etc/aicore-api.yaml

@@ -0,0 +1,9 @@
+Name: AICore-api
+Host: 0.0.0.0
+Port: 8888
+
+#rpc by wangqi
+ModelartsRpcConf:
+  Endpoints:
+    - 127.0.0.1:2003
+  NonBlock: true

adaptor/AIComputing/AICore/api/internal/config/config.go

@@ -0,0 +1,12 @@
+package config
+
+import (
+	"github.com/zeromicro/go-zero/rest"
+	"github.com/zeromicro/go-zero/zrpc"
+)
+
+type Config struct {
+	rest.RestConf
+
+	ModelartsRpcConf zrpc.RpcClientConf
+}

adaptor/AIComputing/AICore/api/internal/handler/createalgorithmhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func CreateAlgorithmHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateAlgorithmReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateAlgorithmLogic(r.Context(), svcCtx)
+		resp, err := l.CreateAlgorithm(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createexporttaskhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func CreateExportTaskHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateExportTaskReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateExportTaskLogic(r.Context(), svcCtx)
+		resp, err := l.CreateExportTask(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createnotebookhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func createNotebookHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateNotebookReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateNotebookLogic(r.Context(), svcCtx)
+		resp, err := l.CreateNotebook(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createservicehandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func createServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateServiceReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateServiceLogic(r.Context(), svcCtx)
+		resp, err := l.CreateService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createtaskhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func CreateTaskHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ImportTaskDataReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateTaskLogic(r.Context(), svcCtx)
+		resp, err := l.CreateTask(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createtrainingjobhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func CreateTrainingJobHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateTrainingJobReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateTrainingJobLogic(r.Context(), svcCtx)
+		resp, err := l.CreateTrainingJob(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/createvisualizationjobhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func createVisualizationJobHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateVisualizationJobReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateVisualizationJobLogic(r.Context(), svcCtx)
+		resp, err := l.CreateVisualizationJob(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/deletealgorithmhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func DeleteAlgorithmHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.DeleteAlgorithmReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteAlgorithmLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteAlgorithm(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/deleteservicehandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func DeleteServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.DeleteServiceReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteServiceLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/deletetrainingjobhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func DeleteTrainingJobHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.DeleteTrainingJobReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteTrainingJobLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteTrainingJob(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/getlisttrainingjobshandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func GetListTrainingJobsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListTrainingJobsreq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetListTrainingJobsLogic(r.Context(), svcCtx)
+		resp, err := l.GetListTrainingJobs(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/getnotebookstoragehandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func getNotebookStorageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.GetNotebookStorageReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetNotebookStorageLogic(r.Context(), svcCtx)
+		resp, err := l.GetNotebookStorage(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/getvisualizationjobhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func getVisualizationJobHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.GetVisualizationJobReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetVisualizationJobLogic(r.Context(), svcCtx)
+		resp, err := l.GetVisualizationJob(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listalgorithmshandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func ListAlgorithmsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListAlgorithmsReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListAlgorithmsLogic(r.Context(), svcCtx)
+		resp, err := l.ListAlgorithms(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listclustershandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func ListClustersHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListClustersReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListClustersLogic(r.Context(), svcCtx)
+		resp, err := l.ListClusters(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listdatasethandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func listDataSetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListDataSetReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListDataSetLogic(r.Context(), svcCtx)
+		resp, err := l.ListDataSet(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listimporthandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func ListImportHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListImportTasksReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListImportLogic(r.Context(), svcCtx)
+		resp, err := l.ListImport(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listnotebookhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func listNotebookHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListNotebookReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListNotebookLogic(r.Context(), svcCtx)
+		resp, err := l.ListNotebook(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listserviceshandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func ListServicesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListServicesReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListServicesLogic(r.Context(), svcCtx)
+		resp, err := l.ListServices(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/mountnotebookstoragehandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func mountNotebookStorageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.MountNotebookStorageReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewMountNotebookStorageLogic(r.Context(), svcCtx)
+		resp, err := l.MountNotebookStorage(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/routes.go

@@ -0,0 +1,142 @@
+// Code generated by goctl. DO NOT EDIT.
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodGet,
+				Path:    "/listDataSet",
+				Handler: listDataSetHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/createDataSet",
+				Handler: CreateDataSetHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/deleteDataSet",
+				Handler: DeleteDataSetHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateTask",
+				Handler: CreateTaskHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/ListImport",
+				Handler: ListImportHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/GetListTrainingJobs",
+				Handler: GetListTrainingJobsHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/DeleteTrainingJob",
+				Handler: DeleteTrainingJobHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateAlgorithm",
+				Handler: CreateAlgorithmHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/ListAlgorithms",
+				Handler: ListAlgorithmsHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/DeleteAlgorithm",
+				Handler: DeleteAlgorithmHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateTrainingJob",
+				Handler: CreateTrainingJobHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateExportTask",
+				Handler: CreateExportTaskHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateService",
+				Handler: CreateServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/ListServices",
+				Handler: ListServicesHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/ShowService",
+				Handler: ShowServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/DeleteService",
+				Handler: DeleteServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/ListClusters",
+				Handler: ListClustersHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/listNotebook",
+				Handler: listNotebookHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/createNotebook",
+				Handler: createNotebookHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/startNotebook",
+				Handler: startNotebookHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/stopNotebook",
+				Handler: stopNotebookHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/getNotebookStorage",
+				Handler: getNotebookStorageHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/mountNotebookStorage",
+				Handler: mountNotebookStorageHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/getVisualizationJob",
+				Handler: getVisualizationJobHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateVisualizationJob",
+				Handler: createVisualizationJobHandler(serverCtx),
+			},
+		},
+	)
+}

adaptor/AIComputing/AICore/api/internal/handler/showservicehandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func ShowServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ShowServiceReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewShowServiceLogic(r.Context(), svcCtx)
+		resp, err := l.ShowService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/startnotebookhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func startNotebookHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.StartNotebookReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewStartNotebookLogic(r.Context(), svcCtx)
+		resp, err := l.StartNotebook(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/stopnotebookhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func stopNotebookHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.StopNotebookReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewStopNotebookLogic(r.Context(), svcCtx)
+		resp, err := l.StopNotebook(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/logic/createalgorithmlogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateAlgorithmLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateAlgorithmLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateAlgorithmLogic {
+	return &CreateAlgorithmLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateAlgorithmLogic) CreateAlgorithm(req *types.CreateAlgorithmReq) (resp *types.CreateAlgorithmResp, err error) {
+	modelartsReq := &modelarts.CreateAlgorithmReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{IgnoreEmpty: true, DeepCopy: true, Converters: tool.Converters})
+	ListAlgorithmsResp, err := l.svcCtx.ModelArtsRpc.CreateAlgorithm(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.CreateAlgorithmResp{}
+	err = copier.CopyWithOption(&resp, &ListAlgorithmsResp, copier.Option{IgnoreEmpty: true, DeepCopy: true, Converters: tool.Converters})
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/createdatasetlogic.go

@@ -0,0 +1,45 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateDataSetLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDataSetLogic {
+	return &CreateDataSetLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateDataSetLogic) CreateDataSet(req *types.CreateDataSetReq) (resp *types.CreateDataSetResp, err error) {
+	// todo: add your logic here and delete this line
+
+	modelartsReq := &modelarts.CreateDataSetReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	CreateDataSetResp, err := l.svcCtx.ModelArtsRpc.CreateDataSet(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.CreateDataSetResp{}
+
+	err = copier.CopyWithOption(&resp, &CreateDataSetResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+
+}

adaptor/AIComputing/AICore/api/internal/logic/createexporttasklogic.go

@@ -0,0 +1,42 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateExportTaskLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateExportTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateExportTaskLogic {
+	return &CreateExportTaskLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateExportTaskLogic) CreateExportTask(req *types.CreateExportTaskReq) (resp *types.CreateExportTaskResp, err error) {
+
+	modelartsReq := &modelarts.ExportTaskReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{IgnoreEmpty: true, DeepCopy: true, Converters: tool.Converters})
+	CreateExportTaskResp, err := l.svcCtx.ModelArtsRpc.ExportTask(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.CreateExportTaskResp{}
+	err = copier.CopyWithOption(&resp, &CreateExportTaskResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/createnotebooklogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateNotebookLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateNotebookLogic {
+	return &CreateNotebookLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateNotebookLogic) CreateNotebook(req *types.CreateNotebookReq) (resp *types.CreateNotebookResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/createservicelogic.go

@@ -0,0 +1,42 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateServiceLogic {
+	return &CreateServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateServiceLogic) CreateService(req *types.CreateServiceReq) (resp *types.CreateServiceResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.CreateServiceReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{IgnoreEmpty: true, DeepCopy: true, Converters: tool.Converters})
+	CreateServiceResp, err := l.svcCtx.ModelArtsRpc.CreateService(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.CreateServiceResp{}
+	err = copier.CopyWithOption(&resp, &CreateServiceResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/createtasklogic.go

@@ -0,0 +1,41 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTaskLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTaskLogic {
+	return &CreateTaskLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateTaskLogic) CreateTask(req *types.ImportTaskDataReq) (resp *types.ImportTaskDataResp, err error) {
+	modelartsReq := &modelarts.ImportTaskDataReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ImportTaskDataResp, err := l.svcCtx.ModelArtsRpc.CreateTask(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ImportTaskDataResp{}
+
+	err = copier.CopyWithOption(&resp, &ImportTaskDataResp, copier.Option{Converters: tool.Converters})
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/createtrainingjoblogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobLogic {
+	return &CreateTrainingJobLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateTrainingJobLogic) CreateTrainingJob(req *types.CreateTrainingJobReq) (resp *types.CreateTrainingJobResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.CreateTrainingJobReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{IgnoreEmpty: false, DeepCopy: true})
+	CreateTrainingJobResp, err := l.svcCtx.ModelArtsRpc.CreateTrainingJob(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db TrainingJob list"), "Failed to get db TrainingJob list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.CreateTrainingJobResp{}
+
+	err = copier.CopyWithOption(&resp, &CreateTrainingJobResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/createvisualizationjoblogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateVisualizationJobLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateVisualizationJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateVisualizationJobLogic {
+	return &CreateVisualizationJobLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateVisualizationJobLogic) CreateVisualizationJob(req *types.CreateVisualizationJobReq) (resp *types.CreateVisualizationJobResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/deletealgorithmlogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteAlgorithmLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteAlgorithmLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteAlgorithmLogic {
+	return &DeleteAlgorithmLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteAlgorithmLogic) DeleteAlgorithm(req *types.DeleteAlgorithmReq) (resp *types.DeleteAlgorithmResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.DeleteAlgorithmsReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	DeleteAlgorithmResp, err := l.svcCtx.ModelArtsRpc.DeleteAlgorithms(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.DeleteAlgorithmResp{}
+	err = copier.CopyWithOption(&resp, &DeleteAlgorithmResp, copier.Option{Converters: tool.Converters})
+	if resp == nil {
+		resp.Msg = "Success"
+		resp.Code = 200
+	}
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/deletedatasetlogic.go

@@ -0,0 +1,43 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteDataSetLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteDataSetLogic {
+	return &DeleteDataSetLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteDataSetLogic) DeleteDataSet(req *types.DeleteDataSetReq) (resp *types.DeleteDataSetResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.DeleteDataSetReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	deleteDataSetResp, err := l.svcCtx.ModelArtsRpc.DeleteDataSet(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to delete db DataSet list"), "Failed to delete db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.DeleteDataSetResp{}
+
+	err = copier.CopyWithOption(&resp, &deleteDataSetResp, copier.Option{Converters: tool.Converters})
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/deleteservicelogic.go

@@ -0,0 +1,41 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteServiceLogic {
+	return &DeleteServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteServiceLogic) DeleteService(req *types.DeleteServiceReq) (resp *types.DeleteServiceResp, err error) {
+	modelartsReq := &modelarts.DeleteServiceReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	DeleteServiceResp, err := l.svcCtx.ModelArtsRpc.DeleteService(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.DeleteServiceResp{}
+	err = copier.CopyWithOption(&resp, &DeleteServiceResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/deletetrainingjoblogic.go

@@ -0,0 +1,41 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteTrainingJobLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteTrainingJobLogic {
+	return &DeleteTrainingJobLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteTrainingJobLogic) DeleteTrainingJob(req *types.DeleteTrainingJobReq) (resp *types.DeleteTrainingJobResp, err error) {
+	modelartsReq := &modelarts.DeleteTrainingJobReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	deleteTrainingJobResp, err := l.svcCtx.ModelArtsRpc.DeleteTrainingJob(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to delete training job"), "Failed to delete training job err : %v ,req:%+v", err, req)
+	}
+	resp = &types.DeleteTrainingJobResp{}
+	err = copier.CopyWithOption(&resp, &deleteTrainingJobResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/getlisttrainingjobslogic.go

@@ -0,0 +1,53 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetListTrainingJobsLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetListTrainingJobsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetListTrainingJobsLogic {
+	return &GetListTrainingJobsLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetListTrainingJobsLogic) GetListTrainingJobs(req *types.ListTrainingJobsreq) (resp *types.ListTrainingJobsresp, err error) {
+	modelartsReq := &modelarts.ListTrainingJobsreq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetListTrainingJobs(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListTrainingJobsresp{}
+	for i := 0; i < len(listDataSetResp.Items); i++ {
+		historyJob := types.Items{}
+		resp.Items = append(resp.Items, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/getnotebookstoragelogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetNotebookStorageLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetNotebookStorageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNotebookStorageLogic {
+	return &GetNotebookStorageLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNotebookStorageLogic) GetNotebookStorage(req *types.GetNotebookStorageReq) (resp *types.GetNotebookStorageResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/getvisualizationjoblogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetVisualizationJobLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetVisualizationJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVisualizationJobLogic {
+	return &GetVisualizationJobLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetVisualizationJobLogic) GetVisualizationJob(req *types.GetVisualizationJobReq) (resp *types.GetVisualizationJobResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/listalgorithmslogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListAlgorithmsLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListAlgorithmsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListAlgorithmsLogic {
+	return &ListAlgorithmsLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListAlgorithmsLogic) ListAlgorithms(req *types.ListAlgorithmsReq) (resp *types.ListAlgorithmsResp, err error) {
+	modelartsReq := &modelarts.ListAlgorithmsReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{IgnoreEmpty: false, DeepCopy: true, Converters: tool.Converters})
+	ListAlgorithmsResp, err := l.svcCtx.ModelArtsRpc.ListAlgorithms(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListAlgorithmsResp{}
+	err = copier.CopyWithOption(&resp, &ListAlgorithmsResp, copier.Option{IgnoreEmpty: true, DeepCopy: true, Converters: tool.Converters})
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listclusterslogic.go

@@ -0,0 +1,42 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListClustersLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListClustersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListClustersLogic {
+	return &ListClustersLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListClustersLogic) ListClusters(req *types.ListClustersReq) (resp *types.ListClustersResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.ListClustersReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ListClustersResp, err := l.svcCtx.ModelArtsRpc.ListClusters(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListClustersResp{}
+	err = copier.CopyWithOption(&resp, &ListClustersResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listdatasetlogic.go

@@ -0,0 +1,48 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListDataSetLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListDataSetLogic {
+	return &ListDataSetLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListDataSetLogic) ListDataSet(req *types.ListDataSetReq) (resp *types.ListDataSetResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.DatasetReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetDatasetList(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListDataSetResp{}
+	for i := 0; i < len(listDataSetResp.Datasets); i++ {
+		dataset := types.DataSet{}
+		resp.DataSet = append(resp.DataSet, dataset)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listimportlogic.go

@@ -0,0 +1,53 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListImportLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListImportLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListImportLogic {
+	return &ListImportLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListImportLogic) ListImport(req *types.ListImportTasksReq) (resp *types.ListImportTasksResp, err error) {
+	modelartsReq := &modelarts.ListImportTasksReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetImportTaskList(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListImportTasksResp{}
+	for i := 0; i < len(listDataSetResp.ImportTasks); i++ {
+		historyJob := types.ImportTasks{}
+		resp.ImportTasks = append(resp.ImportTasks, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listnotebooklogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListNotebookLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListNotebookLogic {
+	return &ListNotebookLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListNotebookLogic) ListNotebook(req *types.ListNotebookReq) (resp *types.ListNotebookResp, err error) {
+	modelartsReq := &modelarts.ListNotebookReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+
+	listNotebookResp, err := l.svcCtx.ModelArtsRpc.ListNotebook(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get notebook list"), "Failed to get notebook list err : %v ,req:%+v", err, req)
+	}
+
+	resp = &types.ListNotebookResp{}
+	err = copier.CopyWithOption(&resp, &listNotebookResp, copier.Option{Converters: tool.Converters})
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listserviceslogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListServicesLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListServicesLogic {
+	return &ListServicesLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListServicesLogic) ListServices(req *types.ListServicesReq) (resp *types.ListServicesResp, err error) {
+	modelartsReq := &modelarts.ListServicesReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ListServicesResp, err := l.svcCtx.ModelArtsRpc.ListServices(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListServicesResp{}
+	for i := 0; i < len(ListServicesResp.Services); i++ {
+		historyJob := types.ListServices{}
+		resp.Services = append(resp.Services, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &ListServicesResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/mountnotebookstoragelogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type MountNotebookStorageLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewMountNotebookStorageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MountNotebookStorageLogic {
+	return &MountNotebookStorageLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *MountNotebookStorageLogic) MountNotebookStorage(req *types.MountNotebookStorageReq) (resp *types.MountNotebookStorageResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/showalgorithmbyuuidlogic.go

@@ -0,0 +1,42 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowAlgorithmByUuidLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewShowAlgorithmByUuidLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowAlgorithmByUuidLogic {
+	return &ShowAlgorithmByUuidLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ShowAlgorithmByUuidLogic) ShowAlgorithmByUuid(req *types.ShowAlgorithmByUuidReq) (resp *types.ShowAlgorithmByUuidResp, err error) {
+
+	modelartsReq := &modelarts.ShowAlgorithmByUuidReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ShowAlgorithmByUuidResp, err := l.svcCtx.ModelArtsRpc.ShowAlgorithmByUuid(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ShowAlgorithmByUuidResp{}
+	err = copier.CopyWithOption(&resp, &ShowAlgorithmByUuidResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/showservicelogic.go

@@ -0,0 +1,41 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewShowServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowServiceLogic {
+	return &ShowServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ShowServiceLogic) ShowService(req *types.ShowServiceReq) (resp *types.ShowServiceResp, err error) {
+	modelartsReq := &modelarts.ShowServiceReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ShowServiceResp, err := l.svcCtx.ModelArtsRpc.ShowService(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ShowServiceResp{}
+	err = copier.CopyWithOption(&resp, &ShowServiceResp, copier.Option{Converters: tool.Converters})
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/startnotebooklogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type StartNotebookLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewStartNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StartNotebookLogic {
+	return &StartNotebookLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *StartNotebookLogic) StartNotebook(req *types.StartNotebookReq) (resp *types.StartNotebookResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/stopnotebooklogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type StopNotebookLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewStopNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StopNotebookLogic {
+	return &StopNotebookLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *StopNotebookLogic) StopNotebook(req *types.StopNotebookReq) (resp *types.StopNotebookResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/svc/servicecontext.go

@@ -0,0 +1,21 @@
+package svc
+
+import (
+	"PCM/adaptor/AIComputing/AICore/api/internal/config"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelartsclient"
+	"github.com/zeromicro/go-zero/zrpc"
+)
+
+type ServiceContext struct {
+	Config config.Config
+
+	ModelArtsRpc modelartsclient.ModelArts
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	return &ServiceContext{
+		Config: c,
+
+		ModelArtsRpc: modelartsclient.NewModelArts(zrpc.MustNewClient(c.ModelartsRpcConf)),
+	}
+}

adaptor/AIComputing/modelarts/rpc/etc/modelarts.yaml

@@ -0,0 +1,4 @@
+Name: modelarts.rpc
+ListenOn: 0.0.0.0:2003
+
+modelartsUrl: "https://modelarts.cn-north-4.myhuaweicloud.com/"

adaptor/AIComputing/modelarts/rpc/internal/common/AuthService.go

@@ -0,0 +1,69 @@
+package common
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+const (
+	IAMUser        = "pcmmodelarts"
+	IAMPassword    = "!QAZ2wsx3edc4"
+	IAMDomain      = "hw_008618597947378_01"
+	AuthMethod     = "password"
+	IAMTokenUrl    = "https://iam.cn-north-4.myhuaweicloud.com/v3/auth/tokens"
+	ProjectName    = "cn-north-4"
+	TokenHeader    = "X-Subject-Token"
+	Status_created = 201
+)
+
+var (
+	token, expiredAt = GenerateToken()
+)
+
+func GenerateToken() (string, time.Time) {
+	a := Auth{}
+	a.Auth.Scope.Project.Name = ProjectName
+	a.Auth.Identity.Methods = append(a.Auth.Identity.Methods, AuthMethod)
+	a.Auth.Identity.Password.User.Name = IAMUser
+	a.Auth.Identity.Password.User.Password = IAMPassword
+	a.Auth.Identity.Password.User.Domain.Name = IAMDomain
+
+	jsonStr, _ := json.Marshal(a)
+	req_url, err := http.NewRequest("POST", IAMTokenUrl, bytes.NewBuffer(jsonStr))
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer req_url.Body.Close()
+
+	c := http.Client{Timeout: time.Duration(3) * time.Second}
+
+	respUrl, err := c.Do(req_url)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if respUrl.StatusCode != Status_created {
+		panic("获取token失败")
+	}
+
+	defer respUrl.Body.Close()
+
+	var t Token
+
+	result, _ := io.ReadAll(respUrl.Body)
+	json.Unmarshal(result, &t)
+
+	return respUrl.Header.Get(TokenHeader), t.Token.ExpiresAt
+}
+
+func GetToken() string {
+	if time.Now().After(expiredAt) {
+		token, expiredAt = GenerateToken()
+	}
+	return token
+}

adaptor/AIComputing/modelarts/rpc/internal/common/Entity.go

@@ -0,0 +1,66 @@
+package common
+
+import "time"
+
+type Token struct {
+	Token struct {
+		ExpiresAt time.Time `json:"expires_at"`
+		Methods   []string  `json:"methods"`
+		Catalog   []struct {
+			Endpoints []struct {
+				Id        string `json:"id"`
+				Interface string `json:"interface"`
+				Region    string `json:"region"`
+				RegionId  string `json:"region_id"`
+				Url       string `json:"url"`
+			} `json:"endpoints"`
+			Id   string `json:"id"`
+			Name string `json:"name"`
+			Type string `json:"type"`
+		} `json:"catalog"`
+		Roles []struct {
+			Id   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"roles"`
+		Project struct {
+			Domain struct {
+				Id   string `json:"id"`
+				Name string `json:"name"`
+			} `json:"domain"`
+			Id   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"project"`
+		IssuedAt time.Time `json:"issued_at"`
+		User     struct {
+			Domain struct {
+				Id   string `json:"id"`
+				Name string `json:"name"`
+			} `json:"domain"`
+			Id                string `json:"id"`
+			Name              string `json:"name"`
+			PasswordExpiresAt string `json:"password_expires_at"`
+		} `json:"user"`
+	} `json:"token"`
+}
+
+type Auth struct {
+	Auth struct {
+		Identity struct {
+			Methods  []string `json:"methods"`
+			Password struct {
+				User struct {
+					Name     string `json:"name"`
+					Password string `json:"password"`
+					Domain   struct {
+						Name string `json:"name"`
+					} `json:"domain"`
+				} `json:"user"`
+			} `json:"password"`
+		} `json:"identity"`
+		Scope struct {
+			Project struct {
+				Name string `json:"name"`
+			} `json:"project"`
+		} `json:"scope"`
+	} `json:"auth"`
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createalgorithmlogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateAlgorithmLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateAlgorithmLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateAlgorithmLogic {
+	return &CreateAlgorithmLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateAlgorithm 创建算法
+func (l *CreateAlgorithmLogic) CreateAlgorithm(in *modelarts.CreateAlgorithmReq) (*modelarts.CreateAlgorithmResp, error) {
+	var resp modelarts.CreateAlgorithmResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createdatasetlogic.go

@@ -0,0 +1,50 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateDataSetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDataSetLogic {
+	return &CreateDataSetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// create  DateSet
+func (l *CreateDataSetLogic) CreateDataSet(in *modelarts.CreateDataSetReq) (*modelarts.CreateDataSetResq, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateDataSetResq
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createmodellogic.go

@@ -0,0 +1,52 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateModelLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateModelLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateModelLogic {
+	return &CreateModelLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// model management
+func (l *CreateModelLogic) CreateModel(in *modelarts.CreateModelReq) (*modelarts.CreateModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createnotebooklogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateNotebookLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateNotebookLogic {
+	return &CreateNotebookLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *CreateNotebookLogic) CreateNotebook(in *modelarts.CreateNotebookReq) (*modelarts.CreateNotebookResp, error) {
+	var resp modelarts.CreateNotebookResp
+	createUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks"
+	createUrl = strings.Replace(createUrl, "{project_id}", in.ProjectId, -1)
+	reqByte, err := json.Marshal(in.Param)
+	if err != nil {
+		panic(err.Error())
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, createUrl, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp.NotebookResp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createprocessortasklogic.go

@@ -0,0 +1,52 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateProcessorTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateProcessorTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateProcessorTaskLogic {
+	return &CreateProcessorTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// processor task
+func (l *CreateProcessorTaskLogic) CreateProcessorTask(in *modelarts.CreateProcessorTaskReq) (*modelarts.CreateProcessorTaskResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateProcessorTaskResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/processor-tasks/"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createservicelogic.go

@@ -0,0 +1,56 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+)
+
+import (
+	"context"
+)
+
+type CreateServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateServiceLogic {
+	return &CreateServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// service management
+func (l *CreateServiceLogic) CreateService(in *modelarts.CreateServiceReq) (*modelarts.CreateServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtasklogic.go

@@ -0,0 +1,50 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTaskLogic {
+	return &CreateTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// creat task 创建导入任务
+func (l *CreateTaskLogic) CreateTask(in *modelarts.ImportTaskDataReq) (*modelarts.ImportTaskDataResp, error) {
+	var resp modelarts.ImportTaskDataResp
+
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/import-tasks"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtrainingjobconfiglogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobConfigLogic {
+	return &CreateTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateTrainingJobConfig 创建训练作业参数
+func (l *CreateTrainingJobConfigLogic) CreateTrainingJobConfig(in *modelarts.CreateTrainingJobConfigReq) (*modelarts.CreateTrainingJobConfigResp, error) {
+	var resp modelarts.CreateTrainingJobConfigResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtrainingjoblogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobLogic {
+	return &CreateTrainingJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateTrainingJob 创建训练作业
+func (l *CreateTrainingJobLogic) CreateTrainingJob(in *modelarts.CreateTrainingJobReq) (*modelarts.CreateTrainingJobResp, error) {
+	var resp modelarts.CreateTrainingJobResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-jobs"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createvisualizationjoblogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateVisualizationJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateVisualizationJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateVisualizationJobLogic {
+	return &CreateVisualizationJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *CreateVisualizationJobLogic) CreateVisualizationJob(in *modelarts.CreateVisualizationJobReq) (*modelarts.CreateVisualizationJobResp, error) {
+	var resp modelarts.CreateVisualizationJobResp
+	createVisualJobUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/visualization-jobs"
+	createVisualJobUrl = strings.Replace(createVisualJobUrl, "{project_id}", in.ProjectId, -1)
+
+	reqByte, err := json.Marshal(in.Param)
+	if err != nil {
+		panic(err.Error())
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, createVisualJobUrl, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletealgorithmslogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteAlgorithmsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteAlgorithmsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteAlgorithmsLogic {
+	return &DeleteAlgorithmsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// DeleteAlgorithms 删除算法
+func (l *DeleteAlgorithmsLogic) DeleteAlgorithms(in *modelarts.DeleteAlgorithmsReq) (*modelarts.DeleteAlgorithmsResp, error) {
+
+	var resp modelarts.DeleteAlgorithmsResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms/" + in.AlgorithmId
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = 200
+	resp.Msg = "success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletedatasetlogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteDataSetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteDataSetLogic {
+	return &DeleteDataSetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// create  DateSet
+func (l *DeleteDataSetLogic) DeleteDataSet(in *modelarts.DeleteDataSetReq) (*modelarts.DeleteDataSetResq, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DeleteDataSetResq
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/datasets/" + in.DatasetId
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletemodellogic.go

@@ -0,0 +1,51 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteModelLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteModelLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteModelLogic {
+	return &DeleteModelLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DeleteModelLogic) DeleteModel(in *modelarts.DeleteModelReq) (*modelarts.DeleteModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DeleteModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models/" + in.ModelId
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deleteservicelogic.go

@@ -0,0 +1,46 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteServiceLogic {
+	return &DeleteServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DeleteServiceLogic) DeleteService(in *modelarts.DeleteServiceReq) (*modelarts.DeleteServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DeleteServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services/" + in.ServiceId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletetrainingjobconfiglogic.go

@@ -0,0 +1,43 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteTrainingJobConfigLogic {
+	return &DeleteTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// DeleteTrainingJobConfig 删除训练作业参数
+func (l *DeleteTrainingJobConfigLogic) DeleteTrainingJobConfig(in *modelarts.DeleteTrainingJobConfigReq) (*modelarts.DeleteTrainingJobConfigResp, error) {
+	var resp modelarts.DeleteTrainingJobConfigResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs/" + in.ConfigName
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, strings.NewReader(``), token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletetrainingjoblogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"strconv"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteTrainingJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteTrainingJobLogic {
+	return &DeleteTrainingJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// DeleteTrainingJobConfig 删除训练作业
+func (l *DeleteTrainingJobLogic) DeleteTrainingJob(in *modelarts.DeleteTrainingJobReq) (*modelarts.DeleteTrainingJobResp, error) {
+	var resp modelarts.DeleteTrainingJobResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-jobs/" + in.TrainingJobId
+	token := common.GetToken()
+	statusCode, err := tool.HttpClientStatusCode(tool.DELETE, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.ErrorCode = strconv.FormatInt(int64(statusCode), 10)
+	resp.ErrorMessage = err.Error()
+	if statusCode == 202 {
+		resp.IsSuccess = true
+	} else {
+		resp.IsSuccess = false
+	}
+
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/describeprocessortasklogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DescribeProcessorTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDescribeProcessorTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DescribeProcessorTaskLogic {
+	return &DescribeProcessorTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DescribeProcessorTaskLogic) DescribeProcessorTask(in *modelarts.DescribeProcessorTaskReq) (*modelarts.DescribeProcessorTaskResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DescribeProcessorTaskResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/processor-tasks/" + in.TaskId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/exporttasklogic.go

@@ -0,0 +1,54 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	_ "PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ExportTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewExportTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ExportTaskLogic {
+	return &ExportTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ExportTask for modelarts
+func (l *ExportTaskLogic) ExportTask(in *modelarts.ExportTaskReq) (*modelarts.ExportTaskResp, error) {
+	var resp modelarts.ExportTaskResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/export-tasks"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getdatasetlistlogic.go

@@ -0,0 +1,40 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"log"
+	"strings"
+)
+
+type GetDatasetListLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetDatasetListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetDatasetListLogic {
+	return &GetDatasetListLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// find datasetList
+func (l *GetDatasetListLogic) GetDatasetList(in *modelarts.DatasetReq) (*modelarts.DatasetResp, error) {
+	projectId := in.ProjectId
+	var resp modelarts.DatasetResp
+	token := common.GetToken()
+	reqUrl, err := tool.HttpClient(tool.GET, "https://modelarts.cn-north-4.myhuaweicloud.com/v2/"+projectId+"/datasets", strings.NewReader(``), token)
+	json.Unmarshal(reqUrl, &resp)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getexporttasksofdatasetlogic.go

@@ -0,0 +1,51 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetExportTasksOfDatasetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetExportTasksOfDatasetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetExportTasksOfDatasetLogic {
+	return &GetExportTasksOfDatasetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+//type Pppp struct {
+//	TotalCount  int                           `json:"total_count"`
+//	ExportTasks []*Modelarts.ExportTaskStatus `json:"export_tasks"`
+//}
+
+func (l *GetExportTasksOfDatasetLogic) GetExportTasksOfDataset(in *modelarts.GetExportTasksOfDatasetReq) (*modelarts.GetExportTasksOfDatasetResp, error) {
+
+	var resp modelarts.GetExportTasksOfDatasetResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/export-tasks"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getexporttaskstatusofdatasetlogic.go

@@ -0,0 +1,47 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetExportTaskStatusOfDatasetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetExportTaskStatusOfDatasetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetExportTaskStatusOfDatasetLogic {
+	return &GetExportTaskStatusOfDatasetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *GetExportTaskStatusOfDatasetLogic) GetExportTaskStatusOfDataset(in *modelarts.GetExportTaskStatusOfDatasetReq) (*modelarts.GetExportTaskStatusOfDatasetResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.GetExportTaskStatusOfDatasetResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.ResourceId + "/export-tasks/" + in.TaskId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getimporttasklistlogic.go

@@ -0,0 +1,48 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"log"
+	"strconv"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetImportTaskListLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetImportTaskListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetImportTaskListLogic {
+	return &GetImportTaskListLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// find taskList 查询数据集导入任务列表
+func (l *GetImportTaskListLogic) GetImportTaskList(in *modelarts.ListImportTasksReq) (*modelarts.ListImportTasksResp, error) {
+	datasetId := in.DatasetId
+	projectId := in.ProjectId
+	limit := strconv.Itoa(int(in.Limit))
+	offset := strconv.Itoa(int(in.Offset))
+	var resp modelarts.ListImportTasksResp
+	token := common.GetToken()
+	reqUrl, err := tool.HttpClient(tool.GET, "https://modelarts.cn-north-4.myhuaweicloud.com/v2/"+projectId+"/datasets/"+datasetId+"/import-tasks?limit="+limit+"&offset="+offset, strings.NewReader(``), token)
+
+	json.Unmarshal(reqUrl, &resp)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getlisttrainingjobslogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetListTrainingJobsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetListTrainingJobsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetListTrainingJobsLogic {
+	return &GetListTrainingJobsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// get ListTrainingJobs1
+func (l *GetListTrainingJobsLogic) GetListTrainingJobs(in *modelarts.ListTrainingJobsreq) (*modelarts.ListTrainingJobsresp, error) {
+	var resp modelarts.ListTrainingJobsresp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-job-searches"
+	reqByte, err := json.Marshal(in)
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getnotebookstoragelogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetNotebookStorageLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetNotebookStorageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNotebookStorageLogic {
+	return &GetNotebookStorageLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *GetNotebookStorageLogic) GetNotebookStorage(in *modelarts.GetNotebookStorageReq) (*modelarts.GetNotebookStorageResp, error) {
+	var resp modelarts.GetNotebookStorageResp
+	getObsUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks/{instance_id}/storage"
+	getObsUrl = strings.Replace(getObsUrl, "{project_id}", in.ProjectId, -1)
+	getObsUrl = strings.Replace(getObsUrl, "{instance_id}", in.InstanceId, -1)
+
+	token := common.GetToken()
+
+	//empty struct
+	var e struct{}
+
+	body, err := tool.HttpClientWithQueries(tool.GET, getObsUrl, nil, token, e)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/gettokenlogic.go

@@ -0,0 +1,68 @@
+package logic
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"time"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetTokenLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetTokenLogic {
+	return &GetTokenLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// getToken
+func (l *GetTokenLogic) GetToken(in *modelarts.TokenReq) (*modelarts.TokenResp, error) {
+	// todo: add your logic here and delete this line
+
+	var resp modelarts.TokenResp
+	TokenUrl := "v3/auth/tokens"
+
+	jsonStr, _ := json.Marshal(in)
+	reqUrl, err := http.NewRequest("POST", "https://iam.cn-north-4.myhuaweicloud.com/"+TokenUrl, bytes.NewBuffer(jsonStr))
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer reqUrl.Body.Close()
+
+	c := http.Client{Timeout: time.Duration(3) * time.Second}
+
+	respUrl, err := c.Do(reqUrl)
+
+	print(respUrl)
+
+	defer respUrl.Body.Close()
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	result, _ := ioutil.ReadAll(respUrl.Body)
+	json.Unmarshal([]byte(string(result)), &resp)
+
+	//X-Auth-Token := respUrl.Header().Get("X-Subject-Token")
+
+	//return resp, nil
+
+	return &modelarts.TokenResp{}, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getvisualizationjoblogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetVisualizationJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetVisualizationJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVisualizationJobLogic {
+	return &GetVisualizationJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// visualization-jobs
+func (l *GetVisualizationJobLogic) GetVisualizationJob(in *modelarts.GetVisualizationJobReq) (*modelarts.GetVisualizationJobResp, error) {
+	var resp modelarts.GetVisualizationJobResp
+	getVisualJobUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/visualization-jobs"
+	getVisualJobUrl = strings.Replace(getVisualJobUrl, "{project_id}", in.ProjectId, -1)
+
+	token := common.GetToken()
+
+	body, err := tool.HttpClientWithQueries(tool.GET, getVisualJobUrl, nil, token, in.Param)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listalgorithmslogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strconv"
+)
+
+type ListAlgorithmsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListAlgorithmsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListAlgorithmsLogic {
+	return &ListAlgorithmsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ListAlgorithms 查询算法
+func (l *ListAlgorithmsLogic) ListAlgorithms(in *modelarts.ListAlgorithmsReq) (*modelarts.ListAlgorithmsResp, error) {
+	var resp modelarts.ListAlgorithmsResp
+	offset := strconv.Itoa(int(in.Offset))
+	limit := strconv.Itoa(int(in.Limit))
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms?offset=" + offset + "&" + "limit=" + limit
+	//reqByte, err := json.Marshal(in)
+	//payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listclusterslogic.go

@@ -0,0 +1,48 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListClustersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListClustersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListClustersLogic {
+	return &ListClustersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListClustersLogic) ListClusters(in *modelarts.ListClustersReq) (*modelarts.ListClustersResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListClustersResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/clusters"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listmodelslogic.go

@@ -0,0 +1,45 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListModelsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListModelsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListModelsLogic {
+	return &ListModelsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListModelsLogic) ListModels(in *modelarts.ListModelReq) (*modelarts.ListModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listnotebooklogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListNotebookLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListNotebookLogic {
+	return &ListNotebookLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// notebook task
+func (l *ListNotebookLogic) ListNotebook(in *modelarts.ListNotebookReq) (*modelarts.ListNotebookResp, error) {
+	var resp modelarts.ListNotebookResp
+	getUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks"
+	getUrl = strings.Replace(getUrl, "{project_id}", in.ProjectId, -1)
+
+	token := common.GetToken()
+
+	body, err := tool.HttpClientWithQueries(tool.GET, getUrl, nil, token, in.Param)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listserviceslogic.go

@@ -0,0 +1,47 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListServicesLogic {
+	return &ListServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListServicesLogic) ListServices(in *modelarts.ListServicesReq) (*modelarts.ListServicesResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListServicesResp
+
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listtrainingjobconfiglogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strconv"
+)
+
+type ListTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListTrainingJobConfigLogic {
+	return &ListTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ListTrainingJobConfig 查询训练作业参数
+func (l *ListTrainingJobConfigLogic) ListTrainingJobConfig(in *modelarts.ListTrainingJobConfigReq) (*modelarts.ListTrainingJobConfigResp, error) {
+	var resp modelarts.ListTrainingJobConfigResp
+	perPage := strconv.Itoa(int(in.PerPage))
+	page := strconv.Itoa(int(in.Page))
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs?" + perPage + "&" + page
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(&jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/mountnotebookstoragelogic.go

@@ -0,0 +1,48 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type MountNotebookStorageLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewMountNotebookStorageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MountNotebookStorageLogic {
+	return &MountNotebookStorageLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *MountNotebookStorageLogic) MountNotebookStorage(in *modelarts.MountNotebookStorageReq) (*modelarts.MountNotebookStorageResp, error) {
+	var resp modelarts.MountNotebookStorageResp
+	mountUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks/{instance_id}/storage"
+	mountUrl = strings.Replace(mountUrl, "{project_id}", in.ProjectId, -1)
+	mountUrl = strings.Replace(mountUrl, "{instance_id}", in.InstanceId, -1)
+
+	reqByte, err := json.Marshal(in.Param)
+	if err != nil {
+		panic(err.Error())
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, mountUrl, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/showalgorithmbyuuidlogic.go

@@ -0,0 +1,42 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowAlgorithmByUuidLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewShowAlgorithmByUuidLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowAlgorithmByUuidLogic {
+	return &ShowAlgorithmByUuidLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ShowAlgorithmByUuid 展示算法详情
+func (l *ShowAlgorithmByUuidLogic) ShowAlgorithmByUuid(in *modelarts.ShowAlgorithmByUuidReq) (*modelarts.ShowAlgorithmByUuidResp, error) {
+	var resp modelarts.ShowAlgorithmByUuidResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms/" + in.AlgorithmId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/showmodelslogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowModelsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewShowModelsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowModelsLogic {
+	return &ShowModelsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ShowModelsLogic) ShowModels(in *modelarts.ShowModelReq) (*modelarts.ShowModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ShowModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models/" + in.ModelId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/showservicelogic.go

@@ -0,0 +1,46 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewShowServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowServiceLogic {
+	return &ShowServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ShowServiceLogic) ShowService(in *modelarts.ShowServiceReq) (*modelarts.ShowServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ShowServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services/" + in.ServiceId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	resp.Code = int32(200)
+	resp.Msg = "Success"
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/startnotebooklogic.go

@@ -0,0 +1,43 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type StartNotebookLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewStartNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StartNotebookLogic {
+	return &StartNotebookLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *StartNotebookLogic) StartNotebook(in *modelarts.StartNotebookReq) (*modelarts.StartNotebookResp, error) {
+	var resp modelarts.StartNotebookResp
+	startUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks/{id}/start"
+	startUrl = strings.Replace(startUrl, "{project_id}", in.ProjectId, -1)
+	startUrl = strings.Replace(startUrl, "{id}", in.Id, -1)
+
+	token := common.GetToken()
+	body, err := tool.HttpClientWithQueries(tool.POST, startUrl, nil, token, in.Param)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp.NotebookResp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/stopnotebooklogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"encoding/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type StopNotebookLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewStopNotebookLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StopNotebookLogic {
+	return &StopNotebookLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *StopNotebookLogic) StopNotebook(in *modelarts.StopNotebookReq) (*modelarts.StopNotebookResp, error) {
+	var resp modelarts.StopNotebookResp
+	stopUrl := "https://modelarts.cn-east-3.myhuaweicloud.com/v1/{project_id}/notebooks/{id}/stop"
+	stopUrl = strings.Replace(stopUrl, "{project_id}", in.ProjectId, -1)
+	stopUrl = strings.Replace(stopUrl, "{id}", in.Id, -1)
+
+	token := common.GetToken()
+	//empty struct
+	var e struct{}
+
+	body, err := tool.HttpClientWithQueries(tool.POST, stopUrl, nil, token, e)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp.NotebookResp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/server/modelartsserver.go

@@ -0,0 +1,235 @@
+// Code generated by goctl. DO NOT EDIT.
+// Source: modelarts.proto
+
+package server
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/logic"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+)
+
+type ModelArtsServer struct {
+	svcCtx *svc.ServiceContext
+	modelarts.UnimplementedModelArtsServer
+}
+
+func NewModelArtsServer(svcCtx *svc.ServiceContext) *ModelArtsServer {
+	return &ModelArtsServer{
+		svcCtx: svcCtx,
+	}
+}
+
+// get modelarts Token
+func (s *ModelArtsServer) GetToken(ctx context.Context, in *modelarts.TokenReq) (*modelarts.TokenResp, error) {
+	l := logic.NewGetTokenLogic(ctx, s.svcCtx)
+	return l.GetToken(in)
+}
+
+// get modelarts Token
+func (s *ModelArtsServer) GetDatasetList(ctx context.Context, in *modelarts.DatasetReq) (*modelarts.DatasetResp, error) {
+	l := logic.NewGetDatasetListLogic(ctx, s.svcCtx)
+	return l.GetDatasetList(in)
+}
+
+// create  DateSet
+func (s *ModelArtsServer) CreateDataSet(ctx context.Context, in *modelarts.CreateDataSetReq) (*modelarts.CreateDataSetResq, error) {
+	l := logic.NewCreateDataSetLogic(ctx, s.svcCtx)
+	return l.CreateDataSet(in)
+}
+
+// create  DateSet
+func (s *ModelArtsServer) DeleteDataSet(ctx context.Context, in *modelarts.DeleteDataSetReq) (*modelarts.DeleteDataSetResq, error) {
+	l := logic.NewDeleteDataSetLogic(ctx, s.svcCtx)
+	return l.DeleteDataSet(in)
+}
+
+// creat task  创建导入任务
+func (s *ModelArtsServer) CreateTask(ctx context.Context, in *modelarts.ImportTaskDataReq) (*modelarts.ImportTaskDataResp, error) {
+	l := logic.NewCreateTaskLogic(ctx, s.svcCtx)
+	return l.CreateTask(in)
+}
+
+// get taskList 查询数据集导入任务列表
+func (s *ModelArtsServer) GetImportTaskList(ctx context.Context, in *modelarts.ListImportTasksReq) (*modelarts.ListImportTasksResp, error) {
+	l := logic.NewGetImportTaskListLogic(ctx, s.svcCtx)
+	return l.GetImportTaskList(in)
+}
+
+// ListTrainingJobs 查询训练作业列表
+func (s *ModelArtsServer) GetListTrainingJobs(ctx context.Context, in *modelarts.ListTrainingJobsreq) (*modelarts.ListTrainingJobsresp, error) {
+	l := logic.NewGetListTrainingJobsLogic(ctx, s.svcCtx)
+	return l.GetListTrainingJobs(in)
+}
+
+// CreateTrainingJob 创建训练作业
+func (s *ModelArtsServer) CreateTrainingJob(ctx context.Context, in *modelarts.CreateTrainingJobReq) (*modelarts.CreateTrainingJobResp, error) {
+	l := logic.NewCreateTrainingJobLogic(ctx, s.svcCtx)
+	return l.CreateTrainingJob(in)
+}
+
+// DeleteTrainingJobConfig 删除训练作业
+func (s *ModelArtsServer) DeleteTrainingJob(ctx context.Context, in *modelarts.DeleteTrainingJobReq) (*modelarts.DeleteTrainingJobResp, error) {
+	l := logic.NewDeleteTrainingJobLogic(ctx, s.svcCtx)
+	return l.DeleteTrainingJob(in)
+}
+
+// CreateTrainingJobConfig 创建训练作业参数
+func (s *ModelArtsServer) CreateTrainingJobConfig(ctx context.Context, in *modelarts.CreateTrainingJobConfigReq) (*modelarts.CreateTrainingJobConfigResp, error) {
+	l := logic.NewCreateTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.CreateTrainingJobConfig(in)
+}
+
+// DeleteTrainingJobConfig 删除训练作业参数
+func (s *ModelArtsServer) DeleteTrainingJobConfig(ctx context.Context, in *modelarts.DeleteTrainingJobConfigReq) (*modelarts.DeleteTrainingJobConfigResp, error) {
+	l := logic.NewDeleteTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.DeleteTrainingJobConfig(in)
+}
+
+// ListTrainingJobConfig 查询训练作业参数
+func (s *ModelArtsServer) ListTrainingJobConfig(ctx context.Context, in *modelarts.ListTrainingJobConfigReq) (*modelarts.ListTrainingJobConfigResp, error) {
+	l := logic.NewListTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.ListTrainingJobConfig(in)
+}
+
+// CreateAlgorithm 创建算法
+func (s *ModelArtsServer) CreateAlgorithm(ctx context.Context, in *modelarts.CreateAlgorithmReq) (*modelarts.CreateAlgorithmResp, error) {
+	l := logic.NewCreateAlgorithmLogic(ctx, s.svcCtx)
+	return l.CreateAlgorithm(in)
+}
+
+// ListAlgorithms 查询算法
+func (s *ModelArtsServer) ListAlgorithms(ctx context.Context, in *modelarts.ListAlgorithmsReq) (*modelarts.ListAlgorithmsResp, error) {
+	l := logic.NewListAlgorithmsLogic(ctx, s.svcCtx)
+	return l.ListAlgorithms(in)
+}
+
+// DeleteAlgorithms 删除算法
+func (s *ModelArtsServer) DeleteAlgorithms(ctx context.Context, in *modelarts.DeleteAlgorithmsReq) (*modelarts.DeleteAlgorithmsResp, error) {
+	l := logic.NewDeleteAlgorithmsLogic(ctx, s.svcCtx)
+	return l.DeleteAlgorithms(in)
+}
+
+// ShowAlgorithmByUuid 展示算法详情
+func (s *ModelArtsServer) ShowAlgorithmByUuid(ctx context.Context, in *modelarts.ShowAlgorithmByUuidReq) (*modelarts.ShowAlgorithmByUuidResp, error) {
+	l := logic.NewShowAlgorithmByUuidLogic(ctx, s.svcCtx)
+	return l.ShowAlgorithmByUuid(in)
+}
+
+// export task
+func (s *ModelArtsServer) ExportTask(ctx context.Context, in *modelarts.ExportTaskReq) (*modelarts.ExportTaskResp, error) {
+	l := logic.NewExportTaskLogic(ctx, s.svcCtx)
+	return l.ExportTask(in)
+}
+
+func (s *ModelArtsServer) GetExportTasksOfDataset(ctx context.Context, in *modelarts.GetExportTasksOfDatasetReq) (*modelarts.GetExportTasksOfDatasetResp, error) {
+	l := logic.NewGetExportTasksOfDatasetLogic(ctx, s.svcCtx)
+	return l.GetExportTasksOfDataset(in)
+}
+
+func (s *ModelArtsServer) GetExportTaskStatusOfDataset(ctx context.Context, in *modelarts.GetExportTaskStatusOfDatasetReq) (*modelarts.GetExportTaskStatusOfDatasetResp, error) {
+	l := logic.NewGetExportTaskStatusOfDatasetLogic(ctx, s.svcCtx)
+	return l.GetExportTaskStatusOfDataset(in)
+}
+
+// processor task
+func (s *ModelArtsServer) CreateProcessorTask(ctx context.Context, in *modelarts.CreateProcessorTaskReq) (*modelarts.CreateProcessorTaskResp, error) {
+	l := logic.NewCreateProcessorTaskLogic(ctx, s.svcCtx)
+	return l.CreateProcessorTask(in)
+}
+
+func (s *ModelArtsServer) DescribeProcessorTask(ctx context.Context, in *modelarts.DescribeProcessorTaskReq) (*modelarts.DescribeProcessorTaskResp, error) {
+	l := logic.NewDescribeProcessorTaskLogic(ctx, s.svcCtx)
+	return l.DescribeProcessorTask(in)
+}
+
+// model management
+func (s *ModelArtsServer) CreateModel(ctx context.Context, in *modelarts.CreateModelReq) (*modelarts.CreateModelResp, error) {
+	l := logic.NewCreateModelLogic(ctx, s.svcCtx)
+	return l.CreateModel(in)
+}
+
+func (s *ModelArtsServer) DeleteModel(ctx context.Context, in *modelarts.DeleteModelReq) (*modelarts.DeleteModelResp, error) {
+	l := logic.NewDeleteModelLogic(ctx, s.svcCtx)
+	return l.DeleteModel(in)
+}
+
+func (s *ModelArtsServer) ListModels(ctx context.Context, in *modelarts.ListModelReq) (*modelarts.ListModelResp, error) {
+	l := logic.NewListModelsLogic(ctx, s.svcCtx)
+	return l.ListModels(in)
+}
+
+func (s *ModelArtsServer) ShowModels(ctx context.Context, in *modelarts.ShowModelReq) (*modelarts.ShowModelResp, error) {
+	l := logic.NewShowModelsLogic(ctx, s.svcCtx)
+	return l.ShowModels(in)
+}
+
+// service management
+func (s *ModelArtsServer) CreateService(ctx context.Context, in *modelarts.CreateServiceReq) (*modelarts.CreateServiceResp, error) {
+	l := logic.NewCreateServiceLogic(ctx, s.svcCtx)
+	return l.CreateService(in)
+}
+
+func (s *ModelArtsServer) ListServices(ctx context.Context, in *modelarts.ListServicesReq) (*modelarts.ListServicesResp, error) {
+	l := logic.NewListServicesLogic(ctx, s.svcCtx)
+	return l.ListServices(in)
+}
+
+func (s *ModelArtsServer) ShowService(ctx context.Context, in *modelarts.ShowServiceReq) (*modelarts.ShowServiceResp, error) {
+	l := logic.NewShowServiceLogic(ctx, s.svcCtx)
+	return l.ShowService(in)
+}
+
+func (s *ModelArtsServer) DeleteService(ctx context.Context, in *modelarts.DeleteServiceReq) (*modelarts.DeleteServiceResp, error) {
+	l := logic.NewDeleteServiceLogic(ctx, s.svcCtx)
+	return l.DeleteService(in)
+}
+
+func (s *ModelArtsServer) ListClusters(ctx context.Context, in *modelarts.ListClustersReq) (*modelarts.ListClustersResp, error) {
+	l := logic.NewListClustersLogic(ctx, s.svcCtx)
+	return l.ListClusters(in)
+}
+
+// notebook task
+func (s *ModelArtsServer) ListNotebook(ctx context.Context, in *modelarts.ListNotebookReq) (*modelarts.ListNotebookResp, error) {
+	l := logic.NewListNotebookLogic(ctx, s.svcCtx)
+	return l.ListNotebook(in)
+}
+
+func (s *ModelArtsServer) CreateNotebook(ctx context.Context, in *modelarts.CreateNotebookReq) (*modelarts.CreateNotebookResp, error) {
+	l := logic.NewCreateNotebookLogic(ctx, s.svcCtx)
+	return l.CreateNotebook(in)
+}
+
+func (s *ModelArtsServer) StartNotebook(ctx context.Context, in *modelarts.StartNotebookReq) (*modelarts.StartNotebookResp, error) {
+	l := logic.NewStartNotebookLogic(ctx, s.svcCtx)
+	return l.StartNotebook(in)
+}
+
+func (s *ModelArtsServer) StopNotebook(ctx context.Context, in *modelarts.StopNotebookReq) (*modelarts.StopNotebookResp, error) {
+	l := logic.NewStopNotebookLogic(ctx, s.svcCtx)
+	return l.StopNotebook(in)
+}
+
+func (s *ModelArtsServer) GetNotebookStorage(ctx context.Context, in *modelarts.GetNotebookStorageReq) (*modelarts.GetNotebookStorageResp, error) {
+	l := logic.NewGetNotebookStorageLogic(ctx, s.svcCtx)
+	return l.GetNotebookStorage(in)
+}
+
+func (s *ModelArtsServer) MountNotebookStorage(ctx context.Context, in *modelarts.MountNotebookStorageReq) (*modelarts.MountNotebookStorageResp, error) {
+	l := logic.NewMountNotebookStorageLogic(ctx, s.svcCtx)
+	return l.MountNotebookStorage(in)
+}
+
+// visualization-jobs
+func (s *ModelArtsServer) GetVisualizationJob(ctx context.Context, in *modelarts.GetVisualizationJobReq) (*modelarts.GetVisualizationJobResp, error) {
+	l := logic.NewGetVisualizationJobLogic(ctx, s.svcCtx)
+	return l.GetVisualizationJob(in)
+}
+
+func (s *ModelArtsServer) CreateVisualizationJob(ctx context.Context, in *modelarts.CreateVisualizationJobReq) (*modelarts.CreateVisualizationJobResp, error) {
+	l := logic.NewCreateVisualizationJobLogic(ctx, s.svcCtx)
+	return l.CreateVisualizationJob(in)
+}

adaptor/AIComputing/modelarts/rpc/internal/svc/servicecontext.go

@@ -1,6 +1,8 @@
 package svc
 
-import "PCM/adaptor/slurm/slurmTianhe/rpc/internal/config"
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/config"
+)
 
 type ServiceContext struct {
 	Config config.Config