lc_veterans/app/file/service/fileService.go

package service

import (
	"github.com/gin-gonic/gin"
	"io/ioutil"
	"iot_manager_service/app/file/dao"
	"iot_manager_service/app/file/model"
	userdao "iot_manager_service/app/user/dao"
	"iot_manager_service/util/common"
	"iot_manager_service/util/websocket"
	"net/http"
	"path"
	"strconv"
	"strings"
	"time"
)

// 用户管理服务
var FileService = new(fileService)

type fileService struct{}

func (f *fileService) Distribute(encryptedname, savepath string, requserfile *model.ReqSysUserFile, uid int) *common.Errors {
	file := &dao.File{
		OriginalName:  requserfile.OriginalName,
		EncryptedName: encryptedname,
		SavePath:      savepath,
		CategoryName:  requserfile.CategoryName,
		AuthId:        requserfile.AuthId,
		SuffixName:    path.Ext(requserfile.OriginalName),
		UploadTime:    time.Now(),
		Uploader:      uid,
		Icon:          strings.TrimPrefix(path.Ext(requserfile.OriginalName), ".") + ".png",
	}
	err := file.Create()
	if err != nil {
		return common.FailResponse("保存文件失败", nil)
	}
	//查询部门下对应的员工
	user := &userdao.SysUser{}
	users, err := user.GetDeptsSysUsers(requserfile.DeptsId)
	if err != nil {
		return common.FailResponse(err.Error(), nil)
	}
	var userfile []dao.SysUserFile
	for _, u := range users {
		userfile = append(userfile, dao.SysUserFile{
			Operator:        uid,
			Receiver:        u.ID,
			FileID:          file.ID,
			EffectiveDate:   requserfile.EffectiveDate,
			OperationStatus: "下发",
		})
	}
	userfiledao := &dao.SysUserFile{}
	err = userfiledao.BatchUFRecords(userfile)
	if err != nil {
		return common.FailResponse(err.Error(), nil)
	}

	//下发消息
	for _, u := range users {
		websocket.SendMessage(strconv.Itoa(u.ID), "您有新的文件，请注意查收！")
	}

	return common.SuccessResponse("新增记录成功", nil)
}

func (f *fileService) GetSysUserFiles(id string, search model.SearchSysUserFiles) *common.Errors {
	filedao := &dao.File{}
	uid, _ := strconv.Atoi(id)
	files, err := filedao.GetSysUserFiles(uid, search)
	if err != nil {
		return common.FailResponse(err.Error(), nil)
	}
	return common.SuccessResponse("查询成功", gin.H{"files": files})
}

func (f *fileService) GetFile(id string, c *gin.Context) {
	filedao := &dao.File{}
	file, err := filedao.GetFile(id)
	if err != nil {
		panic(err.Error())
	}
	encryptedData, err := ioutil.ReadFile(file.SavePath)
	if err != nil {
		panic(err.Error())
	}
	c.Header("Content-Disposition", "attachment;filename="+file.EncryptedName)
	c.Header("Content-Type", "application/octet-stream")
	c.Data(http.StatusOK, "application/octet-stream", encryptedData)
}

// 转发
func (f *fileService) ForwardingFile(uid, fileid int, users []int) *common.Errors {
	var userfile []dao.SysUserFile
	var nilTime *time.Time
	for _, u := range users {
		userfile = append(userfile, dao.SysUserFile{
			Operator:        uid,
			Receiver:        u,
			FileID:          fileid,
			EffectiveDate:   nilTime,
			OperationStatus: "转发",
		})
	}
	userfiledao := &dao.SysUserFile{}
	err := userfiledao.BatchUFRecords(userfile)
	if err != nil {
		return common.FailResponse(err.Error(), nil)

	}
	return common.SuccessResponse("新增记录成功", nil)
}