osm_sdk/osm_sdk.go

package osm_sdk

import (
	"git.sxidc.com/go-framework/baize/framework/core/api/response"
	"git.sxidc.com/go-tools/utils/http_client"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
	"io"
	"net/url"
	"strings"
	"time"
)

const TimeoutSec = 30

var timeoutDuration = TimeoutSec * time.Second

const servicePrefix = "/osm/api/v1"

var prefix string
var namespace string
var name string
var baseUrl string
var httpClient *http_client.Client

func Destroy() {
	if httpClient == nil {
		return
	}
	http_client.Destroy(httpClient)
	httpClient = nil
}

func Init(configPrefix string, configNamespace string, configName string, configBaseUrl string, duration time.Duration) error {
	if duration != 0 {
		timeoutDuration = duration
	}

	if strutils.IsStringEmpty(configNamespace) {
		return errors.New("namespace is empty")
	}

	if strutils.IsStringEmpty(configName) {
		return errors.New("name is empty")
	}

	if strutils.IsStringEmpty(configBaseUrl) {
		return errors.New("baseUrl is empty")
	}

	prefix = configPrefix
	namespace = configNamespace
	name = configName
	baseUrl = configBaseUrl + servicePrefix

	if httpClient == nil {
		httpClient = http_client.New()
	}

	return nil
}

func ExtractObjNameByUrl(urlStr string) (string, error) {
	if strutils.IsStringEmpty(urlStr) {
		return "", nil
	}

	parsed, err := url.Parse(urlStr)
	if err != nil {
		return "", err
	}

	objName, err := url.PathUnescape(parsed.Path)
	if err != nil {
		return "", err
	}

	return strings.TrimLeft(objName, "/"), nil
}

func GetUrl(objName string) (string, error) {
	return getUrl(objName)
}

func GetUrlWithPrefix(objName string) (string, error) {
	return getUrl(prefix + objName)
}

func getUrl(objName string) (string, error) {
	if strutils.IsStringEmpty(objName) {
		return "", nil
	}

	getResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Get(baseUrl+"/operation/url/get",
			http_client.WithRequestQueryParams(map[string]string{
				"namespace": namespace,
				"name":      name,
				"objName":   objName,
			}))
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = getResponse.Json(resp)
	if err != nil {
		return "", err
	}

	if !resp.Success {
		return "", errors.New(resp.Msg)
	}

	return resp.Info, nil
}

func ZoomUrl(objName, profess string) (string, error) {
	return zoomUrl(objName, profess)
}

func ZoomUrlWithPrefix(objName, profess string) (string, error) {
	return zoomUrl(prefix+objName, profess)
}

func zoomUrl(objName, process string) (string, error) {
	if strutils.IsStringEmpty(objName) {
		return "", nil
	}

	postResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Post(baseUrl+"/operation/obj/zoomUrl", ZoomUrlJsonBody{
			ConfigKey: ConfigKey{
				Namespace: namespace,
				Name:      name,
			},
			ObjName: objName,
			Process: process,
		})
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = postResponse.Json(resp)
	if err != nil {
		return "", err
	}

	if !resp.Success {
		return "", errors.New(resp.Msg)
	}

	return resp.Info, nil

}

func Exist(objName string) (bool, error) {
	return exist(objName)
}

func ExistWithPrefix(objName string) (bool, error) {
	return exist(prefix + objName)
}

func exist(objName string) (bool, error) {
	if strutils.IsStringEmpty(objName) {
		return false, nil
	}
	getResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).Get(baseUrl+"/operation/obj/check", http_client.WithRequestQueryParams(map[string]string{
		"namespace": namespace,
		"name":      name,
		"objName":   objName}))
	if err != nil {
		return false, err
	}

	resp := new(response.InfoResponse[bool])
	err = getResponse.Json(resp)
	if err != nil {
		return false, err
	}

	if !resp.Success {
		return false, errors.New(resp.Msg)
	}

	return true, nil
}

func DeleteMulti(objNames ...string) error {
	return deleteMulti(objNames...)
}

func DeleteMultiWithPrefix(userId string, objNames ...string) error {
	for i := range objNames {
		objNames[i] = prefix + objNames[i]
	}

	return deleteMulti(objNames...)
}

func deleteMulti(objNames ...string) error {
	if len(objNames) == 0 {
		return nil
	}
	postResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).Post(baseUrl+"/operation/obj/deleteMulti", DeleteMultiObjJsonBody{
		ConfigKey: ConfigKey{
			Namespace: namespace,
			Name:      name,
		},
		Prefix:   prefix,
		ObjNames: objNames,
	})
	if err != nil {
		return err
	}

	resp := new(response.MsgResponse)
	err = postResponse.Json(resp)
	if err != nil {
		return err
	}

	if !resp.Success {
		return errors.New(resp.Msg)
	}

	return nil
}

func ListDir(dirPath string) ([]string, error) {
	return listDir(dirPath)
}

