baize/convenient/domain/sql_executor/api.go

package sql_executor

import (
	"git.sxidc.com/go-framework/baize/framework/binding"
	"git.sxidc.com/go-framework/baize/framework/binding/request"
	"git.sxidc.com/go-framework/baize/framework/binding/response"
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"git.sxidc.com/go-framework/baize/framework/core/domain"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/sql"
	"git.sxidc.com/go-tools/utils/strutils"
)

// Simple Bind参数
type Simple struct {
	// schema
	Schema string
}

func (simple *Simple) bind(binder *binding.Binder) {
	sqlExecuteLogTableName := domain.TableName(simple.Schema, &SqlExecuteLog{})

	binding.PostBind(binder, &binding.SimpleBindItem[map[string]any]{
		Path:          "/sql/execute",
		ResponseFunc:  response.SendMapResponse,
		RequestParams: &ExecuteSqlJsonBody{},
		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (map[string]any, error) {
			errResponse := map[string]any{
				"result": make([]sql.Result, 0),
			}

			dbExecutor := i.DBExecutor()

			jsonBody, err := request.ToConcrete[*ExecuteSqlJsonBody](params)
			if err != nil {
				return errResponse, err
			}

			var results []sql.Result

			err = database.Transaction(dbExecutor, func(tx database.Executor) error {
				innerResults, err := database.ExecuteRawSql(tx, jsonBody.Sql, nil)
				if err != nil {
					return err
				}

				sqlExecuteLog := &SqlExecuteLog{
					Sql:          jsonBody.Sql,
					ExecutorID:   jsonBody.ExecutorID,
					ExecutorName: jsonBody.ExecutorName,
				}

				err = sqlExecuteLog.ForCreate()
				if err != nil {
					return err
				}

				err = database.InsertEntity(tx, sqlExecuteLogTableName, sqlExecuteLog)
				if err != nil {
					return err
				}

				results = innerResults

				return nil
			})
			if err != nil {
				return errResponse, err
			}

			return map[string]any{
				"result": results,
			}, nil
		},
	})

	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[SqlExecuteLogInfo]]{
		Path:          "/sql/execute/log",
		ResponseFunc:  response.SendInfosResponse[SqlExecuteLogInfo],
		RequestParams: &QuerySqlExecuteLogQueryParams{},
		ServiceFunc: func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[SqlExecuteLogInfo], error) {
			errResponse := response.InfosData[SqlExecuteLogInfo]{
				Infos: make([]SqlExecuteLogInfo, 0),
			}

			dbExecutor := i.DBExecutor()

			queryParams, err := request.ToConcrete[*QuerySqlExecuteLogQueryParams](params)
			if err != nil {
				return errResponse, err
			}

			conditions := sql.NewConditions()

			if strutils.IsStringNotEmpty(queryParams.Sql) {
				conditions.Like(ColumnSql, "%"+queryParams.Sql+"%")
			}

			if strutils.IsStringNotEmpty(queryParams.ExecutorID) {
				conditions.Like(ColumnExecutorID, queryParams.ExecutorID)
			}

			if strutils.IsStringNotEmpty(queryParams.ExecutorName) {
				conditions.Like(ColumnExecutorName, "%"+queryParams.ExecutorName+"%")
			}

			if strutils.IsStringNotEmpty(queryParams.StartExecuteTime) {
				conditions.GreaterThanAndEqual(ColumnExecutedTime, queryParams.StartExecuteTime)
			}

			if strutils.IsStringNotEmpty(queryParams.EndExecuteTime) {
				conditions.LessThanAndEqual(ColumnExecutedTime, queryParams.EndExecuteTime)
			}

			results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
				TableName:  sqlExecuteLogTableName,
				Conditions: conditions,
				PageNo:     queryParams.PageNo,
				PageSize:   queryParams.PageSize,
			})
			if err != nil {
				return errResponse, nil
			}

			infos := make([]SqlExecuteLogInfo, 0)
			err = sql.ParseSqlResult(results, &infos)
			if err != nil {
				return errResponse, nil
			}

			return response.InfosData[SqlExecuteLogInfo]{
				Infos:      infos,
				TotalCount: totalCount,
				PageNo:     queryParams.PageNo,
			}, nil
		},
	})
}

func BindSqlExecutor(binder *binding.Binder, simple *Simple) {
	simple.bind(binder)
}