• 基于Go语言的网盘开发（GloudDisk）

    （记录一下自己做项目的过程） 基于go-zero实现的简易的网盘系统，如果有小伙伴对这个项目感兴趣，可以去网上搜索一些资料。这里推荐一下我学习的来源：【项目实战】基于Go-zero、Xorm的网盘系统_哔哩哔哩_bilibili 

    确定功能模块：

    目录

     xorm连接数据库并创建表结构

     集成go—zero

    一、用户模块

    （1）密码登录

    （2）邮箱注册

     （3）个人资料详情

    二、存储池模块

    （1）中心存储池资源管理

    ①文件上传

    （2）个人存储池资源管理 

    ①文件关联存储

    ②用户文件列表 

    ③用户文件名称修改

    ④用户文件夹创建

    ⑤用户文件删除

    ⑥用户文件移动

    三、文件共享模块

    （1）文件分享

    ①创建分享记录

    ②获取资源详情

    ③资源保存

     xorm连接数据库并创建表结构

     创建项目--安装xorm（ go get xorm.io/xorm）

    文档地址：Xorm

    连接数据库：

    xorm.NewEngine("mysql", "root:123@/test?charset=utf8")

    先创建UserBasic结构体，为了之后的测试，如下：（新建models文件夹，在文件夹下新建user_basic.go）

    1. package Models
    2.  
    3. type UserBasic struct {
    4. 	ID int
    5. 	Identity string
    6. 	Name string
    7. 	Password string
    8. 	Email string
    9. }
    10.  
    11. func (table UserBasic) TableName() string {
    12. 	return "user_basic"
    13. }

    之后通过 engine.CreateTables()，参数为一个或多个空的对应Struct的指针，创建数据表，具体操作如下：（为了测试，新建一个文件夹test，新建xorm_test.go）

    1. package test
    2.  
    3. import (
    4. 	"CloudDisk/Models"
    5. 	bytes2 "bytes"
    6. 	"encoding/json"
    7. 	_ "github.com/go-sql-driver/mysql"
    8. 	"testing"
    9. 	"xorm.io/xorm"
    10. )
    11.  
    12. func TestXorm(t *testing.T) {
    13. 	engine, err := xorm.NewEngine("mysql", "root:123456@tcp(127.0.0.1:3306)/clouddisk?charset=utf8")
    14. 	if err!=nil {
    15. 		t.Fatal(err)
    16. 	}
    17. 	TableUser:=make([]*Models.UserBasic,0)
    18. 	m := new(Models.UserBasic)
    19. 	err = engine.CreateTables(m)
    20. 	if err!=nil {
    21. 		t.Fatal(err)
    22. 	}
    23. 	err = engine.Find(&TableUser)//这里查出来的是地址
    24. 	if err!=nil {
    25. 		t.Fatal(err)
    26. 	}
    27. 	//将以json格式输出
    28. 	bytes, err:= json.Marshal(TableUser)//转换成BYTE数组
    29. 	if err!=nil {
    30. 		t.Fatal(err)
    31. 	}
    32. 	dst := new(bytes2.Buffer)
    33. 	err = json.Indent(dst, bytes, "", "  ") //转换为buffer
    34. 	if err!=nil {
    35. 		t.Fatal(err)
    36. 	}
    37. 	println(dst.String())
    38. }

     集成go—zero

    文档地址：简介 · go-zero document

     安装：

    go get -u github.com/zeromicro/go-zero

    因为项目比较小，所以直接选择单体服务就可以了，

    安装Goctl，完成后执行 goctl -v，如果输出版本信息则代表安装成功

    1. # Go 1.15 及之前版本
    2. go get -u github.com/zeromicro/go-zero/tools/goctl@latest
    3.  
    4. # Go 1.16 及以后版本
    5. go install github.com/zeromicro/go-zero/tools/goctl@latest

    创建greet服务，如下图，因为我们 mkdir 和 cd 都已经完成了，所以直接  goctl api new [可自定义名字] （我的是goctl api new code，因为下面我会直接说code文件，所以希望大家不要迷糊我这code是啥了）

     之后启动服务：

    1. $ cd greet
    2. $ go run greet.go -f etc/greet-api.yaml

    之后通过http://localhost:8888/from/you来访问服务，如下图：

     可以看到当前的返回值为null，那是因为我们在 logic 文件里的 .go文件 没有写任何的业务逻辑（我的名字是code，所以这里是codelogic.go）,如下图：

    如果我们改成 

    重新启动服务，会出现这样的页面：

     

    但是为什么返回的是Message呢？因为返回的response里面定义的是一个Message集。在code.api中可以看到，如下图： 

     以后我们就可以在这里写业务逻辑了。

    接下来我们来整合一下，将models文件放入code目录下，并在models中创建init.go用来连接数据库。如下：

     代码：

    1. package Models
    2.  
    3. import (
    4. 	"log"
    5. 	"xorm.io/xorm"
    6. 	_ "github.com/go-sql-driver/mysql"
    7. )
    8. var Engine=Init()
    9. func Init() *xorm.Engine {
    10. 	engine, err := xorm.NewEngine("mysql", "root:123456@tcp(127.0.0.1:3306)/clouddisk?charset=utf8")
    11. 	if err!=nil {
    12. 		log.Println("engine Error:",err)//log包的println会自动return
    13. 	}
    14. 	return engine
    15. }

    然后在 codelogic.go 进行业务逻辑的实现： （其实就是将文件 xorm_test.go 中的代码复制过来进行测试）

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	bytes2 "bytes"
    6. 	"context"
    7. 	"encoding/json"
    8. 	"log"
    9.  
    10. 	"CloudDisk/code/internal/svc"
    11. 	"CloudDisk/code/internal/types"
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type CodeLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewCodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CodeLogic {
    22. 	return &CodeLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *CodeLogic) Code(req *types.Request) (resp *types.Response, err error) {
    30. 	TableUser:=make([]*Models.UserBasic,0)
    31. 	err = Models.Engine.Find(&TableUser)//这里查出来的是地址
    32. 	if err!=nil {
    33. 		log.Println("Find Error:",err)
    34. 	}
    35. 	//将以json格式输出
    36. 	bytes, err:= json.Marshal(TableUser)//转换成BYTE数组
    37. 	if err!=nil {
    38. 		log.Println("json Error:",err)
    39. 	}
    40. 	dst := new(bytes2.Buffer)
    41. 	err = json.Indent(dst, bytes, "", "  ") //转换为buffer
    42. 	if err!=nil {
    43. 		log.Println("Indent Error:",err)
    44. 	}
    45. 	println(dst.String())
    46. 	resp=new(types.Response)
    47. 	resp.Message=dst.String()
    48. 	return
    49. }

    一、用户模块

    （1）密码登录

    在 code.api 中写登录handler的相关配置

    1. service code-api {
    2. 	@handler User//这个handler指的是生成在handler与logic下的文件所处理的句柄
    3. 	get /user/login (LoginRequest) returns (LoginReply)
    4. }
    5.  
    6. type LoginRequest {
    7. 	Name     string `form:"name"`
    8. 	Password string `json:"password"`
    9. }
    10.  
    11. type LoginReply {
    12. 	Token string `json:"token"`
    13. }

     更新api，之后在 handler 与 logic 文件下都会出现新的.go文件

    goctl api go  -api code.api -dir . -style go_zero

     在用户成功登陆之后，那么存到数据库的密码，我们也需要加密一下，这里用到的是MD5。

    两个方法：

    （1）md5.New() 为初始化一个MD5对象，返回的是hash.Hash对象。

             函数原型: func New() hash.Hash。

             该对象实现了hash.Hash的Sum接口。

    （2）md5.Sum() 计算出MD5校验和。

             函数原型：func Sum(data []byte) [Size]byte。
             他并不是对data进行校验计算，而是对hash.Hash对象内部存储的内容进行校验和计算然后将其追加到data的后面形成一个新的byte切片。该方法返回一个Size大小为16的byte数组，对于MD5来说就是一个128bit的16字节byte数组。

    新建文件 helper，创建 helper.go 写入MD5函数 

    1. package helper
    2.  
    3. import (
    4. 	"crypto/md5"
    5. 	"fmt"
    6. )
    7.  
    8. func Md5(s string) string {
    9. 	return fmt.Sprintf("%x",md5.Sum([]byte(s)))
    10. }

    我们需要生成 token，而 token 需要用到 jwt 进行加密。这里介绍一下 jwt-go 库

    使用 jwt-go 库生成 token，我们需要定义需求（claims），也就是说我们需要通过 jwt 传输的数据。假如我们需要传输 ID 和 Username，我们可以定义 Claims 结构体，其中包含 ID 和 Username 字段，还有在 jwt-go 包预定义的 jwt.StandardClaims。

    使用 jwt-go 库根据指定的算法生成 jwt token ，主要用到两个方法：

    （1）jwt.NewWithClaims 方法：

    func jwt.NewWithClaims(method jwt.SigningMethod, claims jwt.Claims) *jwt.Token

    jwt.NewWithClaims 方法根据 Claims 结构体创建 Token 示例。

    参数 1 是 jwt.SigningMethod，最常用的是 jwt.SigningMethodHS256 这种 crypto.Hash 加密算法的方案。

    参数 2 是 Claims，也就是我们自己定义的UserClaim，UserClaim嵌入在自定义类型中，以方便对标准声明进行编码，解析和验证。

    （2）SignedString 方法：

    func (*jwt.Token).SignedString(key interface{}) (string, error)

    SignedString 方法根据传入的空接口类型参数 key，返回完整的签名令牌。

    解析 token

    使用 jwt-go 库解析 token

    （1）jwt.ParseWithClaims 方法：

    func jwt.ParseWithClaims(tokenString string, claims jwt.Claims, keyFunc jwt.Keyfunc) (*jwt.Token, error)

    jwt.ParseWithClaims 方法用于解析鉴权的声明，返回 *jwt.Token。

    创建文件夹define，用来定义token需要用到的claims

    1. package define
    2.  
    3. import "github.com/dgrijalva/jwt-go"
    4.  
    5. type UserClaim struct {
    6. 	Id int
    7. 	Identity string
    8. 	Name string
    9. 	jwt.StandardClaims
    10. }
    11. var JwtKey="cloud-disk-key"

    接下来定义生成token的方法，写在helper文件里

    1. func GenerateToken(id int,name,identity string) (string,error) {
    2. 	uc:=define.UserClaim{
    3. 		Id:id,
    4. 		Identity: identity,
    5. 		Name: name,
    6. 	}
    7. 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, uc) //生成token
    8. 	//给token进行加密
    9. 	tokenString, err := token.SignedString([]byte(define.JwtKey))
    10. 	if err!=nil {
    11. 		return "", err
    12. 	}
    13. 	return tokenString,nil
    14. }

     准备工作都做好了，接下来我们来写user-login业务逻辑，user_logic.go 代码如下：

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7. 	"errors"
    8.  
    9. 	"CloudDisk/code/internal/svc"
    10. 	"CloudDisk/code/internal/types"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type UserLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogic {
    22. 	return &UserLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *UserLogic) User(req *types.LoginRequest) (resp *types.LoginReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	user := new(Models.UserBasic)
    32. 	//1.从数据库中查询当前用户
    33. 	get, err := Models.Engine.Where("name= ? AND password= ?", req.Name, helper.Md5(req.Password)).Get(user)
    34. 	if err!=nil {
    35. 		return nil, err
    36. 	}
    37. 	if !get {
    38. 		return nil,errors.New("用户名或密码错误")
    39. 	}
    40. 	//2.生成token
    41. 	token, err := helper.GenerateToken(user.ID, user.Name, user.Identity)
    42. 	if err!=nil {
    43. 		return nil,err
    44. 	}
    45. 	resp=new(types.LoginReply)
    46. 	resp.Token=token
    47. 	return
    48. }

    之后我们进行重新编译（下面两句话会频繁的用到，每次写完code.api都要goctl一下）

    goctl api go -api code.api -dir . -style go_zero

     然后运行

    go run code.go -f etc/code-api.yaml

    使用postman软件，帮助测试 （这里在code.api中我将输入json改为了form形式）

    （2）邮箱注册

    go get github.com/jordan-wright/email

     安装email，源址https://github.com/jordan-wright/email

    go get github.com/go-redis/redis/v8

     安装redis，源址GitHub - go-redis/redis: Type-safe Redis client for Golang

    $ go get github.com/satori/go.uuid

     安装uuid ，源址GitHub - satori/go.uuid: UUID package for Go

    在 init.go 中加入 redis 的配置

    1. package Models
    2.  
    3. import (
    4. 	"context"
    5. 	"github.com/go-redis/redis/v8"
    6. 	_ "github.com/go-sql-driver/mysql"
    7. 	"log"
    8. 	"xorm.io/xorm"
    9. )
    10. var Engine=Init()
    11. var ctx = context.Background()
    12. var Redis = InitRedis()
    13. func Init() *xorm.Engine {
    14. 	engine, err := xorm.NewEngine("mysql", "root:123456@tcp(127.0.0.1:3306)/clouddisk?charset=utf8")
    15. 	if err!=nil {
    16. 		log.Println("engine Error:",err)//log包的println会自动return
    17. 	}
    18. 	return engine
    19. }
    20. func InitRedis() *redis.Client {
    21. 	return redis.NewClient(&redis.Options{
    22. 		Addr:     "127.0.0.1:6379",
    23. 		Password: "", // no password set
    24. 		DB:       0,  // use default DB
    25. 	})
    26. }

     在 helper 中定义随机数生成，为了生成随机的验证码；以及 uuid ，为了生成 identity

    1. package helper
    2.  
    3. import (
    4. 	"CloudDisk/code/define"
    5. 	"crypto/md5"
    6. 	"fmt"
    7. 	"github.com/dgrijalva/jwt-go"
    8. 	"github.com/jordan-wright/email"
    9. 	uuid "github.com/satori/go.uuid"
    10. 	"math/rand"
    11. 	"net/smtp"
    12. 	"time"
    13. )
    14.  
    15. func Md5(s string) string {
    16. 	return fmt.Sprintf("%x",md5.Sum([]byte(s)))
    17. }
    18. func GenerateToken(id int,name,identity string) (string,error) {
    19. 	uc:=define.UserClaim{
    20. 		Id:id,
    21. 		Identity: identity,
    22. 		Name: name,
    23. 	}
    24. 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, uc) //生成token
    25. 	//给token进行加密
    26. 	tokenString, err := token.SignedString([]byte(define.JwtKey))
    27. 	if err!=nil {
    28. 		return "", err
    29. 	}
    30. 	return tokenString,nil
    31. }
    32. func MailSendCode(mail,code string) error {
    33. 	e := email.NewEmail()
    34. 	e.From = ""//发送者姓名，发送者邮箱地址
    35. 	e.To = []string{mail}//接收着
    36. 	e.Subject = "验证码测试"//发送的主题
    37. 	e.HTML = []byte("
      "+code+"
      "      )
    38. 	err := e.Send("smtp.qq.com:25", smtp.PlainAuth("", "@qq.com", "jjj", "smtp.qq.com"), )
    39. 	if err!=nil {
    40. 		return err
    41. 	}
    42. 	return nil
    43. }
    44. func RandCode() string {
    45. 	s:="1234567890"
    46. 	rand.Seed(time.Now().UnixNano())
    47. 	code:=""
    48. 	for i := 0; i < 6; i++ {
    49. 		code+=string(s[rand.Intn(len(s))])
    50. 	}
    51. 	return code
    52. }
    53. func GetUUID() string {
    54. 	return uuid.NewV4().String()
    55. }

     发送验证码的业务逻辑

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"CloudDisk/code/internal/svc"
    7. 	"CloudDisk/code/internal/types"
    8. 	"context"
    9. 	"errors"
    10. 	"time"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type MailCodeSendLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewMailCodeSendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MailCodeSendLogic {
    22. 	return &MailCodeSendLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *MailCodeSendLogic) MailCodeSend(req *types.MailCodeSendRequest) (resp *types.MailCodeSendReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	//该邮箱未被注册
    32. 	count, err := Models.Engine.Where("email= ?", req.Email).Count(new(Models.UserBasic))
    33. 	if err!=nil {
    34. 		return
    35. 	}
    36. 	if count>0 {
    37. 		err=errors.New("该邮箱已经被注册过了")
    38. 		return
    39. 	}
    40. 	//获取验证码
    41. 	code:=helper.RandCode()
    42. 	//存储验证码
    43. 	Models.Redis.Set(l.ctx, req.Email,code,time.Second * 300)
    44. 	//发送验证码
    45. 	err = helper.MailSendCode(req.Email, code)
    46. 	if err!=nil {
    47. 		return nil, err
    48. 	}
    49. 	return
    50. }

    用户注册的业务逻辑

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"CloudDisk/code/internal/svc"
    7. 	"CloudDisk/code/internal/types"
    8. 	"context"
    9. 	"errors"
    10. 	"github.com/zeromicro/go-zero/core/logx"
    11. 	"log"
    12. )
    13.  
    14. type UserRegisterLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewUserRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserRegisterLogic {
    21. 	return &UserRegisterLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *UserRegisterLogic) UserRegister(req *types.UserRegisterRequest) (resp *types.UserRegisterReply, err error) {
    29. 	//判断code是否一致
    30. 	result, err := Models.Redis.Get(l.ctx, req.Email).Result()
    31. 	if err!=nil {
    32. 		return nil, errors.New("未获取该邮箱的验证码")
    33. 	}
    34. 	if result!=req.Code {
    35. 		err=errors.New("验证码错误")
    36. 		return
    37. 	}
    38. 	//判断用户名是否已经存在
    39. 	count, err := Models.Engine.Where("name= ?", req.Name).Count(new(Models.UserBasic))
    40. 	if err!=nil {
    41. 		return nil, err
    42. 	}
    43. 	if count>0 {
    44. 		err=errors.New("用户名已经存在")
    45. 		return
    46. 	}
    47. 	//数据入库，开始注册信息
    48. 	user:=&Models.UserBasic{
    49. 		Name: req.Name,
    50. 		Identity:helper.GetUUID(),
    51. 		Email: req.Email,
    52. 		Password: helper.Md5(req.Password),
    53. 	}
    54. 	insert, err := Models.Engine.Insert(user)
    55. 	if err!=nil {
    56. 		return nil, err
    57. 	}
    58. 	log.Println("insert user row:",insert)
    59. 	return
    60. }

     （3）个人资料详情

     通过 identity 来获取用户信息

    code.api新增：

    1. service code-api {
    2. 	//用户登录
    3. 	@handler UserLogin//这个handler指的是生成在handler与logic下的文件所处理的句柄
    4. 	post /user/login (LoginRequest) returns (LoginReply)
    5. 	//用户详情
    6. 	@handler UserDetail
    7. 	post /user/detail (DetailRequest) returns (DetailReply)
    8. }
    9.  
    10. type LoginRequest {
    11. 	Name     string `form:"name"`
    12. 	Password string `form:"password"`
    13. }
    14.  
    15. type LoginReply {
    16. 	Token string `json:"token"`
    17. }
    18. type DetailRequest {
    19. 	Identity string `json:"identity"`
    20. }
    21. type DetailReply {
    22. 	Name  string `json:"name"`
    23. 	Email string `json:"email"`
    24. }

     之后 goctl api go -api code.api -dir . -style go_zero 生成编译，编写detail业务逻辑

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"context"
    6. 	"errors"
    7.  
    8. 	"CloudDisk/code/internal/svc"
    9. 	"CloudDisk/code/internal/types"
    10.  
    11. 	"github.com/zeromicro/go-zero/core/logx"
    12. )
    13.  
    14. type UserDetailLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewUserDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserDetailLogic {
    21. 	return &UserDetailLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *UserDetailLogic) UserDetail(req *types.DetailRequest) (resp *types.DetailReply, err error) {
    29. 	// todo: add your logic here and delete this line
    30. 	resp=&types.DetailReply{}
    31. 	m := new(Models.UserBasic)
    32. 	get, err := Models.Engine.Where("identity= ? ", req.Identity).Get(m)
    33. 	if err!=nil {
    34. 		return nil, err
    35. 	}
    36. 	if !get {
    37. 		return nil, errors.New("该用户不存在")
    38. 	}
    39. 	resp.Name=m.Name
    40. 	resp.Email=m.Email
    41. 	return
    42. }

    二、存储池模块

    我们先修改一下数据库配置路由，在etc文件的 code_api.yaml 中加入如下：

    1. Name: code-api
    2. Host: 0.0.0.0
    3. Port: 8888
    4.  
    5. Mysql:
    6.   DataSource: root:123456@tcp(127.0.0.1:3306)/clouddisk?charset=utf8
    7.  
    8. Redis:
    9.   Addr: 127.0.0.1:6379

    在config文件中加入：

    1. package config
    2.  
    3. import "github.com/zeromicro/go-zero/rest"
    4.  
    5. type Config struct {
    6. 	rest.RestConf
    7. 	Mysql struct{
    8. 		DataSource string
    9. 	}
    10. 	Redis struct{
    11. 		Addr string
    12. 	}
    13. }

    同样在 service_context.go 中也要加入：

    1. package svc
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/internal/config"
    6. 	"CloudDisk/code/internal/middleware"
    7. 	"github.com/go-redis/redis/v8"
    8. 	"github.com/zeromicro/go-zero/rest"
    9. 	"xorm.io/xorm"
    10. )
    11.  
    12. type ServiceContext struct {
    13. 	Config config.Config
    14. 	Engine *xorm.Engine
    15. 	RDB *redis.Client
    16. 	Auth rest.Middleware
    17. }
    18.  
    19. func NewServiceContext(c config.Config) *ServiceContext {
    20. 	return &ServiceContext{
    21. 		Config: c,
    22. 		Engine:Models.Init(c.Mysql.DataSource),
    23. 		RDB:Models.InitRedis(c),
    24. 		Auth: middleware.NewAuthMiddleware().Handle,
    25. 	}
    26. }

    当然，在做以下业务逻辑的时候，首先需要加一个中间件，用来验证用户是否已经登录，如果不登录是无法使用以下功能的。在go-zero中，中间件可以分为路由中间件和全局中间件，路由中间件是指某一些特定路由需要实现中间件逻辑，而全局中间件的服务范围则是整个服务。我们这里使用的是路由中间件 。对于中间件，需要添加 Middleware 声明。

    所以我们需要再写一对 service code-api{}，在这之上需要 Middleware 的声明。例如文件上传的code.api配置，然后 goctl api go -api code.api -dir . -style go_zero 一下会自动生成Middleware的文件，在文件中配置如下：

    1. package middleware
    2.  
    3. import (
    4. 	"CloudDisk/code/helper"
    5. 	"net/http"
    6. )
    7.  
    8. type AuthMiddleware struct {
    9. }
    10.  
    11. func NewAuthMiddleware() *AuthMiddleware {
    12. 	return &AuthMiddleware{}
    13. }
    14.  
    15. func (m *AuthMiddleware) Handle(next http.HandlerFunc) http.HandlerFunc {
    16. 	return func(w http.ResponseWriter, r *http.Request) {
    17. 		// TODO generate middleware implement function, delete after code implementation
    18. 		auth:=r.Header.Get("Authorization")
    19. 		if auth =="" {
    20. 			w.WriteHeader(http.StatusUnauthorized)
    21. 			w.Write([]byte("Unauthorized"))
    22. 			return
    23. 		}
    24. 		uc, err := helper.AnalyzeToken(auth)
    25. 		if err!=nil {
    26. 			w.WriteHeader(http.StatusUnauthorized)
    27. 			w.Write([]byte(err.Error()))
    28. 			return
    29. 		}
    30. 		r.Header.Set("UserId",string(rune(uc.Id)))
    31. 		r.Header.Set("UserIdentity",uc.Identity)
    32. 		r.Header.Set("UserName",uc.Name)
    33. 		// Passthrough to next handler if need
    34. 	    next(w, r)
    35. 	}
    36. }

    这里用到了token的解析，具体如下：

    1. //AnalyzeToken Token解析
    2. func AnalyzeToken(token string) (*define.UserClaim, error) {
    3. 	uc:=new(define.UserClaim)
    4. 	claims, err := jwt.ParseWithClaims(token, uc, func(token *jwt.Token) (interface{}, error) {
    5. 		return []byte(define.JwtKey), nil
    6. 	})
    7. 	if err != nil {
    8. 		return nil,err
    9. 	}
    10. 	if !claims .Valid{
    11. 		return uc,errors.New("token is invalid")
    12. 	}
    13. 	return uc,err
    14. }

      当然同样也要在 service_context.go 中也要加入Middleware 的声明。（代码跟上面一样，不在复制！）

    （1）中心存储池资源管理

    ①文件上传

    在Models里加入 RepositoryPool

    1. package Models
    2.  
    3. import "time"
    4.  
    5. type RepositoryPool struct {
    6. 	Id        int
    7. 	Identity  string
    8. 	Hash      string
    9. 	Name      string
    10. 	Ext       string
    11. 	Size      int64
    12. 	Path      string
    13. 	createdAt time.Time `xorm:"created"`
    14. 	UpdatedAt time.Time `xorm:"updated"`
    15. 	DeletedAt time.Time `xorm:"deleted"`
    16. }
    17. func (table RepositoryPool) TableName() string {
    18. 	return "repository_pool"
    19. }
    20.

     在code.api代码中，添加如下代码：

    1. @server(
    2. 	middleware : Auth
    3. )
    4. service code-api {
    5. 	//文件上传
    6. 	@handler FileUpload
    7. 	post /file/upload (FileUploadRequest) returns (FileUploadReply)
    8. }
    9. type FileUploadRequest {
    10. 	Hash string `json:"hash,optional"`
    11. 	Name string `json:"name,optional"`
    12. 	Ext  string `json:"ext,optional"`
    13. 	Size int    `json:"size,optional"`
    14. 	Path string `json:"path,optional"`
    15. }
    16. type FileUploadReply {
    17. 	Identity string `json:"identity"`
    18. 	Ext      string `json:"ext"`
    19. 	Name     string `json:"name"`
    20. }

     在文件上传这里我们采用 CosUpload 文件上传到腾讯云，帮助文档在这里---------------------------------------------------------------》》》》》对象存储 快速入门-SDK 文档-文档中心-腾讯云

    在 helper 文件中加入 CosUpload 文件上传的业务逻辑

    1. //CosUpload 文件上传到腾讯云
    2. func CosUpload(r *http.Request) (string,error) {
    3. 	u, _ := url.Parse(define.CosBucket)
    4. 	b := &cos.BaseURL{BucketURL: u}
    5. 	c := cos.NewClient(b, &http.Client{
    6. 		Transport: &cos.AuthorizationTransport{
    7. 			//如实填写账号和密钥，也可以设置为环境变量
    8. 			SecretID:  define.TencentSecretID,
    9. 			SecretKey: define.TencentSecretKey,
    10. 		},
    11. 	})
    12. 	file, fileHeader, err := r.FormFile("file")
    13. 	name := "cloud-disk/"+GetUUID()+path.Ext(fileHeader.Filename)
    14. 	_, err = c.Object.Put(context.Background(), name, file,nil)
    15. 	if err != nil {
    16. 		panic(err)
    17. 	}
    18. 	return define.CosBucket+"/"+name,nil
    19. }

    在 file_upload_handler.go 中写入如下代码：这次我们是先判断一下文件是否上传过，之后将信息写给 logic 中的 req 。

    1. package handler
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"crypto/md5"
    7. 	"fmt"
    8. 	"net/http"
    9. 	"path"
    10.  
    11. 	"CloudDisk/code/internal/logic"
    12. 	"CloudDisk/code/internal/svc"
    13. 	"CloudDisk/code/internal/types"
    14. 	"github.com/zeromicro/go-zero/rest/httpx"
    15. )
    16.  
    17. func FileUploadHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
    18. 	return func(w http.ResponseWriter, r *http.Request) {
    19. 		var req types.FileUploadRequest
    20. 		if err := httpx.Parse(r, &req); err != nil {
    21. 			httpx.Error(w, err)
    22. 			return
    23. 		}
    24. 		file, fileHeader, err2 := r.FormFile("file")
    25. 		if err2!=nil {
    26. 			return
    27. 		}
    28. 		//判断文件是否存在
    29. 		bytes := make([]byte, fileHeader.Size)
    30. 		_, err2 = file.Read(bytes)
    31. 		if err2!=nil {
    32. 			return
    33. 		}
    34. 		hash:=fmt.Sprintf("%x",md5.Sum(bytes))
    35. 		rp:=new(Models.RepositoryPool)
    36. 		get, err2 := svcCtx.Engine.Where("hash=?", hash).Get(rp)
    37. 		if err2!=nil {
    38. 			return
    39. 		}
    40. 		if get {
    41. 			httpx.OkJson(w,&types.FileUploadReply{Identity: rp.Identity, Ext: rp.Ext, Name: rp.Name})
    42. 			return
    43. 		}
    44. 		//往cos中存储文件
    45. 		cosPath, err2 := helper.CosUpload(r)
    46. 		if err2!=nil {
    47. 			return
    48. 		}
    49. 		//往 logic 中传递req
    50. 		req.Name=fileHeader.Filename
    51. 		req.Ext=path.Ext(fileHeader.Filename)
    52. 		req.Size= int(fileHeader.Size)
    53. 		req.Hash=hash
    54. 		req.Path=cosPath
    55.  
    56. 		l := logic.NewFileUploadLogic(r.Context(), svcCtx)
    57. 		resp, err := l.FileUpload(&req)
    58. 		if err != nil {
    59. 			httpx.Error(w, err)
    60. 		} else {
    61. 			httpx.OkJson(w, resp)
    62. 		}
    63. 	}
    64. }

    file_upload_logic.go 业务逻辑代码如下：

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7. 	"fmt"
    8.  
    9. 	"CloudDisk/code/internal/svc"
    10. 	"CloudDisk/code/internal/types"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type FileUploadLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewFileUploadLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FileUploadLogic {
    22. 	return &FileUploadLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *FileUploadLogic) FileUpload(req *types.FileUploadRequest) (resp *types.FileUploadReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	rp := &Models.RepositoryPool{
    32. 		Identity: helper.GetUUID(),
    33. 		Hash:     req.Hash,
    34. 		Name:     req.Name,
    35. 		Ext:      req.Ext,
    36. 		Size:     int64(req.Size),
    37. 		Path:     req.Path,
    38. 	}
    39. 	_, err = l.svcCtx.Engine.Insert(rp)
    40. 	if err!=nil {
    41. 		return nil, err
    42. 	}
    43. 	resp=new(types.FileUploadReply)
    44. 	resp.Identity=rp.Identity
    45. 	resp.Ext=rp.Ext
    46. 	resp.Name=rp.Name
    47. 	fmt.Println(resp.Identity)
    48. 	return
    49. }

    （2）个人存储池资源管理 

    ①文件关联存储

    code.api

    1. //用户文件的关联存储
    2. 	@handler UserRepositorySave
    3. 	post /user/repository/save (UserRepositorySaveRequest) returns (UserRepositorySaveReply)
    4. type UserRepositorySaveRequest {
    5. 	ParentId           int64  `json:"parentId"`
    6. 	RepositoryIdentity string `json:"repositoryIdentity"`
    7. 	Ext                string `json:"ext"`
    8. 	Name               string `json:"name"`
    9. }
    10. type UserRepositorySaveReply {
    11. }

     Models新增

    1. package Models
    2.  
    3. import "time"
    4.  
    5. type UserRepository struct {
    6. 	Id                 int
    7. 	Identity           string
    8. 	UserIdentity       string
    9. 	ParentId           int64
    10. 	RepositoryIdentity string
    11. 	Ext                string
    12. 	Name               string
    13. 	CreatedAt          time.Time `xorm:"created"`
    14. 	UpdatedAt          time.Time `xorm:"updated"`
    15. 	DeletedAt          time.Time `xorm:"deleted"`
    16. }
    17.  
    18. func (table UserRepository) TableName() string {
    19. 	return "user_repository"
    20. }

     在 user_repository_save_handler.go 修改一下 UserRepositorySave 函数的参数，将UserIdentity 传入，代码如下：

    1. package handler
    2.  
    3. import (
    4. 	"net/http"
    5.  
    6. 	"CloudDisk/code/internal/logic"
    7. 	"CloudDisk/code/internal/svc"
    8. 	"CloudDisk/code/internal/types"
    9. 	"github.com/zeromicro/go-zero/rest/httpx"
    10. )
    11.  
    12. func UserRepositorySaveHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
    13. 	return func(w http.ResponseWriter, r *http.Request) {
    14. 		var req types.UserRepositorySaveRequest
    15. 		if err := httpx.Parse(r, &req); err != nil {
    16. 			httpx.Error(w, err)
    17. 			return
    18. 		}
    19.  
    20. 		l := logic.NewUserRepositorySaveLogic(r.Context(), svcCtx)
    21. 		resp, err := l.UserRepositorySave(&req,r.Header.Get("UserIdentity"))
    22. 		if err != nil {
    23. 			httpx.Error(w, err)
    24. 		} else {
    25. 			httpx.OkJson(w, resp)
    26. 		}
    27. 	}
    28. }

     接下来的每一个业务逻辑块都需要在 handler 里加入，之后我就不再详细说明了。

    logic业务逻辑：（非常简单，就是个插入） 

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7.  
    8. 	"CloudDisk/code/internal/svc"
    9. 	"CloudDisk/code/internal/types"
    10.  
    11. 	"github.com/zeromicro/go-zero/core/logx"
    12. )
    13.  
    14. type UserRepositorySaveLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewUserRepositorySaveLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserRepositorySaveLogic {
    21. 	return &UserRepositorySaveLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *UserRepositorySaveLogic) UserRepositorySave(req *types.UserRepositorySaveRequest, userIdentity string) (resp *types.UserRepositorySaveReply, err error) {
    29. 	// todo: add your logic here and delete this line
    30. 	ur := &Models.UserRepository{
    31. 		Identity:           helper.GetUUID(),
    32. 		UserIdentity:       userIdentity,
    33. 		ParentId:           req.ParentId,
    34. 		RepositoryIdentity: req.RepositoryIdentity,
    35. 		Ext:                req.Ext,
    36. 		Name:               req.Name,
    37. 	}
    38. 	_, err = l.svcCtx.Engine.Insert(ur)
    39. 	if err!=nil {
    40. 		return
    41. 	}
    42. 	return
    43. }

    ②用户文件列表 

    code.api 

    1. 	//用户文件列表
    2. 	@handler UserFileList
    3. 	get /user/file/list (UserFileListReguest) returns (UserFileListReply)
    4. type UserFileListReguest {
    5. 	Id   int64 `json:"id,optional"`
    6. 	Page int   `json:"page,optional"`
    7. 	Size int   `json:"size,optional"`
    8. }
    9.  
    10. type UserFileListReply {
    11. 	List  []*UserFile `json:"list"`
    12. 	Count int         `json:"count"`
    13. }

    logic 业务逻辑做到了分页的多表 join 查询 

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/define"
    6. 	"context"
    7. 	"time"
    8.  
    9. 	"CloudDisk/code/internal/svc"
    10. 	"CloudDisk/code/internal/types"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type UserFileListLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewUserFileListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFileListLogic {
    22. 	return &UserFileListLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *UserFileListLogic) UserFileList(req *types.UserFileListReguest,userIdentity string) (resp *types.UserFileListReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	uf := make( []*types.UserFile,0)
    32. 	//var cnt int64
    33. 	resp = new(types.UserFileListReply)
    34. 	size:=req.Size
    35. 	if size==0 {
    36. 		size=define.PageSize
    37. 	}
    38. 	page:=req.Page
    39. 	if page ==0{
    40. 		page=1
    41. 	}
    42. 	offset:=(page-1)*size
    43. 	//查询用户文件列表
    44. 	l.svcCtx.Engine.ShowSQL(true)//这样就可以看到运行时的sql语句
    45. 	err = l.svcCtx.Engine.Table("user_repository"). Where("parent_id = ? AND user_identity = ? ",req.Id,userIdentity).
    46. 		Select("user_repository.id,user_repository.identity,user_repository.repository_identity,user_repository.ext,"+
    47. 			"user_repository.name,repository_pool.path,repository_pool.size").
    48. 		Join("LEFT","repository_pool","user_repository.repository_identity=repository_pool.identity").
    49. 		Where("user_repository.deleted_at=? OR user_repository.deleted_at IS NULL",time.Time{}.Format("2006-01-02 15:04:05")).
    50. 		Limit(size,offset).Find(&uf)
    51. 	if err != nil {
    52. 		return
    53. 	}
    54. 	count, err := l.svcCtx.Engine.Where("parent_id = ? AND user_identity = ? ", req.Id, userIdentity).Count(new(Models.UserRepository))
    55. 	if err!=nil {
    56. 		return
    57. 	}
    58. 	resp.List = uf
    59. 	resp.Count = int(count)
    60.  
    61. 	return
    62. }

    ③用户文件名称修改

    code.api

    1. 	//用户文件名称修改
    2. 	@handler UserFileNameUpdate
    3. 	post /user/file/name/update (UserFileNameUpdateReguest) returns (UserFileNameUpdateReply)
    4. type UserFileNameUpdateReguest {
    5. 	Identity string `json:"identity"`
    6. 	Name     string `json:"name"`
    7. }
    8.  
    9. type UserFileNameUpdateReply {
    10. }

     logic 业务实现

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"context"
    6. 	"errors"
    7.  
    8. 	"CloudDisk/code/internal/svc"
    9. 	"CloudDisk/code/internal/types"
    10.  
    11. 	"github.com/zeromicro/go-zero/core/logx"
    12. )
    13.  
    14. type UserFileNameUpdateLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewUserFileNameUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFileNameUpdateLogic {
    21. 	return &UserFileNameUpdateLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *UserFileNameUpdateLogic) UserFileNameUpdate(req *types.UserFileNameUpdateReguest,userIdentity string) (resp *types.UserFileNameUpdateReply, err error) {
    29. 	// todo: add your logic here and delete this line
    30. 	//判断当前名称在该层下面是否存在
    31. 	count, err := l.svcCtx.Engine.Where("name=? AND parent_id=(SELECT parent_id FROM user_repository ur WHERE ur.identity=?)", req.Name, req.Identity).Count(new(Models.UserRepository))
    32. 	if err!=nil {
    33. 		return nil, err
    34. 	}
    35. 	if count >0{
    36. 		return nil,errors.New("该名称已经存在")
    37. 	}
    38. 	//文件修改
    39. 	data := &Models.UserRepository{Name: req.Name}
    40. 	l.svcCtx.Engine.Where("identity = ? AND user_identity = ? ", req.Identity, userIdentity).Update(data)
    41. 	if err != nil {
    42. 		return
    43. 	}
    44. 	return
    45. }

    ④用户文件夹创建

    code.api

    1. 	//用户文件夹创建
    2. 	@handler UserFolderCreate
    3. 	post /user/folder/create (UserFolderCreateReguest) returns (UserFolderCreateReply)
    4. type UserFolderCreateReguest {
    5. 	Name     string `json:"name"`
    6. 	ParentId int64  `json:"parent_id"`
    7. }
    8.  
    9. type UserFolderCreateReply {
    10. 	Identity string `json:"identity"`
    11. }

     logic

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7. 	"errors"
    8.  
    9. 	"CloudDisk/code/internal/svc"
    10. 	"CloudDisk/code/internal/types"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type UserFolderCreateLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewUserFolderCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFolderCreateLogic {
    22. 	return &UserFolderCreateLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *UserFolderCreateLogic) UserFolderCreate(req *types.UserFolderCreateReguest,userIdentity string) (resp *types.UserFolderCreateReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	//判断当前名称在该层下面是否存在
    32. 	count, err := l.svcCtx.Engine.Where("name=? AND parent_id=?", req.Name, req.ParentId).Count(new(Models.UserRepository))
    33. 	if err!=nil {
    34. 		return nil, err
    35. 	}
    36. 	if count >0{
    37. 		return nil,errors.New("该名称已经存在")
    38. 	}
    39. 	//创建文件夹
    40. 	data:=&Models.UserRepository{
    41. 		Identity: helper.GetUUID(),
    42. 		UserIdentity: userIdentity,
    43. 		ParentId: req.ParentId,
    44. 		Name: req.Name,
    45. 	}
    46. 	_, err = l.svcCtx.Engine.Insert(data)
    47. 	if err != nil {
    48. 		return
    49. 	}
    50. 	return
    51. }

    ⑤用户文件删除

    code.api

    1. 	//用户文件删除
    2. 	@handler UserFileDelete
    3. 	post /user/file/delete (UserFileDeleteReguest) returns (UserFileDeleteReply)
    4. type UserFileDeleteReguest {
    5. 	Identity string `json:"identity"`
    6. }
    7.  
    8. type UserFileDeleteReply {
    9. }

     logic

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"context"
    6.  
    7. 	"CloudDisk/code/internal/svc"
    8. 	"CloudDisk/code/internal/types"
    9.  
    10. 	"github.com/zeromicro/go-zero/core/logx"
    11. )
    12.  
    13. type UserFileDeleteLogic struct {
    14. 	logx.Logger
    15. 	ctx    context.Context
    16. 	svcCtx *svc.ServiceContext
    17. }
    18.  
    19. func NewUserFileDeleteLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFileDeleteLogic {
    20. 	return &UserFileDeleteLogic{
    21. 		Logger: logx.WithContext(ctx),
    22. 		ctx:    ctx,
    23. 		svcCtx: svcCtx,
    24. 	}
    25. }
    26.  
    27. func (l *UserFileDeleteLogic) UserFileDelete(req *types.UserFileDeleteReguest,userIdentity string) (resp *types.UserFileDeleteReply, err error) {
    28. 	// todo: add your logic here and delete this line
    29. 	_, err = l.svcCtx.Engine.Where("user_identity=? AND identity=?", userIdentity, req.Identity).Delete(new(Models.UserRepository))
    30. 	if err!=nil {
    31. 		return
    32. 	}
    33. 	return
    34. }

    ⑥用户文件移动

    code.api，注意是 PUT 请求

    1. 	//用户文件移动
    2. 	@handler UserFileMove
    3. 	put  /user/file/move (UserFileMoveReguest) returns (UserFileMoveReply)
    4. type UserFileMoveReguest {
    5. 	Identity       string `json:"identity"`
    6. 	ParentIdentity string `json:"parentIdentity"`
    7. }
    8.  
    9. type UserFileMoveReply {
    10. }

     logic

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"context"
    6. 	"errors"
    7.  
    8. 	"CloudDisk/code/internal/svc"
    9. 	"CloudDisk/code/internal/types"
    10.  
    11. 	"github.com/zeromicro/go-zero/core/logx"
    12. )
    13.  
    14. type UserFileMoveLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewUserFileMoveLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserFileMoveLogic {
    21. 	return &UserFileMoveLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *UserFileMoveLogic) UserFileMove(req *types.UserFileMoveReguest,userIdentity string) (resp *types.UserFileMoveReply, err error) {
    29. 	// todo: add your logic here and delete this line
    30. 	parentDate := new(Models.UserRepository)
    31. 	has, err := l.svcCtx.Engine.Where("identity=? AND user_identity=?", req.ParentIdentity, userIdentity).Get(parentDate)
    32. 	if err!=nil {
    33. 		return nil, err
    34. 	}
    35. 	if !has {
    36. 		return nil,errors.New("文件夹不存在！")
    37. 	}
    38. 	//更新记录的ParentID
    39. 	_, err = l.svcCtx.Engine.Where("identity=?", req.Identity).Update(Models.UserRepository{
    40. 		ParentId: int64(parentDate.Id),
    41. 	})
    42. 	return
    43. }

    三、文件共享模块

    （1）文件分享

    ①创建分享记录

    code.api

    1. 	//创建分享记录
    2. 	@handler ShareBasicCreate
    3. 	post /share/basic/create (ShareBasicCreateRequest) returns (ShareBasicCreateReply)
    4. type ShareBasicCreateRequest {
    5. 	RepositoryIdentity string `json:"repository_identity"`
    6. 	ExpiredTime        int    `json:"expired_time"`
    7. }
    8.  
    9. type ShareBasicCreateReply {
    10. 	Identity string `json:"identity"`
    11. }

    logic

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7.  
    8. 	"CloudDisk/code/internal/svc"
    9. 	"CloudDisk/code/internal/types"
    10.  
    11. 	"github.com/zeromicro/go-zero/core/logx"
    12. )
    13.  
    14. type ShareBasicCreateLogic struct {
    15. 	logx.Logger
    16. 	ctx    context.Context
    17. 	svcCtx *svc.ServiceContext
    18. }
    19.  
    20. func NewShareBasicCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShareBasicCreateLogic {
    21. 	return &ShareBasicCreateLogic{
    22. 		Logger: logx.WithContext(ctx),
    23. 		ctx:    ctx,
    24. 		svcCtx: svcCtx,
    25. 	}
    26. }
    27.  
    28. func (l *ShareBasicCreateLogic) ShareBasicCreate(req *types.ShareBasicCreateRequest, userIdentity string) (resp *types.ShareBasicCreateReply, err error) {
    29. 	// todo: add your logic here and delete this line
    30. 	uuid := helper.GetUUID()
    31. 	data := &Models.ShareBasic{
    32. 		Identity:           uuid,
    33. 		UserIdentity:       userIdentity,
    34. 		RepositoryIdentity: req.RepositoryIdentity,
    35. 		ExpiredTime:        req.ExpiredTime,
    36. 	}
    37. 	_, err = l.svcCtx.Engine.Insert(data)
    38. 	if err != nil {
    39. 		return
    40. 	}
    41. 	resp = &types.ShareBasicCreateReply{
    42. 		Identity: uuid,
    43. 	}
    44. 	return
    45. }

    ②获取资源详情

    对于这个模块，就不用登录的中间件了，因为未登录的应该也可以获取到别人分享的文件。所以就写在用户登录等的那个api块里就行。

    code.api

    1. 	//获取资源详情
    2. 	@handler ShareBasicDetail
    3. 	get /share/basic/detail (ShareBasicDetailRequest) returns (ShareBasicDetailReply)
    4. type ShareBasicDetailRequest {
    5. 	Identity string `json:"identity"`
    6. }
    7.  
    8. type ShareBasicDetailReply {
    9. 	RepositoryIdentity string `json:"repository_identity"`
    10. 	Name               string `json:"name"`
    11. 	Ext                string `json:"ext"`
    12. 	Size               int64  `json:"size"`
    13. 	Path               string `json:"path"`
    14. }

    Models

    1. package Models
    2.  
    3. import "time"
    4.  
    5. type ShareBasic struct {
    6. 	Id int
    7. 	Identity string
    8. 	UserIdentity string
    9. 	RepositoryIdentity string
    10. 	ExpiredTime int
    11. 	ClickNum int
    12. 	CreatedAt time.Time `xorm:"created"`
    13. 	UpdatedAt time.Time `xorm:"updated"`
    14. 	DeletedAt time.Time `xorm:"deleted"`
    15. }
    16.  
    17. func (table ShareBasic)TableName( ) string {
    18. 	return "share_basic"
    19. }

    logic

    1. package logic
    2.  
    3. import (
    4. 	"context"
    5.  
    6. 	"CloudDisk/code/internal/svc"
    7. 	"CloudDisk/code/internal/types"
    8.  
    9. 	"github.com/zeromicro/go-zero/core/logx"
    10. )
    11.  
    12. type ShareBasicDetailLogic struct {
    13. 	logx.Logger
    14. 	ctx    context.Context
    15. 	svcCtx *svc.ServiceContext
    16. }
    17.  
    18. func NewShareBasicDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShareBasicDetailLogic {
    19. 	return &ShareBasicDetailLogic{
    20. 		Logger: logx.WithContext(ctx),
    21. 		ctx:    ctx,
    22. 		svcCtx: svcCtx,
    23. 	}
    24. }
    25.  
    26. func (l *ShareBasicDetailLogic) ShareBasicDetail(req *types.ShareBasicDetailRequest) (resp *types.ShareBasicDetailReply, err error) {
    27. 	// todo: add your logic here and delete this line
    28. 	//对分享记录的点击次数进行 +1 操作
    29. 	_, err = l.svcCtx.Engine.Exec("UPDATE share_basic SET click_num = click_num + 1 WHERE identity = ?", req.Identity)
    30. 	if err!=nil {
    31. 		return
    32. 	}
    33. 	//获取资源的详细信息
    34. 	resp= new(types.ShareBasicDetailReply)
    35. 	_, err = l.svcCtx.Engine.Table("share_basic").
    36. 		Select("share_basic.repository_identity,repository_pool.name,repository_pool.ext,repository_pool.size,repository_pool.path").
    37. 		Join("LEFT", "repository_pool", "share_basic.repository_identity=repository_pool.identity").
    38. 		Where("share_basic.identity=?", req.Identity).Get(resp)
    39. 	return
    40. }

    ③资源保存

    需要用户登录的中间件，code.api 

    1. 	//资源保存
    2. 	@handler ShareBasicSave
    3. 	post /share/basic/save (ShareBasicSaveRequest) returns (ShareBasicSaveReply)
    4. type ShareBasicSaveRequest {
    5. 	RepositoryIdentity string `json:"repository_identity"`
    6. 	ParentId           int64  `json:"parent_id"`
    7. }
    8.  
    9. type ShareBasicSaveReply {
    10. 	Identity string `json:"identity"`
    11. }

    logic

    1. package logic
    2.  
    3. import (
    4. 	"CloudDisk/code/Models"
    5. 	"CloudDisk/code/helper"
    6. 	"context"
    7. 	"errors"
    8.  
    9. 	"CloudDisk/code/internal/svc"
    10. 	"CloudDisk/code/internal/types"
    11.  
    12. 	"github.com/zeromicro/go-zero/core/logx"
    13. )
    14.  
    15. type ShareBasicSaveLogic struct {
    16. 	logx.Logger
    17. 	ctx    context.Context
    18. 	svcCtx *svc.ServiceContext
    19. }
    20.  
    21. func NewShareBasicSaveLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShareBasicSaveLogic {
    22. 	return &ShareBasicSaveLogic{
    23. 		Logger: logx.WithContext(ctx),
    24. 		ctx:    ctx,
    25. 		svcCtx: svcCtx,
    26. 	}
    27. }
    28.  
    29. func (l *ShareBasicSaveLogic) ShareBasicSave(req *types.ShareBasicSaveRequest,userIdentity string) (resp *types.ShareBasicSaveReply, err error) {
    30. 	// todo: add your logic here and delete this line
    31. 	//获取资源详情
    32. 	rp:=new(Models.RepositoryPool)
    33. 	has, err := l.svcCtx.Engine.Where("identity=?", req.RepositoryIdentity).Get(rp)
    34. 	if err!=nil {
    35. 		return nil, err
    36. 	}
    37. 	if !has {
    38. 		return nil,errors.New("资源不存在")
    39. 	}
    40. 	//user_repository 资源保存
    41. 	ur:=&Models.UserRepository{
    42. 		Identity: helper.GetUUID(),
    43. 		UserIdentity: userIdentity,
    44. 		ParentId: req.ParentId,
    45. 		RepositoryIdentity: req.RepositoryIdentity,
    46. 		Ext: rp.Ext,
    47. 		Name: rp.Name,
    48. 	}
    49. 	_, err = l.svcCtx.Engine.Insert(ur)
    50. 	resp=new(types.ShareBasicSaveReply)
    51. 	resp.Identity=ur.Identity
    52. 	return
    53. }
  • 相关阅读:
    长城新能源汽车，战力已蓄满
    Apache Sqoop_2
    使用 GRPC C++ API连接Java的RPC服务
    拙见--springMVC的controller接受的请求参数
    能不能绕过c去学c++？
    C进阶 - 指针进阶
    虹科案例 | 增量式编码器&紧急停止开关之案例研究（下）
    2022年湖北工业大学招生简章之高起专、专升本非全日制学历提升
    哪个牌子除甲醛产品效果好 目前除甲醛最好的净化器
    Python数据类型 ——— 字典
  • 原文地址：https://blog.csdn.net/m0_51530927/article/details/128050856