background/controller/file.go

package controller

import (
	"background/db"
	"background/model"
	"background/utils"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"io/ioutil"
	"log"
	"math"
	"net/http"
	"os"
	"strconv"
	"strings"

	"github.com/disintegration/imaging"
	"github.com/gin-gonic/gin"
	json "github.com/json-iterator/go"
	"github.com/nfnt/resize"
	uuid "github.com/satori/go.uuid"

	// "github.com/nfnt/resize"
	// "image/jpeg"
	"image/gif"
	// "strings"
)

type FileController struct {
}

func (this *FileController) OnUploadDoc(c *gin.Context) {
	// uid, e := uuid.NewV1()
	// if nil != e {
	// 	log.Print(e.Error())
	// 	return
	// }
	// imgtype := c.Query("type")
	// log.Print(imgtype)
	// file, _, err := c.Request.FormFile("doc")
	// if nil != err || nil == file {
	// 	log.Print(err.Error())
	// 	return
	// }

	// img, name, err := image.Decode(file)
	// if nil != err {
	// 	log.Print(err.Error())
	// 	return
	// }
	// dx := img.Bounds().Dx()
	// // resize to width 1000 using Lanczos resampling
	// // and preserve aspect ratio
	// if dx > 800 {
	// 	dx = dx / 2
	// }
	// m := resize.Resize(uint(dx), 0, img, resize.Lanczos3)

	// datout, err := os.Create("image/" + uid.String() + "." + name)
	// defer datout.Close()
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// jpeg.Encode(datout, m, nil)
	// c.JSON(200, map[string]interface{}{"url": uid.String() + "." + name})

}

func (this *FileController) OnUpload(c *gin.Context) {
	uid, e := uuid.NewV1()
	if nil != e {
		log.Print(e.Error())
		return
	}
	imgtype := c.Query("type")
	log.Print(imgtype)
	file, _, err := c.Request.FormFile("image")
	if nil != err || nil == file {
		log.Print(err.Error())
		return
	}

	if imgtype == "gif" {
		allgifs, er := gif.DecodeAll(file)
		if nil != er {
			log.Print("decode error", er.Error())
			return
		}

		datout, err := os.Create("image/" + uid.String() + ".gif")
		defer datout.Close()
		if err != nil {
			log.Fatal(err)
			return
		}

		gif.EncodeAll(datout, allgifs)
		c.JSON(200, map[string]interface{}{"url": uid.String() + ".gif"})
	} else {
		img, name, err := image.Decode(file)
		if nil != err {
			log.Print(err.Error())
			return
		}
		dx := img.Bounds().Dx()
		// resize to width 1000 using Lanczos resampling
		// and preserve aspect ratio
		if dx > 800 {
			dx = dx / 2
		}
		m := resize.Resize(uint(dx), 0, img, resize.Lanczos3)

		datout, err := os.Create("image/" + uid.String() + "." + name)
		defer datout.Close()
		if err != nil {
			log.Fatal(err)
		}
		jpeg.Encode(datout, m, nil)
		c.JSON(200, map[string]interface{}{"url": uid.String() + "." + name})
	}

}

func (this *FileController) OnUploadOrigin(c *gin.Context) {
	uid, e := uuid.NewV1()
	if nil != e {
		log.Print(e.Error())
		return
	}
	imgtype := c.Query("type")
	file, _, err := c.Request.FormFile("image")
	if nil != err || nil == file {
		log.Print(err.Error())
		return
	}

	if imgtype == "gif" {
		allgifs, er := gif.DecodeAll(file)
		if nil != er {
			log.Print("decode error", er.Error())
			return
		}

		datout, err := os.Create("image/" + uid.String() + ".gif")
		defer datout.Close()
		if err != nil {
			log.Fatal(err)
			return
		}

		gif.EncodeAll(datout, allgifs)
		c.JSON(200, map[string]interface{}{"url": uid.String() + ".gif"})
	} else {
		img, name, err := image.Decode(file)
		if nil != err {
			log.Print(err.Error())
			return
		}
		dx := img.Bounds().Dx()
		// resize to width 1000 using Lanczos resampling
		// and preserve aspect ratio

		m := resize.Resize(uint(dx), 0, img, resize.Lanczos3)

		datout, err := os.Create("image/" + uid.String() + "." + name)
		defer datout.Close()
		if err != nil {
			log.Fatal(err)
		}
		jpeg.Encode(datout, m, nil)
		c.JSON(200, map[string]interface{}{"url": uid.String() + "." + name})
	}
}

func (this *FileController) FileList(c *gin.Context) {
	var nodes utils.FileDesc
	path := c.Query("path")
	utils.GetPathFileName("files\\"+path, &nodes)
	log.Print(nodes)
	bs, e := json.Marshal(nodes)
	if nil != e {
		log.Print(e.Error())
	}
	log.Print(string(bs))
	c.JSON(200, map[string]interface{}{
		"msg":    "ok",
		"status": 200,
		"files":  nodes,
	})
}

func (this *FileController) FileType(c *gin.Context) {

}

