light-core/pkg/myOss/index.go

package myOss

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"io"
	"net/http"
	"strings"
)

type Model struct {
	Path             string
	Bucket           string
	ACLType          string
	Endpoint         string
	AccessKeyID      string
	SecretAccessKey  string
	StorageClassType string
	CdnUrl           string
	ossClient        *oss.Client
	ossBucket        *oss.Bucket
}

func (t *Model) MustGetOssClient() *oss.Client {
	if t.ossClient == nil {
		client, err := oss.New(t.Endpoint, t.AccessKeyID, t.SecretAccessKey, oss.Timeout(10, 120))
		if err != nil {
			panic("function oss.New() Filed, err:" + err.Error())
		}
		t.ossClient = client
	}
	return t.ossClient
}

func (t *Model) MustGetDefaultOssBucket() *oss.Bucket {
	if t.ossBucket == nil {
		client := t.MustGetOssClient()
		bucket, err := client.Bucket(t.Bucket)

		if err != nil {
			panic("function client.Bucket() Filed, err:" + err.Error())
		}
		t.ossBucket = bucket
	}
	return t.ossBucket
}

func (t *Model) PutObject(savePath, fileName string, reader io.Reader, contentType string) (*RespPath, error) {
	err := t.MustGetDefaultOssBucket().PutObject(
		fmt.Sprintf("%s/%s", savePath, fileName),
		reader,
		oss.ContentType(contentType),
		t.GetObjectStorageClass(),
		t.GetObjectAcl(),
	)
	return &RespPath{
		Path: savePath,
		Name: fileName,
		Host: t.CdnUrl,
	}, err

}

func (t *Model) MustPutObject(savePath, fileName string, reader io.Reader, contentType string) *RespPath {
	p, err := t.PutObject(savePath, fileName, reader, contentType)
	if err != nil {
		panic(err.Error())
	}
	return p
}

func (t *Model) GetObjectMeta(key string) (http.Header, error) {
	if strings.HasPrefix(key, "/") {
		key = strings.TrimLeft(key, "/")
	}
	return t.MustGetDefaultOssBucket().GetObjectMeta(key)
}

func (t *Model) DeleteObject(key string) error {
	// 删除单个文件。objectName表示删除OSS文件时需要指定包含文件后缀在内的完整路径，例如abc/efg/123.jpg。
	// 如需删除文件夹，请将objectName设置为对应的文件夹名称。如果文件夹非空，则需要将文件夹下的所有object删除后才能删除该文件夹。
	//这里需要处理一下路径，如果第一个是/，要去掉

	if strings.HasPrefix(key, "/") {
		key = strings.TrimLeft(key, "/")
	}
	if t.IsFileExist(key) {
		return t.MustGetDefaultOssBucket().DeleteObject(key)
	}
	return fmt.Errorf("文件不存在")
}

func (t *Model) IsFileExist(key string) bool {
	if strings.HasPrefix(key, "/") {
		key = strings.TrimLeft(key, "/")
	}
	exist, err := t.MustGetDefaultOssBucket().IsObjectExist(key)
	if err != nil {
		panic(err.Error())
	}
	return exist
}

func (t *Model) GetObjectStorageClass() oss.Option {
	switch t.StorageClassType { // 根据配置文件进行指定存储类型
	case "Standard": // 指定存储类型为标准存储
		return oss.ObjectStorageClass(oss.StorageStandard)
	case "IA": // 指定存储类型为很少访问存储
		return oss.ObjectStorageClass(oss.StorageIA)
	case "Archive": // 指定存储类型为归档存储。
		return oss.ObjectStorageClass(oss.StorageArchive)
	case "ColdArchive": // 指定存储类型为归档存储。
		return oss.ObjectStorageClass(oss.StorageColdArchive)
	default: // 无匹配结果就是标准存储
		return oss.ObjectStorageClass(oss.StorageStandard)
	}
}

func (t *Model) GetObjectAcl() oss.Option {
	switch t.ACLType { // 根据配置文件进行指定访问权限
	case "private": // 指定访问权限为私有读写
		return oss.ObjectACL(oss.ACLPrivate) // 指定访问权限为公共读
	case "public-read":
		return oss.ObjectACL(oss.ACLPublicRead) // 指定访问权限为公共读
	case "public-read-write":
		return oss.ObjectACL(oss.ACLPublicReadWrite) // 指定访问权限为公共读写
	case "default":
		return oss.ObjectACL(oss.ACLDefault) // 指定访问权限为公共读
	default:
		return oss.ObjectACL(oss.ACLPrivate) // 默认为访问权限为公共读
	}
}

type RespPath struct {
	Path string
	Name string
	Host string
}