279 lines
7.7 KiB
Go
279 lines
7.7 KiB
Go
package fileUpload
|
||
|
||
import (
|
||
"bytes"
|
||
"fmt"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/net/ghttp"
|
||
"github.com/tiger1103/gfast/v3/api/v1/common/globe"
|
||
"io"
|
||
"log"
|
||
"os"
|
||
"path"
|
||
"strconv"
|
||
"strings"
|
||
)
|
||
|
||
func InitUploadApi(group *ghttp.RouterGroup) {
|
||
group.POST("/source/upload", SourceUploadFunc)
|
||
//group.Bind(new(SourceUpload))
|
||
}
|
||
|
||
type SourceUpload struct {
|
||
}
|
||
type SourceUploadReq struct {
|
||
g.Meta `path:"source/upload" dc:"上传资源" method:"post" tags:"资源相关" `
|
||
}
|
||
type SourceUploadRes struct {
|
||
}
|
||
|
||
/*func (SourceUpload) UploadFile(ctx context.Context, req *SourceUploadReq) (res *SourceUploadRes, err error) {
|
||
err = startSaveFile(g.RequestFromCtx(ctx))
|
||
return
|
||
}*/
|
||
|
||
func SourceUploadFunc(request *ghttp.Request) {
|
||
projectId := request.Get("projectId")
|
||
fmt.Println("projectId", projectId)
|
||
startSaveFile(request)
|
||
}
|
||
|
||
func startSaveFile(request *ghttp.Request) error {
|
||
err, filename := Upload(request, globe.SOURCE)
|
||
fmt.Println("结束了")
|
||
fmt.Println(err)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
fmt.Println(filename)
|
||
/* arr := strings.Split(filename, ".")
|
||
arr = arr[:len(arr)-1]
|
||
suffix := path.Ext(filename)
|
||
var SourceType = ""
|
||
switch suffix {
|
||
case globe.CLT:
|
||
SourceType = globe.TILESET
|
||
break
|
||
case globe.JCT:
|
||
SourceType = globe.TILESET
|
||
break
|
||
case globe.MBTILES:
|
||
SourceType = globe.LAYER
|
||
break
|
||
case globe.PAK:
|
||
//此时需要判断是地形还是正射
|
||
SourceType = globe.LAYER
|
||
break
|
||
}*/
|
||
//source := database.SOURCE{
|
||
// SourceID: tool.GetUuid(),
|
||
// SourceName: strings.Join(arr, "."),
|
||
// SourceType: SourceType,
|
||
// SourcePath: filename,
|
||
//}
|
||
//database.GetORMDBInstance().Model(&database.SOURCE{}).Create(&source)
|
||
return err
|
||
}
|
||
|
||
func Upload(r *ghttp.Request, dir string) (error, string) {
|
||
var contentLength int64
|
||
contentLength = r.Request.ContentLength
|
||
if contentLength <= 0 {
|
||
return globe.GetErrors("content_length error"), ""
|
||
}
|
||
content_type_, has_key := r.Request.Header["Content-Type"]
|
||
if !has_key {
|
||
return globe.GetErrors("Content-Type error"), ""
|
||
}
|
||
if len(content_type_) != 1 {
|
||
return globe.GetErrors("Content-Type count error"), ""
|
||
}
|
||
contentType := content_type_[0]
|
||
const BOUNDARY string = "; boundary="
|
||
loc := strings.Index(contentType, BOUNDARY)
|
||
if -1 == loc {
|
||
return globe.GetErrors("Content-Type error, no boundary"), ""
|
||
}
|
||
boundary := []byte(contentType[(loc + len(BOUNDARY)):])
|
||
readData := make([]byte, 1024*12)
|
||
var readTotal = 0
|
||
var des = ""
|
||
var filename = ""
|
||
for {
|
||
fileHeader, fileData, err := ParseFromHead(readData, readTotal, append(boundary, []byte("\r\n")...), r.Request.Body)
|
||
if err != nil {
|
||
return err, ""
|
||
}
|
||
filename = fileHeader.FileName
|
||
des = path.Join(dir, filename)
|
||
f, err := os.Create(des)
|
||
if err != nil {
|
||
return err, ""
|
||
}
|
||
f.Write(fileData)
|
||
fileData = nil
|
||
//需要反复搜索boundary
|
||
tempData, reachEnd, err := ReadToBoundary(boundary, r.Request.Body, f)
|
||
f.Close()
|
||
if err != nil {
|
||
return err, ""
|
||
}
|
||
if reachEnd {
|
||
break
|
||
} else {
|
||
copy(readData[0:], tempData)
|
||
readTotal = len(tempData)
|
||
continue
|
||
}
|
||
}
|
||
return nil, filename
|
||
}
|
||
|
||
// / 解析多个文件上传中，每个具体的文件的信息
|
||
type FileHeader struct {
|
||
ContentDisposition string
|
||
Name string
|
||
FileName string ///< 文件名
|
||
ContentType string
|
||
ContentLength int64
|
||
}
|
||
|
||
// / 解析描述文件信息的头部
|
||
// / @return FileHeader 文件名等信息的结构体
|
||
// / @return bool 解析成功还是失败
|
||
func ParseFileHeader(h []byte) (FileHeader, bool) {
|
||
arr := bytes.Split(h, []byte("\r\n"))
|
||
var out_header FileHeader
|
||
out_header.ContentLength = -1
|
||
const (
|
||
CONTENT_DISPOSITION = "Content-Disposition: "
|
||
NAME = "name=\""
|
||
FILENAME = "filename=\""
|
||
CONTENT_TYPE = "Content-Type: "
|
||
CONTENT_LENGTH = "Content-Length: "
|
||
)
|
||
for _, item := range arr {
|
||
if bytes.HasPrefix(item, []byte(CONTENT_DISPOSITION)) {
|
||
l := len(CONTENT_DISPOSITION)
|
||
arr1 := bytes.Split(item[l:], []byte("; "))
|
||
out_header.ContentDisposition = string(arr1[0])
|
||
if bytes.HasPrefix(arr1[1], []byte(NAME)) {
|
||
out_header.Name = string(arr1[1][len(NAME) : len(arr1[1])-1])
|
||
}
|
||
fmt.Println(arr1)
|
||
l = len(arr1[2])
|
||
if bytes.HasPrefix(arr1[2], []byte(FILENAME)) && arr1[2][l-1] == 0x22 {
|
||
out_header.FileName = string(arr1[2][len(FILENAME) : l-1])
|
||
}
|
||
} else if bytes.HasPrefix(item, []byte(CONTENT_TYPE)) {
|
||
l := len(CONTENT_TYPE)
|
||
out_header.ContentType = string(item[l:])
|
||
} else if bytes.HasPrefix(item, []byte(CONTENT_LENGTH)) {
|
||
l := len(CONTENT_LENGTH)
|
||
s := string(item[l:])
|
||
content_length, err := strconv.ParseInt(s, 10, 64)
|
||
if err != nil {
|
||
log.Printf("content length error:%s", string(item))
|
||
return out_header, false
|
||
} else {
|
||
out_header.ContentLength = content_length
|
||
}
|
||
} else {
|
||
log.Printf("unknown:%s\n", string(item))
|
||
}
|
||
}
|
||
if len(out_header.FileName) == 0 {
|
||
return out_header, false
|
||
}
|
||
return out_header, true
|
||
}
|
||
|
||
// / 从流中一直读到文件的末位
|
||
// / @return []byte 没有写到文件且又属于下一个文件的数据
|
||
// / @return bool 是否已经读到流的末位了
|
||
// / @return error 是否发生错误
|
||
func ReadToBoundary(boundary []byte, stream io.ReadCloser, target io.WriteCloser) ([]byte, bool, error) {
|
||
read_data := make([]byte, 1024*8)
|
||
read_data_len := 0
|
||
buf := make([]byte, 1024*4)
|
||
b_len := len(boundary)
|
||
reach_end := false
|
||
for !reach_end {
|
||
read_len, err := stream.Read(buf)
|
||
if err != nil {
|
||
if err != io.EOF && read_len <= 0 {
|
||
return nil, true, err
|
||
}
|
||
reach_end = true
|
||
}
|
||
//todo: 下面这一句很蠢，值得优化
|
||
copy(read_data[read_data_len:], buf[:read_len]) //追加到另一块buffer，仅仅只是为了搜索方便
|
||
read_data_len += read_len
|
||
if read_data_len < b_len+4 {
|
||
continue
|
||
}
|
||
loc := bytes.Index(read_data[:read_data_len], boundary)
|
||
if loc >= 0 {
|
||
//找到了结束位置
|
||
target.Write(read_data[:loc-4])
|
||
return read_data[loc:read_data_len], reach_end, nil
|
||
}
|
||
|
||
target.Write(read_data[:read_data_len-b_len-4])
|
||
copy(read_data[0:], read_data[read_data_len-b_len-4:])
|
||
read_data_len = b_len + 4
|
||
}
|
||
target.Write(read_data[:read_data_len])
|
||
return nil, reach_end, nil
|
||
}
|
||
|
||
// / 解析表单的头部
|
||
// / @param read_data 已经从流中读到的数据
|
||
// / @param read_total 已经从流中读到的数据长度
|
||
// / @param boundary 表单的分割字符串
|
||
// / @param stream 输入流
|
||
// / @return FileHeader 文件名等信息头
|
||
// / []byte 已经从流中读到的部分
|
||
// / error 是否发生错误
|
||
func ParseFromHead(read_data []byte, readTotal int, boundary []byte, stream io.ReadCloser) (FileHeader, []byte, error) {
|
||
buf := make([]byte, 1024*4)
|
||
foundBoundary := false
|
||
boundaryLoc := -1
|
||
var file_header FileHeader
|
||
for {
|
||
read_len, err := stream.Read(buf)
|
||
fmt.Println("read_len", read_len)
|
||
if err != nil {
|
||
if err != io.EOF {
|
||
return file_header, nil, err
|
||
}
|
||
break
|
||
}
|
||
if readTotal+read_len > cap(read_data) {
|
||
return file_header, nil, fmt.Errorf("not found boundary")
|
||
}
|
||
copy(read_data[readTotal:], buf[:read_len])
|
||
readTotal += read_len
|
||
if !foundBoundary {
|
||
boundaryLoc = bytes.Index(read_data[:readTotal], boundary)
|
||
if -1 == boundaryLoc {
|
||
continue
|
||
}
|
||
foundBoundary = true
|
||
}
|
||
start_loc := boundaryLoc + len(boundary)
|
||
file_head_loc := bytes.Index(read_data[start_loc:readTotal], []byte("\r\n\r\n"))
|
||
if -1 == file_head_loc {
|
||
continue
|
||
}
|
||
file_head_loc += start_loc
|
||
ret := false
|
||
file_header, ret = ParseFileHeader(read_data[start_loc:file_head_loc])
|
||
if !ret {
|
||
return file_header, nil, fmt.Errorf("ParseFileHeader fail:%s", string(read_data[start_loc:file_head_loc]))
|
||
}
|
||
return file_header, read_data[file_head_loc+4 : readTotal], nil
|
||
}
|
||
return file_header, nil, fmt.Errorf("reach to stream EOF")
|
||
}
|