huangguo_server/web/service/exportser/export.go

package exportser

import (
	"container/list"
	"errors"
	"fmt"
	"path/filepath"
	"reflect"
	"strconv"
	"time"

	"91porn-server/common/constant"
	"91porn-server/common/file"
	"91porn-server/common/log"
	"91porn-server/models/s/statordermod"
	"91porn-server/models/s/statvidmod"
	"91porn-server/models/v/exchcodemod"
	"91porn-server/models/v/rchgordmod"
	"91porn-server/models/v/txnmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/wdordmod"

	"github.com/tealeg/xlsx"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

// Import 读取文件
func Import(inFile string) (data *list.List, errr error) {
	// 打开文件
	xlFile, err := xlsx.OpenFile(inFile)
	if err != nil {
		return nil, err
	}
	l := list.New()
	// 遍历sheet页读取
	for _, sheet := range xlFile.Sheets {
		fmt.Println("sheet name: ", sheet.Name)
		//遍历行读取
		for _, row := range sheet.Rows {
			var rowCell []string
			// 遍历每行的列读取
			for _, cell := range row.Cells {
				text := cell.String()
				rowCell = append(rowCell, text)
			}
			l.PushBack(rowCell)
		}
	}
	return l, nil
}

type Student struct {
	Name   string
	age    int
	Phone  string
	Gender string
	Mail   string
}

// Export 导出xlsx文件
func Export(typeFile int64) (string, error) {
	switch typeFile {
	case constant.ChannelLogTypeFile:
		return ExampleExport()
	default:
		return "", errors.New("not this type of excel")
	}
}

func ExampleExport() (string, error) {
	var fileName = "导出excel案列文件.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("导出excel案列")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	data := getStudents()
	//add data
	for _, stu := range data {
		row := sheet.AddRow()
		nameCell := row.AddCell()
		nameCell.Value = stu.Name
		ageCell := row.AddCell()
		ageCell.Value = strconv.Itoa(stu.age)
		phoneCell := row.AddCell()
		phoneCell.Value = stu.Phone
		genderCell := row.AddCell()
		genderCell.Value = stu.Gender
		mailCell := row.AddCell()
		mailCell.Value = stu.Mail
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	fmt.Println(fpath)
	if err = f.Save(fpath); err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	fmt.Println("\n\nexport success")
	return fpath, nil
}

func StructToTitle(s *xlsx.Sheet, obj interface{}) {
	t := reflect.TypeOf(obj)
	row := s.AddRow()
	for i := 0; i < t.NumField(); i++ {
		k, _ := t.Field(i).Tag.Lookup("json")
		c := row.AddCell()
		c.Value = k
	}
}

func StructToTitle2(s *xlsx.Sheet, obj interface{}, lableMap map[string]string) {
	t := reflect.TypeOf(obj)
	v := reflect.ValueOf(obj)
	row := s.AddRow()
	for i := 0; i < t.NumField(); i++ {
		vv := v.Field(i)
		fv := vv.Type()
		switch fv.Kind() {
		case reflect.Struct:
		}
		k, _ := t.Field(i).Tag.Lookup("json")
		lable, ok := lableMap[k]
		if !ok {
			lable = k
		}
		row.AddCell().Value = lable
	}
}

func getValue(kind reflect.Kind, value reflect.Value) string {
	switch kind {
	case reflect.String:
		return value.String()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return strconv.FormatInt(value.Int(), 10)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return strconv.FormatUint(value.Uint(), 10)
	case reflect.Bool:
		return strconv.FormatBool(value.Bool())
	case reflect.Float32, reflect.Float64:
		return strconv.FormatFloat(value.Float(), 'f', 2, 64)
	case reflect.Struct:
		timeV, ok := value.Interface().(time.Time)
		if ok {
			return timeV.String()
		}
		if oid, ok := value.Interface().(primitive.ObjectID); ok {
			return oid.Hex()
		}
		return ""
	case reflect.Interface:
		if timeV, ok := value.Interface().(time.Time); ok {
			return timeV.String()
		}
		return ""
	case reflect.Ptr:
		if value.IsNil() {
			return ""
		}
		value = value.Elem()
		if value.Interface() != nil {
			if timeV, ok := value.Interface().(time.Time); ok {
				return timeV.String()
			}
		} else {
			return ""
		}
	case reflect.Array:
		if id, ok := value.Interface().(primitive.ObjectID); ok {
			if id.IsZero() {
				return ""
			} else {
				return id.Hex()
			}
		}
	}
	return "未知"
}

func StructToRow(row *xlsx.Row, obj interface{}) error {
	t := reflect.TypeOf(obj)
	v := reflect.ValueOf(obj)
	for i := 0; i < t.NumField(); i++ {
		fv := v.Field(i).Type()
		vv := v.Field(i)
		c := row.AddCell()
		c.Value = getValue(fv.Kind(), vv)
	}
	return nil
}

func UserListExport(path string, index int, users []usermod.ExportUser) (string, error) {
	var fileName = fmt.Sprintf("用户列表_%v.xlsx", index)
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("用户列表")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, usermod.ExportUser{})
	//add data
	for _, u := range users {
		row := sheet.AddRow()
		_ = StructToRow(row, u)
	}
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	fmt.Println(fpath)
	err = f.Save(fpath)
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	fmt.Println("\n\nexport success")
	return fpath, nil
}

func getStudents() []Student {
	students := make([]Student, 10)
	for i := 0; i < 10; i++ {
		stu := Student{}
		stu.Name = "name" + strconv.Itoa(i+1)
		stu.Mail = stu.Name + "@chairis.cn"
		stu.Phone = "1380013800" + strconv.Itoa(i)
		stu.age = 20
		stu.Gender = "男"
		students[i] = stu
	}
	return students
}

// RechargeOrderExport 充值订单存xlsx
func RechargeOrderExport(orders []*rchgordmod.RchargeOrderExport) (string, error) {
	var fileName = "充值订单.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("充值订单")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, rchgordmod.RchargeOrderExport{})
	//add data
	for _, o := range orders {
		row := sheet.AddRow()
		_ = StructToRow(row, *o)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}

// WithdrawOrderExport 提现订单存xlsx
func WithdrawOrderExport(orders []*wdordmod.WithdrawOrder) (string, error) {
	var fileName = "提现订单.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("提现订单")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, wdordmod.WithdrawOrder{})
	//add data
	for _, o := range orders {
		row := sheet.AddRow()
		_ = StructToRow(row, *o)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}

// GoldTurnoverExport 金币流水存xlsx
func GoldTurnoverExport(turnover []*txnmod.TransactionLog) (string, error) {
	var fileName = "金币流水.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("金币流水")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, txnmod.TransactionLog{})
	//add data
	for _, t := range turnover {
		row := sheet.AddRow()
		_ = StructToRow(row, *t)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}

func changeVideoStatRecord(incomes []statvidmod.VideoStatRecord) []statvidmod.VideoStatExport {
	infos := make([]statvidmod.VideoStatExport, len(incomes))
	for i, v := range incomes {
		vs := statvidmod.VideoStatExport{}
		if v.SumDate != nil {
			vs.SumDate = *v.SumDate
		}
		if v.Video.ID != nil {
			vs.ID = *v.Video.ID
		}
		if v.Video.Title != nil {
			vs.Title = *v.Video.Title
		}
		if v.Video.PublisherID != nil {
			vs.PublisherID = *v.Video.PublisherID
		}
		if v.Video.Coins != nil {
			vs.Coins = *v.Video.Coins
		}
		if v.Income != nil {
			vs.Income = *v.Income
		}
		if v.Tax != nil {
			vs.Tax = *v.Tax
		}
		if v.PayCount != nil {
			vs.PayCount = *v.PayCount
		}
		if v.CreatedAt != nil {
			vs.CreatedAt = *v.CreatedAt
		}
		infos[i] = vs
	}
	return infos
}

// VideoIncomeExport 视频收入存xlsx
func VideoIncomeExport(incomes []statvidmod.VideoStatRecord) (string, error) {
	infos := changeVideoStatRecord(incomes)
	var fileName = "视频收入.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("视频收入")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, statvidmod.VideoStatExport{})
	//add data
	for _, i := range infos {
		row := sheet.AddRow()
		_ = StructToRow(row, i)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}

// OrderStatExport 订单统计存xlsx
func OrderStatExport(orders []statordermod.OrderState) (string, error) {
	var fileName = "订单统计.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("订单统计")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, statordermod.OrderState{})
	//add data
	for _, o := range orders {
		row := sheet.AddRow()
		_ = StructToRow(row, o)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}

// ExchangeCodeExport 兑换码导出
func ExchangeCodeExport(codes []exchcodemod.RespList) (string, error) {
	var fileName = "兑换码.xlsx"
	f := xlsx.NewFile()
	sheet, err := f.AddSheet("兑换码")
	if err != nil {
		fmt.Println(err.Error())
		return "", err
	}
	StructToTitle(sheet, exchcodemod.RespList{})
	//add data
	for _, c := range codes {
		row := sheet.AddRow()
		_ = StructToRow(row, c)
	}
	var path, _ = filepath.Abs("temp")
	if err = file.MakeDir(path); err != nil {
		log.Warn("can't make fs dir", log.E(err))
	}
	fpath := path + "/" + fileName
	if err = f.Save(fpath); err != nil {
		return "", err
	}
	return fpath, nil
}