[新功能]上传加密文件、增加用户文件记录表、退出登录等

app/file/controller/file.go

@@ -0,0 +1,67 @@
+package controller
+
+import (
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"iot_manager_service/app/file/model"
+	"iot_manager_service/app/file/service"
+	"iot_manager_service/util/cache"
+	"iot_manager_service/util/common"
+	"iot_manager_service/util/token"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+var FileController = new(file)
+
+type file struct{}
+
+func (f *file) Distribute(c *gin.Context) {
+	//获取当前用户
+	header := c.GetHeader("Authorization")
+	claims, _ := token.JwtClaims.ParseJwtToken(header)
+	nowUser, _ := cache.GetToken(claims.ID)
+
+	//TODO:校验签名 如果成功则上传否则不上传
+	formFile, err := c.FormFile("file")
+	if err != nil {
+		c.JSON(http.StatusOK, common.ParamsInvalidResponse("获取文件数据失败", nil))
+		return
+	}
+
+	//获取后缀
+	sufx := path.Ext(formFile.Filename)
+	//利用时间戳生成文件名
+	fileNameInt := time.Now().Unix()
+	fileNameStr := strconv.FormatInt(fileNameInt, 10)
+	//新的文件名
+	newfileName := fileNameStr + sufx
+	_, err = os.Stat("uploadfiles")
+	if os.IsNotExist(err) {
+		os.Mkdir("./uploadfiles", os.ModePerm)
+	}
+	//保存文件
+	filePath := filepath.Join("uploadfiles", "/", newfileName)
+	c.SaveUploadedFile(formFile, filePath)
+
+	//获取另外一个参数
+	str := c.Request.FormValue("req")
+	userFile := model.ReqUserFile{}
+	json.Unmarshal([]byte(str), &userFile)
+
+	savePath := "/uploadfiles/" + newfileName
+	distribute := service.FileService.Distribute(formFile.Filename, savePath, &userFile, nowUser.User.ID)
+
+	c.JSON(http.StatusOK, distribute)
+}
+
+func (f *file) GetUserFiles(c *gin.Context) {
+	header := c.GetHeader("Authorization")
+	claims, _ := token.JwtClaims.ParseJwtToken(header)
+	files := service.FileService.GetUserFiles(claims.ID)
+	c.JSON(http.StatusOK, files)
+}

app/file/dao/common.go

@@ -0,0 +1,19 @@
+package dao
+
+import (
+	"fmt"
+	"gorm.io/gorm"
+)
+
+var Db *gorm.DB
+
+func InitDB(db *gorm.DB) {
+	Db = db
+	err := Db.AutoMigrate(
+		&File{},
+		&UserFile{},
+	)
+	if err != nil {
+		panic(fmt.Sprintf("AutoMigrate err : %v", err))
+	}
+}

app/file/dao/file.go

@@ -0,0 +1,38 @@
+package dao
+
+import "time"
+
+// File 文件表
+type File struct {
+	ID            int       `gorm:"primary_key;type:int" json:"id"`                     //编号
+	OriginalName  string    `gorm:"type:varchar(45)" json:"originalName"`               //文件原始名
+	EncryptedName string    `gorm:"type:varchar(45)" json:"encryptedName"`              //文件加密名
+	SavePath      string    `gorm:"type:varchar(45)" json:"savePath"`                   //保存路径
+	CategoryName  string    `gorm:"type:varchar(12)" json:"categoryName"`               //文件类别名
+	AuthId        string    `gorm:"type:varchar(12);default:'100'" json:"authId"`       //权限id
+	SuffixName    string    `gorm:"type:varchar(12)" json:"suffixName"`                 //文件后缀名
+	UploadTime    time.Time `gorm:"column:upload_time;type:datetime" json:"uploadTime"` //上传时间
+	Uploader      int       `gorm:"type:int" json:"uploader"`                           //上传者id
+	IsShowed      int       `gorm:"type:int;default:0" json:"isShowed"`                 //收否展示 0=展示,1=不展示
+	IsDeleted     int       `gorm:"type:int;default:0" json:"isDeleted"`                //是否删除 0=未删除,1=删除
+}
+
+func (*File) TableName() string {
+	return "file"
+}
+
+func (f *File) Create() error {
+	return Db.Model(&f).Save(&f).Error
+}
+
+func (f *File) GetUserFiles(uid int) ([]File, error) {
+	var files []File
+	err := Db.Table("file").
+		Select("file.*").
+		Joins("left join user_file uf on uf.file_id = file.id").
+		Where("uf.receiver = ? AND file.is_showed = 0 AND file.is_deleted = 0", uid).
+		Order("upload_time DESC"). // 根据created_at字段降序排列
+		Scan(&files).
+		Error
+	return files, err
+}

app/file/dao/userfile.go

@@ -0,0 +1,21 @@
+package dao
+
+import "time"
+
+// UserFile 用户文件记录表
+type UserFile struct {
+	ID              int       `gorm:"primary_key;type:int" json:"id"`                                         //编号
+	Operator        int       `gorm:"type:int" json:"operator"`                                               //操作者id
+	Receiver        int       `gorm:"type:int" json:"receiver"`                                               //接收者id
+	FileID          int       `gorm:"type:int" json:"fileid"`                                                 //文件id
+	EffectiveDate   time.Time `gorm:"autoCreateTime;column:effectiveDate;type:datetime" json:"effectiveDate"` //阅读的有效日期
+	OperationStatus string    `gorm:"type:varchar(12)" json:"operationStatus"`                                //操作状态
+}
+
+func (*UserFile) TableName() string {
+	return "user_file"
+}
+
+func (uf *UserFile) BatchUFRecords(userfile []UserFile) error {
+	return Db.Model(&uf).Create(&userfile).Error
+}

app/file/model/file.go

@@ -0,0 +1,11 @@
+package model
+
+import "time"
+
+type ReqUserFile struct {
+	OriginalName  string    `json:"originalName"`  //文件原始名
+	AuthId        string    `json:"authId"`        //权限id
+	CategoryName  string    `json:"categoryName"`  //文件类别名
+	DeptsId       []int     `json:"deptsId"`       //下发的部门id
+	EffectiveDate time.Time `json:"effectiveDate"` //阅读的有效日期
+}

app/file/service/fileService.go

@@ -0,0 +1,66 @@
+package service
+
+import (
+	"github.com/gin-gonic/gin"
+	"iot_manager_service/app/file/dao"
+	"iot_manager_service/app/file/model"
+	userdao "iot_manager_service/app/user/dao"
+	"iot_manager_service/util/common"
+	"path"
+	"strconv"
+	"time"
+)
+
+// 用户管理服务
+var FileService = new(fileService)
+
+type fileService struct{}
+
+func (f *fileService) Distribute(encryptedname, savepath string, requserfile *model.ReqUserFile, 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,
+	}
+	err := file.Create()
+	if err != nil {
+		return common.FailResponse("保存文件失败", nil)
+	}
+	//查询部门下对应的员工
+	user := &userdao.User{}
+	users, err := user.GetDeptsUsers(requserfile.DeptsId)
+	if err != nil {
+		return common.FailResponse(err.Error(), nil)
+	}
+	var userfile []dao.UserFile
+	for _, u := range users {
+		userfile = append(userfile, dao.UserFile{
+			Operator:        uid,
+			Receiver:        u.ID,
+			FileID:          file.ID,
+			EffectiveDate:   requserfile.EffectiveDate,
+			OperationStatus: "上传",
+		})
+	}
+	userfiledao := &dao.UserFile{}
+	err = userfiledao.BatchUFRecords(userfile)
+	if err != nil {
+		return common.FailResponse(err.Error(), nil)
+	}
+	return common.SuccessResponse("新增记录成功", nil)
+}
+
+func (f *fileService) GetUserFiles(id string) *common.Errors {
+	filedao := &dao.File{}
+	uid, _ := strconv.Atoi(id)
+	files, err := filedao.GetUserFiles(uid)
+	if err != nil {
+		return common.FailResponse(err.Error(), nil)
+	}
+	return common.SuccessResponse("查询成功", gin.H{"files": files})
+}

