feat: 添加数据库资产、命令拦截器、授权资产等功能，修复GitHub Actions工作流

2026-04-18 07:44:18 +08:00
parent 6e2e2f9387
commit 3c217ab039
64 changed files with 3308 additions and 760 deletions
@@ -1,7 +1,13 @@
 package api

 import (
+	"context"
+	"strconv"
+
 	"next-terminal/server/common/maps"
+	"next-terminal/server/model"
+	"next-terminal/server/repository"
+	"next-terminal/server/utils"

 	"github.com/labstack/echo/v4"
 )
@@ -9,87 +15,493 @@ import (
 type AuthorisedAssetApi struct{}

 func (api AuthorisedAssetApi) PagingEndpoint(c echo.Context) error {
+	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
+	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
+	userId := c.QueryParam("userId")
+	departmentId := c.QueryParam("departmentId")
+	assetGroupId := c.QueryParam("assetGroupId")
+	assetId := c.QueryParam("assetId")
+
+	items, total, err := repository.AuthorisedAssetRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, assetGroupId, assetId)
+	if err != nil {
+		return err
+	}
+
+	if items == nil {
+		items = []map[string]interface{}{}
+	}
+
 	return Success(c, maps.Map{
-		"total": 0,
-		"items": []interface{}{},
+		"total": total,
+		"items": items,
 	})
 }

 func (api AuthorisedAssetApi) AuthorisedAssetsEndpoint(c echo.Context) error {
+	var req struct {
+		UserIds         []string `json:"userIds"`
+		DepartmentIds   []string `json:"departmentIds"`
+		AssetIds        []string `json:"assetIds"`
+		AssetGroupIds   []string `json:"assetGroupIds"`
+		CommandFilterId string   `json:"commandFilterId"`
+		StrategyId      string   `json:"strategyId"`
+		ExpiredAt       int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedAsset
+	for _, userId := range req.UserIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+	for _, departmentId := range req.DepartmentIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

 func (api AuthorisedAssetApi) AuthorisedUsersEndpoint(c echo.Context) error {
+	var req struct {
+		AssetIds        []string `json:"assetIds"`
+		AssetGroupIds   []string `json:"assetGroupIds"`
+		UserIds         []string `json:"userIds"`
+		CommandFilterId string   `json:"commandFilterId"`
+		StrategyId      string   `json:"strategyId"`
+		ExpiredAt       int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedAsset
+	for _, userId := range req.UserIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

 func (api AuthorisedAssetApi) AuthorisedDepartmentsEndpoint(c echo.Context) error {
+	var req struct {
+		AssetIds        []string `json:"assetIds"`
+		AssetGroupIds   []string `json:"assetGroupIds"`
+		DepartmentIds   []string `json:"departmentIds"`
+		CommandFilterId string   `json:"commandFilterId"`
+		StrategyId      string   `json:"strategyId"`
+		ExpiredAt       int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedAsset
+	for _, departmentId := range req.DepartmentIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

 func (api AuthorisedAssetApi) SelectedEndpoint(c echo.Context) error {
-	return Success(c, []string{})
+	expect := c.QueryParam("expect")
+	userId := c.QueryParam("userId")
+	departmentId := c.QueryParam("departmentId")
+	assetId := c.QueryParam("assetId")
+
+	result, err := repository.AuthorisedAssetRepository.Selected(context.TODO(), expect, userId, departmentId, assetId)
+	if err != nil {
+		return err
+	}
+	return Success(c, result)
 }

 func (api AuthorisedAssetApi) DeleteEndpoint(c echo.Context) error {
+	id := c.Param("id")
+	if err := repository.AuthorisedAssetRepository.DeleteById(context.TODO(), id); err != nil {
+		return err
+	}
 	return Success(c, nil)
 }

 func (api AuthorisedAssetApi) GetEndpoint(c echo.Context) error {
-	return Success(c, nil)
+	id := c.Param("id")
+	item, err := repository.AuthorisedAssetRepository.FindById(context.TODO(), id)
+	if err != nil {
+		return err
+	}
+	return Success(c, item)
 }

 func (api AuthorisedAssetApi) UpdateEndpoint(c echo.Context) error {
-	return Success(c, nil)
+	id := c.Param("id")
+	var item model.AuthorisedAsset
+	if err := c.Bind(&item); err != nil {
+		return err
+	}
+	item.ID = id
+	if err := repository.AuthorisedAssetRepository.UpdateById(context.TODO(), &item); err != nil {
+		return err
+	}
+	return Success(c, item)
 }

 func (api AuthorisedAssetApi) CreateEndpoint(c echo.Context) error {
+	var req struct {
+		UserIds         []string `json:"userIds"`
+		DepartmentIds   []string `json:"departmentIds"`
+		AssetIds        []string `json:"assetIds"`
+		AssetGroupIds   []string `json:"assetGroupIds"`
+		CommandFilterId string   `json:"commandFilterId"`
+		StrategyId      string   `json:"strategyId"`
+		ExpiredAt       int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedAsset
+	for _, userId := range req.UserIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+	for _, departmentId := range req.DepartmentIds {
+		for _, assetId := range req.AssetIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetId:         assetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+		for _, assetGroupId := range req.AssetGroupIds {
+			items = append(items, model.AuthorisedAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				AssetGroupId:    assetGroupId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

 type AuthorisedDatabaseAssetApi struct{}

 func (api AuthorisedDatabaseAssetApi) PagingEndpoint(c echo.Context) error {
+	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
+	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
+	userId := c.QueryParam("userId")
+	departmentId := c.QueryParam("departmentId")
+	databaseAssetId := c.QueryParam("assetId")
+
+	items, total, err := repository.AuthorisedDatabaseAssetRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, databaseAssetId)
+	if err != nil {
+		return err
+	}
+
+	if items == nil {
+		items = []map[string]interface{}{}
+	}
+
 	return Success(c, maps.Map{
-		"total": 0,
-		"items": []interface{}{},
+		"total": total,
+		"items": items,
 	})
 }

 func (api AuthorisedDatabaseAssetApi) SelectedEndpoint(c echo.Context) error {
-	return Success(c, []string{})
+	expect := c.QueryParam("expect")
+	userId := c.QueryParam("userId")
+	departmentId := c.QueryParam("departmentId")
+	databaseAssetId := c.QueryParam("assetId")
+
+	result, err := repository.AuthorisedDatabaseAssetRepository.Selected(context.TODO(), expect, userId, departmentId, databaseAssetId)
+	if err != nil {
+		return err
+	}
+	return Success(c, result)
 }

 func (api AuthorisedDatabaseAssetApi) DeleteEndpoint(c echo.Context) error {
+	id := c.Param("id")
+	if err := repository.AuthorisedDatabaseAssetRepository.DeleteById(context.TODO(), id); err != nil {
+		return err
+	}
 	return Success(c, nil)
 }

 func (api AuthorisedDatabaseAssetApi) GetEndpoint(c echo.Context) error {
-	return Success(c, nil)
+	id := c.Param("id")
+	item, err := repository.AuthorisedDatabaseAssetRepository.FindById(context.TODO(), id)
+	if err != nil {
+		return err
+	}
+	return Success(c, item)
 }

 func (api AuthorisedDatabaseAssetApi) UpdateEndpoint(c echo.Context) error {
-	return Success(c, nil)
+	id := c.Param("id")
+	var item model.AuthorisedDatabaseAsset
+	if err := c.Bind(&item); err != nil {
+		return err
+	}
+	item.ID = id
+	if err := repository.AuthorisedDatabaseAssetRepository.UpdateById(context.TODO(), &item); err != nil {
+		return err
+	}
+	return Success(c, item)
 }

 func (api AuthorisedDatabaseAssetApi) CreateEndpoint(c echo.Context) error {
+	var req struct {
+		UserIds          []string `json:"userIds"`
+		DepartmentIds    []string `json:"departmentIds"`
+		DatabaseAssetIds []string `json:"assetIds"`
+		CommandFilterId  string   `json:"commandFilterId"`
+		StrategyId       string   `json:"strategyId"`
+		ExpiredAt        int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedDatabaseAsset
+	for _, userId := range req.UserIds {
+		for _, databaseAssetId := range req.DatabaseAssetIds {
+			items = append(items, model.AuthorisedDatabaseAsset{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				DatabaseAssetId: databaseAssetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+	for _, departmentId := range req.DepartmentIds {
+		for _, databaseAssetId := range req.DatabaseAssetIds {
+			items = append(items, model.AuthorisedDatabaseAsset{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				DatabaseAssetId: databaseAssetId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedDatabaseAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

 type AuthorisedWebsiteApi struct{}

 func (api AuthorisedWebsiteApi) PagingEndpoint(c echo.Context) error {
+	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
+	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
+	userId := c.QueryParam("userId")
+	departmentId := c.QueryParam("departmentId")
+	websiteId := c.QueryParam("websiteId")
+
+	items, total, err := repository.AuthorisedWebsiteRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, websiteId)
+	if err != nil {
+		return err
+	}
+
+	if items == nil {
+		items = []map[string]interface{}{}
+	}
+
 	return Success(c, maps.Map{
-		"total": 0,
-		"items": []interface{}{},
+		"total": total,
+		"items": items,
 	})
 }

 func (api AuthorisedWebsiteApi) DeleteEndpoint(c echo.Context) error {
+	id := c.Param("id")
+	if err := repository.AuthorisedWebsiteRepository.DeleteById(context.TODO(), id); err != nil {
+		return err
+	}
 	return Success(c, nil)
 }

 func (api AuthorisedWebsiteApi) CreateEndpoint(c echo.Context) error {
+	var req struct {
+		UserIds         []string `json:"userIds"`
+		DepartmentIds   []string `json:"departmentIds"`
+		WebsiteIds      []string `json:"websiteIds"`
+		CommandFilterId string   `json:"commandFilterId"`
+		StrategyId      string   `json:"strategyId"`
+		ExpiredAt       int64    `json:"expiredAt"`
+	}
+	if err := c.Bind(&req); err != nil {
+		return err
+	}
+
+	var items []model.AuthorisedWebsite
+	for _, userId := range req.UserIds {
+		for _, websiteId := range req.WebsiteIds {
+			items = append(items, model.AuthorisedWebsite{
+				ID:              utils.UUID(),
+				UserId:          userId,
+				WebsiteId:       websiteId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+	for _, departmentId := range req.DepartmentIds {
+		for _, websiteId := range req.WebsiteIds {
+			items = append(items, model.AuthorisedWebsite{
+				ID:              utils.UUID(),
+				DepartmentId:    departmentId,
+				WebsiteId:       websiteId,
+				CommandFilterId: req.CommandFilterId,
+				StrategyId:      req.StrategyId,
+				ExpiredAt:       req.ExpiredAt,
+			})
+		}
+	}
+
+	if len(items) > 0 {
+		if err := repository.AuthorisedWebsiteRepository.CreateInBatches(context.TODO(), items); err != nil {
+			return err
+		}
+	}
+
 	return Success(c, nil)
 }

@@ -139,9 +551,9 @@ type DnsProviderApi struct{}

 func (api DnsProviderApi) GetConfigEndpoint(c echo.Context) error {
 	return Success(c, maps.Map{
-		"ok":      false,
-		"email":   "",
-		"type":    "",
+		"ok":    false,
+		"email": "",
+		"type":  "",
 	})
 }

@@ -163,12 +575,12 @@ func (api LicenseApi) GetMachineIdEndpoint(c echo.Context) error {

 func (api LicenseApi) GetLicenseEndpoint(c echo.Context) error {
 	return Success(c, maps.Map{
-		"type":      "free",
-		"machineId": "",
-		"asset":     0,
+		"type":       "free",
+		"machineId":  "",
+		"asset":      0,
 		"concurrent": 0,
-		"user":      0,
-		"expired":   0,
+		"user":       0,
+		"expired":    0,
 	})
 }