func (this *FileController) DownloadFile(c *gin.Context) {
	resp := RespBase{Msg: "FAIL", Status: 211}
	filename := c.Query("filename")
	file, e := os.Open("files//" + filename)
	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)
		return
	}
	bytes, e := ioutil.ReadAll(file)
	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)
		return
	}
	c.Header("X-Content-Type-Options", "nosniff")
	c.Header("Content-Disposition",
		"/files/"+filename)
	c.Writer.Write(bytes)

}
func myAtoi(str string) int {
	num := 0
	s := ""
	flag := false
	str = strings.TrimSpace(str)
	if len(str) == 0 {
		return 0
	}
	for i := 0; i < len(str); i++ {
		if !(str[i] >= '0' && str[i] <= '9') && !(str[i] == '+' || str[i] == '-') {
			break
		}
		if str[i] == '+' {
			if flag || s != "" {
				break
			}
			flag = true
			continue
		}
		if str[i] == '-' {
			if flag || s != "" {
				break
			}
			flag = true
			s += "-"
			continue
		}
		s += string(str[i])
	}
	num, _ = strconv.Atoi(s)
	if num > math.MaxInt32 {
		return math.MaxInt32
	} else if num < math.MinInt32 {
		return math.MinInt32
	}
	return num
}

func (this *FileController) OnFileUploadFileMarkdown(c *gin.Context) {
	parent := c.Query("parent")
	filename := c.Query("filename")
	file, _, err := c.Request.FormFile("file")
	if nil != err || nil == file {
		log.Print(err.Error())
		return
	}
	bytes, err := ioutil.ReadAll(file)
	if nil != err {
		log.Print(err.Error())
		return
	}
	log.Print(parent, filename, string(bytes))

	query := fmt.Sprintf("select * from doc_copy1 where doc_copy1.id = '%d'", int32(myAtoi(parent)))
	docs := []model.DocTree{}
	e := db.GetMysqlClient().Query2(query, &docs)
	if nil != e {
		log.Print(e.Error())
		return
	}
	if len(docs) == 0 {
		return
	}

	fork := strings.ReplaceAll(string(bytes), "\\\\", "\\\\\\\\")
	fork = strings.ReplaceAll(string(fork), "\\", "\\\\")

	e = model.CreateDocTree(
		model.DocTree{
			Title:    filename,
			Content:  fork,
			Author:   "admin",
			IsPublic: 1,
			Father:   int32(myAtoi(parent)),
			Level:    docs[0].Level + 1,
		},
	)
	if nil != e {
		log.Printf(e.Error())
	}
	c.JSON(200, map[string]interface{}{"msg": "ok"})
}

func (this *FileController) OnFileUploadFile(c *gin.Context) {
	path := c.Query("path")
	filename := c.Query("filename")
	file, _, err := c.Request.FormFile("file")
	if nil != err || nil == file {
		log.Print(err.Error())
		return
	}
	bytes, err := ioutil.ReadAll(file)
	if nil != err {
		log.Print(err.Error())
		return
	}
	header := make([]byte, 512)
	copy(header, bytes)
	types := http.DetectContentType(header)
	log.Print(types)
	// jpg
	defer file.Close()
	out, err := os.Create("files/" + path + "/" + filename)
	if err != nil {
		log.Print(err)
	}
	defer out.Close()
	out.Write(bytes)
	log.Print(len(bytes))
	c.JSON(200, map[string]interface{}{"msg": "ok"})
}

func (this *FileController) OnThumbnail(c *gin.Context) {
	resp := RespBase{Msg: "FAIL", Status: 211}

	fileName := c.Param("file")
	if "" == fileName {
		c.JSON(200, resp)

		return
	}
	// input files
	files := []string{"/home/ubuntu/api/bin/image/" + fileName}

	// load images and make 100x100 thumbnails of them
	var thumbnails []image.Image
	for _, file := range files {
		img, err := imaging.Open(file)
		if err != nil {
			panic(err)
		}
		thumb := imaging.Thumbnail(img, 100, 100, imaging.CatmullRom)
		thumbnails = append(thumbnails, thumb)
	}

	// create a new blank image
	dst := imaging.New(100*len(thumbnails), 100, color.NRGBA{0, 0, 0, 0})

	// paste thumbnails into the new image side by side
	for i, thumb := range thumbnails {
		dst = imaging.Paste(dst, thumb, image.Pt(i*100, 0))
	}

	// save the combined image to file
	err := imaging.Save(dst, "/home/ubuntu/api/bin/image/thumbnail_"+fileName)
	if err != nil {
		log.Print(err.Error())
		return
	}
	// open file
	file, e := os.Open("/home/ubuntu/api/bin/image/thumbnail_" + fileName)
	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)

		return
	}
	defer file.Close()
	bytes, e := ioutil.ReadAll(file)
	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)

		return
	}
	c.Header("X-Content-Type-Options", "nosniff")
	c.Header("Content-Type", "image/png")
	c.Header("Content-Disposition",
		"/image/"+fileName)
	c.Writer.Write(bytes)
}

func (this *FileController) OnDownLoad(c *gin.Context) {
	resp := RespBase{Msg: "FAIL", Status: 211}

	fileName := c.Param("file")
	if "" == fileName {
		c.JSON(200, resp)

		return
	}
	file, e := os.Open(utils.GetCurrentDirectory() + "/image/" + fileName)

	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)

		return
	}
	defer file.Close()
	bytes, e := ioutil.ReadAll(file)
	if nil != e {
		log.Print(e.Error())
		c.JSON(200, resp)

		return
	}
	c.Header("X-Content-Type-Options", "nosniff")
	c.Header("Content-Type", "image/png")
	c.Header("Content-Disposition",
		"/image/"+fileName)
	c.Writer.Write(bytes)
}