github.com/qiniu/go-sdk/v7@v7.27.0/storagev2/apis/api_post_object.go

// THIS FILE IS GENERATED BY api-generator, DO NOT EDIT DIRECTLY!

package apis

import (
	"context"
	"net/http"
	"strconv"
	"strings"

	uplog "github.com/qiniu/go-sdk/v7/internal/uplog"
	postobject "github.com/qiniu/go-sdk/v7/storagev2/apis/post_object"
	errors "github.com/qiniu/go-sdk/v7/storagev2/errors"
	httpclient "github.com/qiniu/go-sdk/v7/storagev2/http_client"
	region "github.com/qiniu/go-sdk/v7/storagev2/region"
)

type innerPostObjectRequest postobject.Request

func (form *innerPostObjectRequest) getBucketName(ctx context.Context) (string, error) {
	putPolicy, err := form.UploadToken.GetPutPolicy(ctx)
	if err != nil {
		return "", err
	} else {
		return putPolicy.GetBucketName()
	}
}

func (form *innerPostObjectRequest) getObjectName() string {
	var objectName string
	if form.ObjectName != nil {
		objectName = *form.ObjectName
	}
	return objectName
}

func (form *innerPostObjectRequest) build(ctx context.Context) (*httpclient.MultipartForm, error) {
	multipartForm := new(httpclient.MultipartForm)
	if form.ObjectName != nil {
		multipartForm.SetValue("key", *form.ObjectName)
	}
	if form.UploadToken != nil {
		upToken, err := form.UploadToken.GetUpToken(ctx)
		if err != nil {
			return nil, err
		}
		multipartForm.SetValue("token", upToken)
	} else {
		return nil, errors.MissingRequiredFieldError{Name: "UploadToken"}
	}
	if form.Crc32 != 0 {
		multipartForm.SetValue("crc32", strconv.FormatInt(form.Crc32, 10))
	}
	if form.File.Data != nil {
		if form.File.Name == "" {
			return nil, errors.MissingRequiredFieldError{Name: "File.Name"}
		}
		multipartForm.SetFile("file", form.File.Name, form.File.ContentType, form.File.Data)
	} else {
		return nil, errors.MissingRequiredFieldError{Name: "File"}
	}
	for key, value := range form.CustomData {
		multipartForm.SetValue(key, value)
	}
	return multipartForm, nil
}

func (request *innerPostObjectRequest) getAccessKey(ctx context.Context) (string, error) {
	if request.UploadToken != nil {
		if accessKey, err := request.UploadToken.GetAccessKey(ctx); err != nil {
			return "", err
		} else {
			return accessKey, nil
		}
	}
	return "", nil
}

type (
	PostObjectRequest  = postobject.Request
	PostObjectResponse = postobject.Response
)

// 在一次 HTTP 会话中上传单一的一个文件
func (storage *Storage) PostObject(ctx context.Context, request *PostObjectRequest, options *Options) (*PostObjectResponse, error) {
	if options == nil {
		options = &Options{}
	}
	innerRequest := (*innerPostObjectRequest)(request)
	serviceNames := []region.ServiceName{region.ServiceUp}
	pathSegments := make([]string, 0)
	path := "/" + strings.Join(pathSegments, "/")
	var rawQuery string
	headers := http.Header{}
	body, err := innerRequest.build(ctx)
	if err != nil {
		return nil, err
	}
	bucketName := options.OverwrittenBucketName
	if bucketName == "" {
		var err error
		if bucketName, err = innerRequest.getBucketName(ctx); err != nil {
			return nil, err
		}
	}
	objectName := innerRequest.getObjectName()
	uplogInterceptor, err := uplog.NewRequestUplog("postObject", bucketName, objectName, nil)
	if err != nil {
		return nil, err
	}
	req := httpclient.Request{Method: "POST", ServiceNames: serviceNames, Path: path, RawQuery: rawQuery, Endpoints: options.OverwrittenEndpoints, Region: options.OverwrittenRegion, Interceptors: []httpclient.Interceptor{uplogInterceptor}, Header: headers, BufferResponse: true, RequestBody: httpclient.GetMultipartFormRequestBody(body), OnRequestProgress: options.OnRequestProgress}
	if options.OverwrittenEndpoints == nil && options.OverwrittenRegion == nil && storage.client.GetRegions() == nil {
		bucketHosts := httpclient.DefaultBucketHosts()
		if bucketName != "" {
			query := storage.client.GetBucketQuery()
			if query == nil {
				if options.OverwrittenBucketHosts != nil {
					if bucketHosts, err = options.OverwrittenBucketHosts.GetEndpoints(ctx); err != nil {
						return nil, err
					}
				}
				queryOptions := region.BucketRegionsQueryOptions{UseInsecureProtocol: storage.client.UseInsecureProtocol(), AccelerateUploading: storage.client.AccelerateUploadingEnabled(), HostFreezeDuration: storage.client.GetHostFreezeDuration(), Resolver: storage.client.GetResolver(), Chooser: storage.client.GetChooser(), BeforeResolve: storage.client.GetBeforeResolveCallback(), AfterResolve: storage.client.GetAfterResolveCallback(), ResolveError: storage.client.GetResolveErrorCallback(), BeforeBackoff: storage.client.GetBeforeBackoffCallback(), AfterBackoff: storage.client.GetAfterBackoffCallback(), BeforeRequest: storage.client.GetBeforeRequestCallback(), AfterResponse: storage.client.GetAfterResponseCallback()}
				if hostRetryConfig := storage.client.GetHostRetryConfig(); hostRetryConfig != nil {
					queryOptions.RetryMax = hostRetryConfig.RetryMax
					queryOptions.Backoff = hostRetryConfig.Backoff
				}
				if query, err = region.NewBucketRegionsQuery(bucketHosts, &queryOptions); err != nil {
					return nil, err
				}
			}
			if query != nil {
				var accessKey string
				var err error
				if accessKey, err = innerRequest.getAccessKey(ctx); err != nil {
					return nil, err
				}
				if accessKey == "" {
					if credentialsProvider := storage.client.GetCredentials(); credentialsProvider != nil {
						if creds, err := credentialsProvider.Get(ctx); err != nil {
							return nil, err
						} else if creds != nil {
							accessKey = creds.AccessKey
						}
					}
				}
				if accessKey != "" {
					req.Region = query.Query(accessKey, bucketName)
				}
			}
		}
	}
	ctx = httpclient.WithoutSignature(ctx)
	respBody := PostObjectResponse{Body: innerRequest.ResponseBody}
	if err := storage.client.DoAndAcceptJSON(ctx, &req, &respBody); err != nil {
		return nil, err
	}
	return &respBody, nil
}