func ListDirWithPrefix(dirPath string) ([]string, error) {
	return listDir(prefix + dirPath)
}

func listDir(dirPath string) ([]string, error) {
	if strutils.IsStringEmpty(dirPath) {
		return nil, nil
	}

	getResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).Get(baseUrl+"/operation/objPath/list", http_client.WithRequestQueryParams(map[string]string{
		"namespace": namespace,
		"name":      name,
		"dirPath":   dirPath,
	}))
	if err != nil {
		return nil, err
	}

	resp := new(response.InfoResponse[[]string])
	err = getResponse.Json(resp)
	if err != nil {
		return nil, err
	}

	if !resp.Success {
		return nil, errors.New(resp.Msg)
	}

	return resp.Info, nil
}

func LsDetails(dirPath string) ([]ObjectInfo, error) {
	return lsDetails(dirPath)
}

func LsDetailsWithPrefix(dirPath string) ([]ObjectInfo, error) {
	return lsDetails(prefix + dirPath)
}

type ObjectInfo struct {
	Key  string
	Type string
	Size int64
}

func lsDetails(dirPath string) ([]ObjectInfo, error) {
	if strutils.IsStringEmpty(dirPath) {
		return []ObjectInfo{}, nil
	}

	getResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Get(baseUrl+"/operation/objPath/listDetail", http_client.WithRequestQueryParams(map[string]string{
			"namespace": namespace,
			"name":      name,
			"dirPath":   dirPath,
		}))
	if err != nil {
		return nil, err
	}

	resp := new(response.InfoResponse[[]ObjectInfo])
	err = getResponse.Json(resp)
	if err != nil {
		return nil, err
	}

	if !resp.Success {
		return nil, errors.New(resp.Msg)
	}

	return resp.Info, nil

}

func Move(srcObjName, dstObjName string) (string, error) {
	return dstObjName, move(srcObjName, dstObjName, nil)
}

func MoveWithPrefix(srcObjName, dstObjName string) (string, error) {
	return prefix + dstObjName, move(prefix+srcObjName, prefix+dstObjName, nil)
}

func move(srcObjName, dstObjName string, requireInfos []string) error {
	if strutils.IsStringEmpty(srcObjName) {
		return nil
	}
	if strutils.IsStringEmpty(dstObjName) {
		return nil
	}
	putResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Put(baseUrl+"/operation/obj/move", MoveJsonBody{
			ConfigKey: ConfigKey{
				Namespace: namespace,
				Name:      name,
			},
			SrcObjName:   srcObjName,
			DstObjName:   dstObjName,
			RequireInfos: requireInfos,
			Prefix:       prefix,
		})
	if err != nil {
		return err
	}
	resp := new(response.InfoResponse[any])
	err = putResponse.Json(resp)
	if err != nil {
		return err
	}
	if !resp.Success {
		return errors.New(resp.Msg)
	}
	return nil
}

func Copy(srcObjName, dstObjName string) (string, error) {
	return dstObjName, copying(srcObjName, dstObjName, nil)
}

func CopyWithPrefix(srcObjName, dstObjName string) (string, error) {
	return prefix + dstObjName, copying(prefix+srcObjName, prefix+dstObjName, nil)
}

func copying(srcObjName, dstObjName string, requireInfos []string) error {
	if strutils.IsStringEmpty(srcObjName) {
		return nil
	}
	if strutils.IsStringEmpty(dstObjName) {
		return nil
	}

	postResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Post(baseUrl+"/operation/obj/copy", CopyJsonBody{
			ConfigKey: ConfigKey{
				Namespace: namespace,
				Name:      name,
			},
			SrcObjName:   srcObjName,
			DstObjName:   dstObjName,
			RequireInfos: requireInfos,
			Prefix:       prefix,
		})
	if err != nil {
		return err
	}

	resp := new(response.InfoResponse[any])
	err = postResponse.Json(resp)
	if err != nil {
		return err
	}

	if !resp.Success {
		return errors.New(resp.Msg)
	}

	return nil
}

func CopyPublic(srcObjName, dstObjName string) (string, error) {
	return dstObjName, copyPublic(srcObjName, dstObjName, nil)
}

func CopyPublicWithPrefix(srcObjName, dstObjName string) (string, error) {
	return prefix + dstObjName, copyPublic(prefix+srcObjName, prefix+dstObjName, nil)
}

func copyPublic(srcObjName, dstObjName string, requireInfos []string) error {
	if strutils.IsStringEmpty(srcObjName) {
		return nil
	}
	if strutils.IsStringEmpty(dstObjName) {
		return nil
	}

	postRequest := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration))
	postResponse, err := postRequest.Post(baseUrl+"/operation/obj/copyPublic", CopyJsonBody{
		ConfigKey: ConfigKey{
			Namespace: namespace,
			Name:      name,
		},
		SrcObjName:   srcObjName,
		DstObjName:   dstObjName,
		RequireInfos: requireInfos,
		Prefix:       prefix,
	})
	if err != nil {
		return err
	}
	resp := new(response.InfoResponse[any])
	err = postResponse.Json(resp)
	if err != nil {
		return err
	}

	if !resp.Success {
		return errors.New(resp.Msg)
	}

	return nil

}