app/middleware/token.go

@@ -14,7 +14,7 @@ func AuthMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		//如果包含路径/login则放行，其余的都要进行token认证
 		if strings.Contains(c.Request.RequestURI, "/login") ||
-			strings.Contains(c.Request.RequestURI, "/getpublicKey") {
+			strings.Contains(c.Request.RequestURI, "/getpublickey") {
 			c.Next()
 			return
 		}
@@ -33,8 +33,8 @@ func AuthMiddleware() gin.HandlerFunc {
 			return
 		}
 		//判断是不是最新一次的token，只有最新的有效，否则无效，不放行
-		redis_uuid, err := cache.GetToken(claims.ID)
-		if redis_uuid != claims.UUID || redis_uuid == "" || err != nil {
+		nowuser, err := cache.GetToken(claims.ID)
+		if nowuser.UUID != claims.UUID || nowuser == nil || err != nil {
 			c.JSON(http.StatusOK, common.ParamsInvalidResponse("Authorization失效", nil))
 			c.Abort()
 			return

app/user/controller/user.go

@@ -5,11 +5,13 @@ import (
 	"github.com/gin-gonic/gin"
 	"iot_manager_service/app/user/model"
 	"iot_manager_service/app/user/service"
+	"iot_manager_service/util/cache"
 	"iot_manager_service/util/common"
+	"iot_manager_service/util/token"
 	"net/http"
 )
 
-var User = new(user)
+var UserController = new(user)
 
 type user struct{}
 
@@ -28,6 +30,28 @@ func (u *user) GetPublicKey(c *gin.Context) {
 	c.JSON(http.StatusOK, key)
 }
 
+func (u *user) GetDeptUsers(c *gin.Context) {
+	depts := model.ReqDepts{}
+	err := c.ShouldBindJSON(&depts)
+	if err != nil {
+		c.JSON(http.StatusOK, common.ParamsInvalidResponse(err.Error(), nil))
+		return
+	}
+	users := service.UserService.GetDeptUsers(depts.Depts)
+	c.JSON(http.StatusOK, users)
+}
+
+func (u *user) Logout(c *gin.Context) {
+	header := c.GetHeader("Authorization")
+	claims, _ := token.JwtClaims.ParseJwtToken(header)
+	err := cache.DeleteToken(claims.ID)
+	if err != nil {
+		c.JSON(http.StatusOK, common.ParamsInvalidResponse(err.Error(), nil))
+		return
+	}
+	c.JSON(http.StatusOK, common.SuccessResponse("退出成功", nil))
+}
+
 func (u *user) GetUser(c *gin.Context) {
 	fmt.Println("demo。。。")
 }

app/user/dao/common.go

@@ -11,6 +11,7 @@ func InitDB(db *gorm.DB) {
 	Db = db
 	err := Db.AutoMigrate(
 		&User{},
+		&Dept{},
 	)
 	if err != nil {
 		panic(fmt.Sprintf("AutoMigrate err : %v", err))

app/user/dao/dept.go

@@ -0,0 +1,21 @@
+package dao
+
+// 部门
+type Dept struct {
+	ID        int    `gorm:"primary_key;type:int" json:"id"`    //部门id
+	DeptName  string `gorm:"type:varchar(12)" json:"dept_name"` //部门名称
+	ParentId  int    `gorm:"type:int" json:"parent_id"`         //父部门id
+	IsDeleted int    `gorm:"type:int" json:"isDeleted"`         //是否删除
+	Remark    string `gorm:"type:varchar(45)" json:"remark"`    //备注
+	Users     []User `gorm:"-" json:"users"`                    //用户们
+}
+
+func (*Dept) TableName() string {
+	return "dept"
+}
+
+func (d *Dept) GetDepts(deptIDs []int) ([]Dept, error) {
+	var depts []Dept
+	err := Db.Model(&d).Where("id IN (?)", deptIDs).Find(&depts).Error
+	return depts, err
+}

app/user/dao/user.go

@@ -33,6 +33,29 @@ func (c *User) LoginFindAccount(acc string) (*User, error) {
 	return &user, err
 }
 
+func (c *User) GetUsers() ([]User, error) {
+	var users []User
+	err := Db.Model(&c).Find(&users).Error
+	return users, err
+}
+
+func (c *User) GetNowUser(id int) (*User, error) {
+	err := Db.Model(&c).Where("id = ?", id).First(&c).Error
+	return c, err
+}
+
+func (c *User) GetDeptsUsers(depts []int) ([]User, error) {
+	var users []User
+	err := Db.Model(&c).Where("dept_id in ?", depts).Find(&users).Error
+	return users, err
+}
+
+//func (c *User) GetUsers1(id int) ([]User, error) {
+//	var users []User
+//	err := Db.Model(&c).Where("dept_id = ?", id).Find(&users).Error
+//	return users, err
+//}
+
 //func (c *User) GetUser() error {
 //	return Db.Model(&c).Where(" is_deleted = 0").Find(&c).Error
 //}

app/user/model/dept.go

@@ -0,0 +1,5 @@
+package model
+
+type ReqDepts struct {
+	Depts []int `json:"depts"`
+}

app/user/model/user.go

@@ -1,6 +1,14 @@
 package model
 
+import "iot_manager_service/app/user/dao"
+
+// 登录用户
 type LoginUser struct {
 	Account  string `json:"account"`  //账号
-	PassWord string `json:"passWord"` //密码
+	PassWord string `json:"password"` //密码
+}
+
+type NowUser struct {
+	UUID string   `json:"uuid"`
+	User dao.User `json:"user"`
 }

app/user/service/userService.go

@@ -5,18 +5,13 @@ import (
 	"encoding/base64"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"iot_manager_service/app/user/dao"
 	"iot_manager_service/util/cache"
+	"iot_manager_service/util/common"
 	"iot_manager_service/util/rsa"
 	"iot_manager_service/util/token"
 	"strconv"
-
-	//"github.com/google/uuid"
-	"gorm.io/gorm"
-	"iot_manager_service/app/user/dao"
-	"iot_manager_service/util/common"
-	//"iot_manager_service/util/rsa"
-	//"iot_manager_service/util/token"
-	//"strconv"
 )
 
 // 用户管理服务
@@ -26,7 +21,7 @@ type userService struct{}
 
 func (s *userService) Login(acc string, pwd string) *common.Errors {
 	userdao := &dao.User{}
-	user, err := userdao.LoginFindAccount(acc)
+	USER, err := userdao.LoginFindAccount(acc)
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 			return common.ParamsInvalidResponse("很抱歉，由于您的账号未完成注册或已被禁用，暂时无法使用。", nil)
@@ -42,7 +37,7 @@ func (s *userService) Login(acc string, pwd string) *common.Errors {
 	client := rsa.Decryption(a)
 
 	//解密数据库密文
-	b, _ := base64.StdEncoding.DecodeString(user.Password)
+	b, _ := base64.StdEncoding.DecodeString(USER.Password)
 	mysql := rsa.Decryption(b)
 	if !bytes.Equal(client, mysql) {
 		return common.ParamsInvalidResponse("密码错误", err)
@@ -50,9 +45,9 @@ func (s *userService) Login(acc string, pwd string) *common.Errors {
 
 	//登录成功则生成token
 	UUID := uuid.New().String()
-	USERID := strconv.Itoa(user.ID)
-	jwtToken, _ := token.JwtClaims.CreateJwtToken(USERID, user.UserName, UUID)
-	cache.SetToken(USERID, UUID)
+	USERID := strconv.Itoa(USER.ID)
+	jwtToken, _ := token.JwtClaims.CreateJwtToken(USERID, USER.UserName, UUID)
+	cache.SetToken(USERID, UUID, USER)
 	return common.SuccessResponse("登录成功", gin.H{"token": jwtToken})
 }
 
@@ -63,3 +58,32 @@ func (s *userService) GetPublicKey() *common.Errors {
 	}
 	return common.SuccessResponse("获取公钥成功", gin.H{"publicKey": pub})
 }
+
+func (s *userService) GetDeptUsers(deptIDs []int) *common.Errors {
+	deptdao := &dao.Dept{}
+	depts, _ := deptdao.GetDepts(deptIDs)
+
+	userdao := &dao.User{}
+	users, _ := userdao.GetUsers()
+
+	deptUsersMap := make(map[int][]dao.User)
+	for _, user := range users {
+		deptUsersMap[user.DeptId] = append(deptUsersMap[user.DeptId], user)
+	}
+
+	var deptUsers []dao.Dept
+	for _, dept := range depts {
+		users := deptUsersMap[dept.ID]
+		deptUsers = append(deptUsers, dao.Dept{
+			ID:       dept.ID,
+			DeptName: dept.DeptName,
+			Users:    users,
+		})
+	}
+	//for i, dept := range depts {
+	//	users1, _ := userdao.GetUsers1(dept.ID)
+	//	depts[i].Users = users1
+	//}
+
+	return common.SuccessResponse("获取成功", gin.H{"deptUsers": deptUsers})
+}

main.go

@@ -5,6 +5,7 @@ import (
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	gormLogger "gorm.io/gorm/logger"
+	file "iot_manager_service/app/file/dao"
 	user "iot_manager_service/app/user/dao"
 	"iot_manager_service/config"
 	_ "iot_manager_service/config"
@@ -78,4 +79,5 @@ func initDB() {
 		sqlDB.SetConnMaxLifetime(time.Hour * 4) //括号里面是超时时间，要小于数据库的超时时间  返回 invalid connection的问题
 	}
 	user.InitDB(db)
+	file.InitDB(db)
 }

router/router.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"github.com/gin-gonic/gin"
+	file "iot_manager_service/app/file/controller"
 	"iot_manager_service/app/middleware"
 	user "iot_manager_service/app/user/controller"
 	"iot_manager_service/config"
@@ -23,19 +24,23 @@ func InitRouter(engine *gin.Engine) {
 	//用户
 	sys := engine.Group("/user")
 	{
-		sys.GET("/getpublicKey", user.User.GetPublicKey)
-		sys.POST("/login", user.User.Login)
+		sys.GET("/getpublickey", user.UserController.GetPublicKey)
+		sys.POST("/login", user.UserController.Login)
+		sys.POST("/logout", user.UserController.Logout)
+		sys.GET("/getdeptusers", user.UserController.GetDeptUsers)
 	}
 
-	//通知
-	notice := engine.Group("/notice")
+	//文件
+	files := engine.Group("/file")
 	{
-		notice.GET("/demo", user.User.GetUser)
+		files.POST("/distribute", file.FileController.Distribute)
+		files.GET("/getuserfiles", file.FileController.GetUserFiles)
 	}
 
-	//文件
-	file := engine.Group("/file")
+	//通知
+	notice := engine.Group("/notice")
 	{
-		file.GET("/Auth", user.User.Login)
+		notice.GET("/demo", user.UserController.GetUser)
 	}
+
 }

util/aes/aes.go

@@ -0,0 +1,54 @@
+package aes
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"io"
+	"os"
+)
+
+// 加密密钥和签名密钥
+var AesKey = []byte("AESKey1234567890")
+var hmacKey = []byte("HMACKey1234567890")
+
+func EncryptFile(filePath string, aesKey []byte, hmacKey []byte) ([]byte, []byte, error) {
+	// 读取文件内容
+	fileContent, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// 创建 AES 加密块
+	block, err := aes.NewCipher(AesKey)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// 创建 AES 加密模式
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// 生成随机 nonce
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
+		return nil, nil, err
+	}
+
+	// 加密文件内容
+	encryptedFileContent := gcm.Seal(nil, nonce, fileContent, nil)
+
+	// 计算 HMAC 签名
+	h := hmac.New(sha256.New, hmacKey)
+	_, err = h.Write(encryptedFileContent)
+	if err != nil {
+		return nil, nil, err
+	}
+	signature := h.Sum(nil)
+
+	return encryptedFileContent, signature, nil
+}

util/cache/redis.go

@@ -1,7 +1,10 @@
 package cache
 
 import (
+	"encoding/json"
 	"github.com/go-redis/redis"
+	"iot_manager_service/app/user/dao"
+	"iot_manager_service/app/user/model"
 	"iot_manager_service/config"
 	"time"
 )
@@ -38,12 +41,26 @@ const (
 	TIME          = "time"
 )
 
-// 将token存入到redis中
-func SetToken(uid string, uuid string) {
-	Redis.Set("login:"+uid, uuid, time.Hour*1)
+// 将当前用户存入到redis中
+func SetToken(uid string, uuid string, user *dao.User) {
+	nowuser := model.NowUser{
+		uuid,
+		*user,
+	}
+	marshal, _ := json.Marshal(nowuser)
+	Redis.Set("login:"+uid, marshal, time.Hour*1)
+}
+
+// 从redis中取出当前用户
+func GetToken(uid string) (*model.NowUser, error) {
+	result, _ := Redis.Get("login:" + uid).Result()
+	str := []byte(result)
+	nowuser := model.NowUser{}
+	err := json.Unmarshal(str, &nowuser)
+	return &nowuser, err
 }
 
-// 从redis中取出token
-func GetToken(uid string) (string, error) {
-	return Redis.Get("login:" + uid).Result()
+// 将当前用户从redis中删除(退出登录)
+func DeleteToken(uid string) error {
+	return Redis.Del("login:" + uid).Err()
 }