back/internal/v2/lib/common/function.go

package common

import (
	"errors"
	"fmt"
	"image"
	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"recook/internal/static_path"
	"recook/internal/v2/model/gys/user"
	"recook/internal/v2/model/recook/manage"
	"recook/tools"
	"reflect"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/shopspring/decimal"
)

// @Style 获取登录管理账号信息
func GetManageUser(c *gin.Context) (manage.RecookManageUserInfoModel, error) {
	userInfo, flag := c.Get("manageUserInfo")
	if flag {
		return userInfo.(manage.RecookManageUserInfoModel), nil
	}
	return manage.RecookManageUserInfoModel{}, errors.New("未登录")
}

// @Style 获取登录管理账号信息
func GetManageMainId(c *gin.Context) (uint, error) {
	userInfo, flag := c.Get("manageUserInfo")
	if flag {
		user := userInfo.(manage.RecookManageUserInfoModel)
		return user.Id, nil
	}
	return 0, errors.New("未登录")
}

// @Style 获取登录管理账号信息
func GetGysUser(c *gin.Context) (user.GysUsersModel, error) {
	userInfo, flag := c.Get("gysInfo")
	if flag {
		return userInfo.(user.GysUsersModel), nil
	}
	return user.GysUsersModel{}, errors.New("未登录")
}

// @Style 获取登录管理账号信息
func GetGysMainId(c *gin.Context) (uint, error) {
	userInfo, flag := c.Get("gysInfo")
	if flag {
		user := userInfo.(user.GysUsersModel)
		if user.MainId != 0 {
			return user.MainId, nil
		}
		return user.Id, nil
	}
	return 0, errors.New("未登录")
}

//根据url保存图片
func UrlToImg(url, saveName string) (imgName string, width int, height int) {
	// don't worry about errors
	response, e := http.Get(url)
	if e != nil {
		log.Println(e)
		return "", 0, 0
	}
	defer response.Body.Close()

	//open a file for writing
	dateDir := CreateDateDir(filepath.Join(static_path.Dir.Root, saveName))
	imgName = filepath.Join("/", saveName, dateDir, tools.GenerateGoodsHashSign()+".jpg")
	file, err := os.Create(filepath.Join(static_path.Dir.Root, imgName))
	if err != nil {
		log.Println(err)
		return "", 0, 0
	}
	defer file.Close()

	// Use io.Copy to just dump the response body to the file. This supports huge files
	_, err = io.Copy(file, response.Body)
	if err != nil {
		log.Println(err)
		return "", 0, 0
	}

	file1, err := os.Open(filepath.Join(static_path.Dir.Root, imgName))
	if err != nil {
		fmt.Println("err0 = ", err)
		return
	}
	c, _, err := image.DecodeConfig(file1)
	if err != nil {
		fmt.Println("err1 = ", err)
		return
	}
	width = c.Width
	height = c.Height

	return imgName, width, height
}

// CreateDateDir 根据当前日期来创建文件夹
func CreateDateDir(Path string) string {
	folderName := time.Now().Format("20060102")
	folderPath := filepath.Join(Path, folderName)
	if _, err := os.Stat(folderPath); os.IsNotExist(err) {
		os.MkdirAll(folderPath, 0755)
	}
	return folderName
}

// @Style 结构体转map
func StructToMap(obj interface{}) map[string]interface{} {
	obj1 := reflect.TypeOf(obj)
	obj2 := reflect.ValueOf(obj)

	var data = make(map[string]interface{})
	for i := 0; i < obj1.NumField(); i++ {
		data[obj1.Field(i).Name] = obj2.Field(i).Interface()
	}
	return data
}

// @Style 是否在数组中
func InArray(need interface{}, data interface{}) bool {
	if datas, ok := data.([]int); ok {
		for _, item := range datas {
			if item == need {
				return true
			}
		}
	}
	if datas, ok := data.([]string); ok {
		for _, item := range datas {
			if item == need {
				return true
			}
		}
	}
	return false
}

// @Style 图片大小
func ImageSize(filePath string) (*image.Point, error) {
	open, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer open.Close()
	img, _, err := image.Decode(open)
	if err != nil {
		return nil, err
	}
	size := img.Bounds().Size()
	return &size, nil
}

// @Style decimal转float64
func DecimalToFloat(data decimal.Decimal) float64 {
	res, _ := data.Float64()
	return res
}

// @Style 删除数组值
func UnSetArrayVal(value []int, val int) []int {
	for index, item := range value {
		if item == val {
			return append(value[:index], value[index+1:]...)
		}
	}
	return value
}

type DataItem struct {
	Id       uint        `json:"id"`
	Name     string      `json:"name"`
	ParentId uint        `json:"parentId"`
	Children []*DataItem `json:"children"`
}

// @Style 生成树
func SelectTree(datas []DataItem) (result []DataItem) {
	result = []DataItem{}
	for i, item := range datas {
		if item.ParentId > 0 {
			for index, value := range datas {
				if item.ParentId == value.Id {
					datas[index].Children = append(datas[index].Children, &datas[i])
					break
				}
			}
		}
	}
	for _, item := range datas {
		if item.ParentId == 0 {
			result = append(result, item)
		}
	}
	return
}

// GetAppUserId @Style 获取app登录账号id
func GetAppUserId(c *gin.Context) (uint, error) {
	userId, flag := c.Get("appUserId")
	if flag {
		if uId, ok := userId.(uint); ok {
			return uId, nil
		}
	}
	return 0, errors.New("未登录")
}

// @Style 进制转换
func Radix(data uint, str ...string) (result string) {
	radixStr := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	if len(str) != 0 {
		radixStr = str[0]
	}
	strLen := uint(len(radixStr))
	for {
		result = string(radixStr[data%strLen]) + result
		data = data / strLen
		if data == 0 {
			return
		}
	}
}

func StringSliceContains(c []string, s string) bool {
	for _, v := range c {
		if v == s {
			return true
		}
	}
	return false
}