func CreateImage(reader io.Reader, objName string) (string, error) {
	return createImage(reader, objName)
}

func CreateImageWithPrefix(reader io.Reader, objName string) (string, error) {
	return createImage(reader, prefix+objName)
}

func createImage(reader io.Reader, objName string) (string, error) {
	if strutils.IsStringEmpty(objName) {
		return "", nil
	}

	postResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Post(baseUrl+"/operation/obj/create/image", nil,
			http_client.WithRequestFileReader("file", objName, reader),
			http_client.WithRequestFormData(map[string]string{
				"namespace": namespace,
				"name":      name,
				"objName":   objName,
			}))
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = postResponse.Json(resp)
	if err != nil {
		return "", err
	}

	if !resp.Success {
		return "", errors.New(resp.Msg)
	}
	return resp.Info, nil
}

func CreateFile(reader io.Reader, objName string, contentType string) (string, error) {
	return createFile(reader, objName, contentType)
}

func CreateFileWithPrefix(reader io.Reader, objName string, contentType string) (string, error) {
	return createFile(reader, prefix+objName, contentType)
}

func createFile(reader io.Reader, objName string, contentType string) (string, error) {
	if strutils.IsStringEmpty(objName) {
		return "", nil
	}

	postResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Post(baseUrl+"/operation/obj/create/file", nil,
			http_client.WithRequestFileReader("file", objName, reader),
			http_client.WithRequestFormData(map[string]string{
				"namespace":   namespace,
				"name":        name,
				"objName":     objName,
				"contentType": contentType,
			}))
	if err != nil {
		return "", err
	}

	resp := new(response.InfoResponse[string])
	err = postResponse.Json(resp)
	if err != nil {
		return "", err
	}

	if !resp.Success {
		return "", errors.New(resp.Msg)
	}
	return resp.Info, nil
}

func GetUrlWithMetaData(objName string) (UrlWithMetaData, error) {
	return getUrlWithMetaData(objName)
}

func GetUrlUrlWithMetaDataWithPrefix(objName string) (UrlWithMetaData, error) {
	return getUrlWithMetaData(prefix + objName)
}

func getUrlWithMetaData(objName string) (UrlWithMetaData, error) {
	var errResponse UrlWithMetaData
	if strutils.IsStringEmpty(objName) {
		return errResponse, nil
	}

	getResponse, err := httpClient.NewRequest(http_client.WithNewRequestTimeout(timeoutDuration)).
		Get(baseUrl+"/operation/url/metaData/get",
			http_client.WithRequestQueryParams(map[string]string{
				"namespace": namespace,
				"name":      name,
				"objName":   objName,
			}))
	if err != nil {
		return errResponse, err
	}

	resp := new(response.InfoResponse[UrlWithMetaData])
	err = getResponse.Json(resp)
	if err != nil {
		return errResponse, err
	}

	if !resp.Success {
		return errResponse, errors.New(resp.Msg)
	}

	return resp.Info, nil
}

//func GetObjectBytes(obj string) ([]byte, error) {
//	if strutils.HasBlank(obj) {
//		return nil, errors.New("参数错误")
//	}
//	buf := new(bytes.Buffer)
//	body, err := Bkt.GetObject(prefix + obj)
//	if err != nil {
//		return nil, err
//	}
//	_, err = io.Copy(buf, body)
//	if err != nil {
//		return nil, err
//	}
//	err = body.Close()
//	if err != nil {
//		return nil, err
//	}
//
//	return buf.Bytes(), nil
//}

//func getObjectBytes(objName, userId string) ([]byte, error) {
//	if strutils.IsStringEmpty(objName) {
//		return nil, nil
//	}
//	if strutils.IsStringEmpty(objName) {
//		return nil, nil
//	}
//	buf := new(bytes.Buffer)
//
//	responseBytes, err := httpClient.GetWithoutHeaders(baseUrl+"/operation/obj/getContent", map[string]string{
//		"namespace": namespace,
//		"name":      name,
//		"objName":   objName,
//		"userId":    userId,
//	})
//	if err != nil {
//		return nil, err
//	}
//
//	resp := new(response.InfoResponse[[]byte])
//	err = json.Unmarshal(responseBytes, resp)
//	if err != nil {
//		return nil, err
//	}
//
//	if !resp.Success {
//		return nil, errors.New(resp.Msg)
//	}
//
//	//return resp.Info, nil
//	_, err = io.Copy(buf, resp.Info)
//	if err != nil {
//		return nil, err
//	}
//	err = body.Close()
//	if err != nil {
//		return nil, err
//	}
//
//	return buf.Bytes(), nil
//}