init: initial commit

service/enter.go

@@ -0,0 +1,13 @@
+package service
+
+import (
+	"sundynix-go/service/plant"
+	"sundynix-go/service/system"
+)
+
+var GroupApp = new(Group)
+
+type Group struct {
+	SystemServiceGroup system.ServiceGroup
+	PlantServiceGroup  plant.ServiceGroup
+}

service/plant/enter.go

@@ -0,0 +1,5 @@
+package plant
+
+type ServiceGroup struct {
+	MyPlantService
+}

service/plant/my_plant.go

@@ -0,0 +1,224 @@
+package plant
+
+import (
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/plant"
+	plantReq "sundynix-go/model/plant/request"
+	plantRes "sundynix-go/model/plant/response"
+	"sundynix-go/model/system"
+	"sundynix-go/utils/timer"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type MyPlantService struct{}
+
+var MyPlantServiceApp = new(MyPlantService)
+
+// AddPlant 添加植物
+func (s *MyPlantService) AddPlant(req plantReq.CreateMyPlant, id string) error {
+	err := global.DB.Transaction(func(tx *gorm.DB) error {
+		//1. 验证oss是否存在
+		var ossList []*system.Oss
+		err := tx.Where("id in ?", req.OssIds).Find(&ossList).Error
+		if err != nil {
+			return err
+		}
+		bgTime := timer.GetZeroTime()
+		//2. 处理养护计划
+		var carePlans []*plant.CarePlan
+		for _, v := range req.CarePlans {
+			carePlans = append(carePlans, &plant.CarePlan{
+				UserId: id,
+				Name:   v.Name,
+				Icon:   v.Icon,
+				Period: v.Period,
+			})
+		}
+		//3.保存数据
+		myPlant := plant.MyPlant{
+			UserId:           id,
+			Name:             req.Name,
+			PlantTime:        bgTime,
+			Status:           1,
+			Placement:        req.Placement,
+			PotMaterial:      req.PotMaterial,
+			PotSize:          req.PotSize,
+			Sunlight:         req.Sunlight,
+			PlantingMaterial: req.PlantingMaterial,
+			CarePlans:        carePlans,
+		}
+		err = tx.Create(&myPlant).Error
+		if err != nil {
+			return err
+		}
+
+		//4.处理图片关系
+		if len(ossList) > 0 {
+			var relations []map[string]interface{}
+			for _, oss := range ossList {
+				relations = append(relations, map[string]interface{}{
+					"my_plant_id": myPlant.Id,
+					"oss_id":      oss.Id,
+				})
+			}
+			err = tx.Table("sundynix_my_plant_oss").Create(relations).Error
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return err
+
+}
+
+// PlantPage 植物列表
+func (s *MyPlantService) PlantPage(req common.PageInfo, userId string) (list interface{}, total int64, err error) {
+	limit := req.PageSize
+	offset := req.PageSize * (req.Current - 1)
+	db := global.DB.Model(&plant.MyPlant{}).Preload("ImgList", func(db *gorm.DB) *gorm.DB {
+		return db.Order("created_at desc")
+	})
+	var myPlants []*plant.MyPlant
+	db = db.Where("user_id = ?", userId)
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Order("created_at desc").Find(&myPlants).Error
+	return myPlants, total, err
+}
+
+// PlantDetail 植物详情
+func (s *MyPlantService) PlantDetail(id string) (p plant.MyPlant, err error) {
+	var res plant.MyPlant
+	err = global.DB.Where("id = ?", id).
+		Preload("ImgList", func(db *gorm.DB) *gorm.DB {
+			return db.Order("created_at desc")
+		}).
+		Preload("CarePlans").
+		Preload("CareRecords").
+		First(&res).Error
+
+	//不存在的时候不要返回错误，而是返回nil
+	if err != nil {
+		return res, err
+	}
+	return res, nil
+}
+
+func (s *MyPlantService) UpdatePlant(req plantReq.UpdateMyPlant) error {
+	// 以map形式更新 先构建map
+	updateMap := map[string]interface{}{
+		"name":              req.Name,
+		"placement":         req.Placement,
+		"planting_material": req.PlantingMaterial,
+		"pot_material":      req.PotMaterial,
+		"pot_size":          req.PotSize,
+		"sunlight":          req.Sunlight,
+	}
+	return global.DB.Model(&plant.MyPlant{}).Where("id = ?", req.Id).Updates(updateMap).Error
+}
+
+// TodayTask 今日任务
+func (s *MyPlantService) TodayTask(userId string) ([]plantRes.PlantTaskVO, error) {
+	today := timer.GetZeroTime()
+	endOfToday := today.Add(24 * time.Hour)
+
+	var tasks []*plant.CareTask
+	// 查询条件：1.未完成的任务(包含今天和以前逾期的) 2.今天已经完成的任务
+	err := global.DB.Where("user_id = ? AND ("+
+		"(status = 1 AND due_date < ?) OR "+
+		"(status = 2 AND completed_at >= ? AND completed_at < ?)"+
+		")", userId, endOfToday, today, endOfToday).
+		Order("due_date ASC").
+		Find(&tasks).Error
+	if err != nil {
+		return nil, err
+	}
+	// 2.内存处理：聚合数据
+	plantTaskMap := make(map[string][]*plant.CareTask)
+	expiredMap := make(map[string]bool)
+	var plantIds []string
+	for _, t := range tasks {
+		plantIds = append(plantIds, t.PlantId)
+		plantTaskMap[t.PlantId] = append(plantTaskMap[t.PlantId], t)
+		// 判定右上角红标：状态为待办 且 应做时间早于今天
+		if t.Status == 1 && t.DueDate.Before(today) {
+			expiredMap[t.PlantId] = true
+		}
+	}
+	//3.批量查询植物
+	var myPlants []*plant.MyPlant
+	err = global.DB.Where("id in ?", plantIds).Preload("ImgList", func(db *gorm.DB) *gorm.DB {
+		return db.Order("created_at desc")
+	}).Find(&myPlants).Error
+	if err != nil {
+		return nil, err
+	}
+	//4.组装结果
+	var res []plantRes.PlantTaskVO
+	for _, p := range myPlants {
+		plantTaskVO := plantRes.PlantTaskVO{
+			MyPlant:    p,
+			HasExpired: expiredMap[p.Id],
+			Tasks:      plantTaskMap[p.Id],
+		}
+		res = append(res, plantTaskVO)
+	}
+	return res, nil
+}
+
+// CompleteTask 完成任务
+func (s *MyPlantService) CompleteTask(req plantReq.CompleteTask) error {
+	return global.DB.Transaction(func(tx *gorm.DB) error {
+		var task plant.CareTask
+		if err := tx.Where("id = ?", req.TaskId).First(&task).Error; err != nil {
+			return err
+		}
+		//1.更新当前任务为完成
+		updateData := map[string]interface{}{
+			"status":       2,
+			"completed_at": time.Now(),
+		}
+		if err := tx.Model(&task).Where("id = ?", req.TaskId).Updates(updateData).Error; err != nil {
+			return err
+		}
+		//2.获取计划模版
+		var plan plant.CarePlan
+		if err := tx.Where("id = ?", task.PlanId).First(&plan).Error; err != nil {
+			return err
+		}
+		//3.生成下个周期的任务
+		today := timer.GetZeroTime()
+		nextDueDate := today.AddDate(0, 0, plan.Period)
+		newTask := plant.CareTask{
+			UserId:  plan.UserId,
+			PlantId: plan.PlantId,
+			PlanId:  plan.Id,
+			Name:    plan.Name,
+			Icon:    plan.Icon,
+			DueDate: nextDueDate,
+			Status:  1,
+		}
+		if err := tx.Create(&newTask).Error; err != nil {
+			return err
+		}
+		//4.保存养护记录
+		record := plant.CareRecord{
+			UserId:  plan.UserId,
+			PlantId: plan.PlantId,
+			PlanId:  plan.Id,
+			Name:    plan.Name,
+			Icon:    plan.Icon,
+			Remark:  req.Remark,
+		}
+		if err := tx.Create(&record).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+}

service/plant/pay.go

@@ -0,0 +1,206 @@
+package plant
+
+//
+//import (
+//	"context"
+//	"errors"
+//	"net/http"
+//	"sundynix-go/global"
+//	"sundynix-go/model/plant"
+//	"sundynix-go/model/system"
+//	"sundynix-go/utils/wechat"
+//
+//	"github.com/gin-gonic/gin"
+//	"github.com/wechatpay-apiv3/wechatpay-go/core"
+//	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
+//	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
+//	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
+//	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"
+//	"github.com/wechatpay-apiv3/wechatpay-go/utils"
+//	"go.uber.org/zap"
+//	"gorm.io/gorm"
+//)
+//
+//type PayService struct{}
+//
+//var PayServiceApp = new(PayService)
+//
+//// PrePay 预支付
+//func (s *PayService) PrePay(orderId, userId string) (resp *jsapi.PrepayWithRequestPaymentResponse, err error) {
+//	//1.查询订单和 用户
+//	var order plant.Order
+//	err = global.DB.Where("id = ?", orderId).First(&order).Error
+//	if err != nil {
+//		return nil, err
+//	}
+//	var user system.User
+//	err = global.DB.Where("id = ?", userId).First(&user).Error
+//	if err != nil {
+//		return nil, err
+//	}
+//	payClient, err := wechat.GetWxPayClient()
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	svc := jsapi.JsapiApiService{Client: payClient}
+//	result, _, err := svc.PrepayWithRequestPayment(context.Background(),
+//		jsapi.PrepayRequest{
+//			Appid:       core.String(global.Config.MiniProgram.AppId),
+//			Mchid:       core.String(global.Config.WechatPay.MchId),
+//			Description: core.String(order.Name),
+//			OutTradeNo:  core.String(order.OutTradeNo),
+//			//TimeExpire:    core.Time(time.Now()), //选填
+//			//Attach:        core.String("自定义数据说明"), //选填
+//			NotifyUrl: core.String(global.Config.WechatPay.NotifyUrl),
+//			//GoodsTag:      core.String("WXG"),  //选填
+//			//SupportFapiao: core.Bool(false),  //选填
+//			Amount: &jsapi.Amount{
+//				Currency: core.String("CNY"),
+//				Total:    core.Int64(int64(order.Amount)),
+//			},
+//			Payer: &jsapi.Payer{
+//				Openid: core.String(user.MiniOpenId),
+//			},
+//			//Detail: &jsapi.Detail{
+//			//	CostPrice: core.Int64(608800),
+//			//	GoodsDetail: []jsapi.GoodsDetail{jsapi.GoodsDetail{
+//			//		GoodsName:        core.String("iPhoneX 256G"),
+//			//		MerchantGoodsId:  core.String("ABC"),
+//			//		Quantity:         core.Int64(1),
+//			//		UnitPrice:        core.Int64(828800),
+//			//		WechatpayGoodsId: core.String("1001"),
+//			//	}},
+//			//	InvoiceId: core.String("wx123"),
+//			//},  //选填
+//			//SceneInfo: &jsapi.SceneInfo{
+//			//	DeviceId:      core.String("013467007045764"),
+//			//	PayerClientIp: core.String("14.23.150.211"),
+//			//	StoreInfo: &jsapi.StoreInfo{
+//			//		Address:  core.String("广东省深圳市南山区科技中一道10000号"),
+//			//		AreaCode: core.String("440305"),
+//			//		Id:       core.String("0001"),
+//			//		Name:     core.String("腾讯大厦分店"),
+//			//	},
+//			//},
+//			//SettleInfo: &jsapi.SettleInfo{
+//			//	ProfitSharing: core.Bool(false),
+//			//},  //选填
+//		})
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	return result, nil
+//
+//}
+//
+//// PayCallback 支付回调
+//func (s *PayService) PayCallback(c *gin.Context) error {
+//	//1.加载共钥
+//	mchPublicKeyPath := global.Config.WechatPay.PublicKeyPath
+//	mchPublicKey, err := utils.LoadPublicKeyWithPath(mchPublicKeyPath)
+//	if err != nil {
+//		return err
+//	}
+//	ctx := context.Background()
+//	//2.创建客户端
+//	handler, err := notify.NewRSANotifyHandler(global.Config.WechatPay.MchAPIv3Key,
+//		verifiers.NewSHA256WithRSAPubkeyVerifier(global.Config.WechatPay.PublicKeyId, *mchPublicKey))
+//	if err != nil {
+//		return err
+//	}
+//	//3.验签 解密
+//	//将支付回调通知中的内容，解析为 payments.Transaction。
+//	transaction := new(payments.Transaction)
+//	notifyReq, err := handler.ParseNotifyRequest(ctx, c.Request, transaction)
+//	// 4.如果验签未通过，或者解密失败
+//	if err != nil {
+//		//应答微信
+//		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+//			"code":    "FAIL",
+//			"message": "失败",
+//		})
+//		global.Logger.Error("wxPay回调-验签或解密:", zap.Error(err))
+//		return err
+//	}
+//	//5.应答微信
+//	c.Status(http.StatusOK)
+//	// 6.处理通知内容
+//	global.Logger.Info("wxPay回调-成功:", zap.Any("notifyReq", notifyReq.Summary))
+//	//7. 异步处理数据
+//	go func() {
+//		payNotify := plant.PayNotify{
+//			Amount:         *transaction.Amount.Total,
+//			Currency:       *transaction.Amount.Currency,
+//			PayerCurrency:  *transaction.Amount.PayerCurrency,
+//			PayerTotal:     *transaction.Amount.PayerTotal,
+//			Appid:          *transaction.Appid,
+//			Mchid:          *transaction.Mchid,
+//			OutTradeNo:     *transaction.OutTradeNo,
+//			Attach:         *transaction.Attach,
+//			BankType:       *transaction.BankType,
+//			Payer:          *transaction.Payer.Openid,
+//			SuccessTime:    *transaction.SuccessTime,
+//			TradeState:     *transaction.TradeState,
+//			TradeStateDesc: *transaction.TradeStateDesc,
+//			TradeType:      *transaction.TradeType,
+//			TransactionId:  *transaction.TransactionId,
+//		}
+//		//7.1 回调记录
+//		err = global.DB.Create(&payNotify).Error
+//		if err != nil {
+//			global.Logger.Error("wxPay回调-存储数据异常:", zap.Error(err))
+//		}
+//		if payNotify.TradeState == "SUCCESS" {
+//			//7.2 扣商品库存
+//			var order plant.Order
+//			err = global.DB.Where("out_trade_no = ?", *transaction.OutTradeNo).First(&order).Error
+//			if err != nil {
+//				if errors.Is(err, gorm.ErrRecordNotFound) {
+//					global.Logger.Error("wxPay回调-订单不存在:", zap.Error(err))
+//				}
+//			}
+//			//根据订单找到领取记录
+//			var record plant.ClaimPlantRecord
+//			err = global.DB.Where("order_id = ?", order.Id).First(&record).Error
+//			if err != nil {
+//				if errors.Is(err, gorm.ErrRecordNotFound) {
+//					global.Logger.Error("wxPay回调-领取记录不存在:", zap.Error(err))
+//				}
+//			}
+//			//根据领取记录找到植物
+//			var claimPlant plant.ClaimPlant
+//			err = global.DB.Where("id = ?", record.ClaimPlantId).First(&claimPlant).Error
+//			if err != nil {
+//				if errors.Is(err, gorm.ErrRecordNotFound) {
+//					global.Logger.Error("wxPay回调-植物不存在:", zap.Error(err))
+//				}
+//			}
+//			err = global.DB.Transaction(func(tx *gorm.DB) error {
+//				//扣库存
+//				if err = tx.Model(&claimPlant).Update("stock", gorm.Expr("stock - ?", 1)).Error; err != nil {
+//					return err
+//				}
+//				//订单状态
+//				if err = tx.Model(&order).Update("pay_status", "SUCCESS").Error; err != nil {
+//					return err
+//				}
+//				//修改领取记录为成功
+//				if err = tx.Model(&record).Update("status", 1).Error; err != nil {
+//					return err
+//				}
+//				//减用户积分
+//				if err = tx.Model(&plant.Personal{}).Where("user_id = ?", order.UserId).Update("points_count", gorm.Expr("points_count - ?", claimPlant.Points)).Error; err != nil {
+//					return err
+//				}
+//				return nil
+//			})
+//		}
+//		if err != nil {
+//			return
+//		}
+//	}()
+//	return nil
+//
+//}

service/system/enter.go

@@ -0,0 +1,11 @@
+package system
+
+type ServiceGroup struct {
+	JwtService
+	UserService
+	ClientService
+	RoleService
+	MenuService
+	OperationRecordService
+	OssService
+}

service/system/oss.go

@@ -0,0 +1,135 @@
+package system
+
+import (
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"image"
+	_ "image/jpeg"
+	_ "image/png"
+	"io"
+	"mime/multipart"
+	"strings"
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/system"
+	sysReq "sundynix-go/model/system/request"
+	"sundynix-go/utils/upload"
+
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+)
+
+type OssService struct {
+}
+
+var OssServiceApp = new(OssService)
+
+func (o *OssService) Save(file system.Oss) error {
+	return global.DB.Create(&file).Error
+}
+
+func (o *OssService) Upload(multipartFile multipart.File, header *multipart.FileHeader) (file system.Oss, err error) {
+	//1.检查是否已有此文件
+	temp, err := header.Open()
+	if err != nil {
+		return file, err
+	}
+	defer temp.Close()
+
+	hasher := md5.New()
+	if _, copyErr := io.Copy(hasher, temp); copyErr != nil {
+		return file, copyErr
+	}
+	// 步骤3: 计算哈希值并转换为十六进制字符串
+	hashBytes := hasher.Sum(nil)
+	hashString := fmt.Sprintf("%x", hashBytes)
+	var exist system.Oss
+	findErr := global.DB.Where("md5 = ?", hashString).First(&exist).Error
+	if findErr == nil && exist.Id != "" {
+		return exist, nil
+	}
+	if errors.Is(findErr, gorm.ErrRecordNotFound) {
+		//不存在的时候保存
+		instance := upload.OssInstance()
+		filepath, key, uploadErr := instance.UploadFile(header)
+		if uploadErr != nil {
+			return file, uploadErr
+		}
+		//文件后缀
+		s := strings.Split(header.Filename, ".")
+		height := 0
+		width := 0
+		//mime类型
+		contentType := header.Header.Get("Content-Type")
+		allowedImageTypes := map[string]bool{
+			"image/jpeg": true,
+			"image/png":  true,
+		}
+		isPossibleImage := allowedImageTypes[contentType]
+		//仅当可能是图片时 才计算图片宽高
+		if isPossibleImage {
+			img, _, err1 := image.Decode(multipartFile)
+			if err1 != nil {
+				return file, err
+			}
+			height = img.Bounds().Max.Y
+			width = img.Bounds().Max.X
+		}
+		f := system.Oss{
+			Key:    key, // uploads/2025-09-17/
+			Name:   header.Filename,
+			Suffix: s[len(s)-1],
+			Tag:    s[len(s)-1],
+			Url:    filepath, // http://127.0.0.1:9000/planting-fun/uploads/2025-09-17/211476f3837fc7acbaebf0f901c1bd68.png
+			MD5:    hashString,
+			Height: height,
+			Width:  width,
+		}
+		return f, global.DB.Create(&f).Error
+	}
+	return file, err
+}
+
+func (o *OssService) DeleteFileByIds(ids common.IdsReq) error {
+	//循环删除
+	instance := upload.OssInstance()
+	for _, id := range ids.Ids {
+		file, err := o.GetById(id)
+		if err != nil {
+			return err
+		}
+		if err = instance.DeleteFile(file.Key); err != nil {
+			global.Logger.Error("删除文件失败!", zap.Error(err))
+			return err
+		}
+	}
+	err := global.DB.Where("id IN (?)", ids.Ids).Delete(&system.Oss{}).Error
+	return err
+}
+
+func (o *OssService) GetById(id string) (system.Oss, error) {
+	var file system.Oss
+	err := global.DB.Where("id = ?", id).First(&file).Error
+	//不存在的时候不要返回错误，而是返回nil
+	if err != nil {
+		return file, nil
+	}
+	return file, err
+}
+
+func (o *OssService) GetFileList(info sysReq.GetOssFileList) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Current - 1)
+	db := global.DB.Model(&system.Oss{})
+	var files []system.Oss
+	if info.Name != "" {
+		db = db.Where("name LIKE ?", "%"+info.Name+"%")
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Order("created_at desc").Find(&files).Error
+	return files, total, err
+}

service/system/sys_client.go

@@ -0,0 +1,61 @@
+package system
+
+import (
+	"errors"
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/system"
+	systemReq "sundynix-go/model/system/request"
+
+	"gorm.io/gorm"
+)
+
+type ClientService struct{}
+
+var ClientServiceApp = new(ClientService)
+
+func (s *ClientService) SaveClient(client system.Client) error {
+	if !errors.Is(global.DB.Where("client_id = ?", client.ClientId).First(&system.Client{}).Error, gorm.ErrRecordNotFound) {
+		return errors.New("存在重复clientId，请修改clientId")
+	}
+	return global.DB.Create(&client).Error
+}
+
+func (s *ClientService) UpdateClient(client system.Client) error {
+	return global.DB.Model(&client).Where("id = ?", client.Id).Updates(&client).Error
+}
+
+func (s *ClientService) GetClientList(info systemReq.GetClientList) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Current - 1)
+	db := global.DB.Model(&system.Client{})
+	var clientList []system.Client
+	if info.ClientId != "" {
+		db = db.Where("client_id = ?", info.ClientId)
+	}
+	if info.Name != "" {
+		db = db.Where("name LIKE ?", "%"+info.Name+"%")
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Find(&clientList).Error
+	return clientList, total, err
+}
+
+func (s *ClientService) DeleteClientByIds(ids common.IdsReq) (err error) {
+	return global.DB.Where("id IN (?)", ids.Ids).Delete(&system.Client{}).Error
+}
+
+func (s *ClientService) GetClientById(id string) (client system.Client, err error) {
+	var c system.Client
+	err = global.DB.Where("id = ?", id).First(&c).Error
+	return c, err
+}
+
+func (s *ClientService) GetClientByClientId(clientId string) (client *system.Client, err error) {
+	var c system.Client
+	err = global.DB.Where("client_id = ?", clientId).First(&c).Error
+	return &c, err
+}

service/system/sys_jwt.go

@@ -0,0 +1,26 @@
+package system
+
+import (
+	"context"
+	"sundynix-go/global"
+	"sundynix-go/utils"
+)
+
+type JwtService struct{}
+
+var JwtServiceApp = new(JwtService)
+
+// 登出，禁用jwt
+func (s *JwtService) PutBlacklist(userId string, token string) (err error) {
+	expire, err := utils.ParseDuration(global.Config.JWT.ExpiresTime)
+	if err != nil {
+		return err
+	}
+	err = global.Redis.Set(context.Background(), userId, token, expire).Err()
+	return err
+}
+
+func (s *JwtService) IsInBlacklist(userId string, token string) bool {
+	val, err := global.Redis.Get(context.Background(), userId).Result()
+	return err == nil && val == token
+}

service/system/sys_menu.go

@@ -0,0 +1,126 @@
+package system
+
+import (
+	"errors"
+	"sundynix-go/global"
+	"sundynix-go/model/system"
+
+	"gorm.io/gorm"
+)
+
+type MenuService struct{}
+
+var MenuServiceApp = new(MenuService)
+
+func (s *MenuService) SaveMenu(menu system.Menu) error {
+	//1.根据code和name查询是否存在重名
+	if err := global.DB.Where("code = ? or name = ?", menu.Code, menu.Name).First(&system.Menu{}).Error; err == nil {
+		return errors.New("菜单已存在")
+	}
+	return global.DB.Create(&menu).Error
+}
+
+func (s *MenuService) UpdateMenu(menu *system.Menu) (err error) {
+	var sysMenu system.Menu
+	menuMap := map[string]interface{}{
+		"Category":   menu.Category,
+		"Name":       menu.Name,
+		"Title":      menu.Title,
+		"Code":       menu.Code,
+		"Permission": menu.Permission,
+		"Locale":     menu.Locale,
+		"Icon":       menu.Icon,
+		"Sort":       menu.Sort,
+	}
+	err = global.DB.Where("id = ?", menu.Id).First(&sysMenu).Error
+	if err != nil {
+		global.Logger.Debug(err.Error())
+		return errors.New("查询菜单失败")
+	}
+	err = global.DB.Model(&sysMenu).Updates(menuMap).Error
+	return err
+}
+
+func (s *MenuService) DeleteMenu(id string) (err error) {
+	err = global.DB.First(&system.Menu{}, "parent_id = ?", id).Error
+	if err == nil {
+		return errors.New("请先删除子菜单")
+	}
+	var menu system.Menu
+	err = global.DB.Where("id = ?", id).First(&menu).Error
+	if err != nil {
+		return errors.New("菜单记录不存在")
+	}
+	// 同步删除menu表和role-menu表数据
+	return global.DB.Transaction(func(tx *gorm.DB) error {
+		if err = tx.Where("id = ?", id).Delete(&system.Menu{}).Error; err != nil {
+			return err
+		}
+		if err = tx.Where("menu_id = ?", id).Delete(&system.RoleMenu{}).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (s *MenuService) GetMenuById(id string) (menu system.Menu, err error) {
+	var m system.Menu
+	err = global.DB.Where("id = ?", id).First(&m).Error
+	return m, err
+}
+
+func (s *MenuService) GetAllMenuTree(category int, parentId string) (menus []*system.Menu, err error) {
+	//1,先根据category和parentId获取所有菜单 category默认为0,parentId默认为0
+	//2.讲查询出的列表构建为树结构
+	var menuList []*system.Menu
+	db := global.DB.Model(&system.Menu{})
+	if category != 0 {
+		db.Where("category = ?", category)
+	}
+	if parentId != "0" {
+		db.Where("parent_id = ?", parentId)
+	}
+	err = db.Order("sort asc").Find(&menuList).Error
+	if err != nil {
+		return nil, err
+	}
+	tree := buildMenuTree(menuList)
+	return tree, nil
+}
+
+func (s *MenuService) GetUserRoutes(userId string) (menus []*system.Menu, err error) {
+	//1.根据userId 查询角色 根据角色查询菜单 去重
+	//2.构建树结构
+	var roleIds []string
+	err = global.DB.Model(&system.UserRole{}).Where("user_id = ?", userId).Pluck("role_id", &roleIds).Error
+	var menuIds []string
+	err = global.DB.Model(&system.RoleMenu{}).Where("role_id in ?", roleIds).Pluck("menu_id", &menuIds).Error
+	var menuList []*system.Menu
+	err = global.DB.Model(&system.Menu{}).Where("id in ?", menuIds).Order("sort asc").Find(&menuList).Error
+	return buildMenuTree(menuList), nil
+}
+
+func buildMenuTree(list []*system.Menu) []*system.Menu {
+	//1.定义一个map
+	menuMap := make(map[string]*system.Menu)
+	for _, item := range list {
+		menuMap[item.Id] = item
+	}
+	//构建树结构
+	var treeList []*system.Menu
+	for _, item := range list {
+		if item.ParentId == "0" {
+			// 如果没有父节点，直接添加到树中
+			treeList = append(treeList, item)
+		} else {
+			if parent, exists := menuMap[item.ParentId]; exists {
+				// 如果有父节点，将当前节点添加到父节点的Children中
+				parent.Children = append(parent.Children, item)
+			} else {
+				// 如果没有父节点，将当前节点添加到树中
+				treeList = append(treeList, item)
+			}
+		}
+	}
+	return treeList
+}

service/system/sys_operation_record.go

@@ -0,0 +1,57 @@
+package system
+
+import (
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/system"
+	systemReq "sundynix-go/model/system/request"
+)
+
+type OperationRecordService struct{}
+
+var OperationRecordServiceApp = new(OperationRecordService)
+
+func (o *OperationRecordService) CreateOperationRecord(operationRecord system.SysOperationRecord) (err error) {
+	return global.DB.Create(&operationRecord).Error
+}
+
+func (o *OperationRecordService) GetRecordList(info systemReq.GetOperationRecordList) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Current - 1)
+	db := global.DB.Model(&system.SysOperationRecord{})
+	var operationRecordList []system.SysOperationRecord
+
+	if info.Ip != "" {
+		db = db.Where("ip = ?", info.Method)
+	}
+	if info.Method != "" {
+		db = db.Where("method = ?", info.Method)
+	}
+	if info.Path != "" {
+		db = db.Where("path = ?", info.Path)
+	}
+	if info.UserId != "" {
+		db = db.Where("status = ?", info.UserId)
+	}
+	if info.Status != 0 {
+		db = db.Where("status = ?", info.Status)
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Find(&operationRecordList).Error
+	return operationRecordList, total, err
+}
+
+func (o *OperationRecordService) GetRecordById(id string) (record system.SysOperationRecord, err error) {
+	var r system.SysOperationRecord
+	err = global.DB.Where("id = ?", id).First(&r).Error
+	return r, err
+}
+
+func (o *OperationRecordService) DeleteRecordsByIds(ids common.IdsReq) (err error) {
+	// Unscoped()禁用软删除 --> 永久物理删除
+	err = global.DB.Where("id in ?", ids.Ids).Unscoped().Delete(&system.SysOperationRecord{}).Error
+	return err
+}

service/system/sys_role.go

@@ -0,0 +1,89 @@
+package system
+
+import (
+	"errors"
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/system"
+	systemReq "sundynix-go/model/system/request"
+
+	"gorm.io/gorm"
+)
+
+type RoleService struct {
+}
+
+var RoleServiceApp = new(RoleService)
+
+func (s *RoleService) SaveRole(role system.Role) error {
+	if !errors.Is(global.DB.Where("code = ?", role.Code).First(&system.Role{}).Error, gorm.ErrRecordNotFound) {
+		return errors.New("存在重复角色")
+	}
+	return global.DB.Create(&role).Error
+}
+
+func (s *RoleService) UpdateRole(role system.Role) error {
+	return global.DB.Model(&role).Where("id = ?", role.Id).Updates(&role).Error
+}
+
+func (s *RoleService) GetRoleList(info systemReq.GetRoleList) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Current - 1)
+	db := global.DB.Model(&system.Role{})
+	var roleList []system.Role
+	if info.Code != "" {
+		db = db.Where("code = ?", info.Code)
+	}
+	if info.Name != "" {
+		db = db.Where("name LIKE ?", "%"+info.Name+"%")
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Find(&roleList).Error
+	return roleList, total, err
+}
+
+func (s *RoleService) DeleteRoleByIds(ids common.IdsReq) error {
+	return global.DB.Where("id in ?", ids.Ids).Delete(&system.Role{}).Error
+}
+
+func (s *RoleService) GetRoleById(id string) (role system.Role, err error) {
+	var r system.Role
+	err = global.DB.Where("id = ?", id).First(&r).Error
+	return r, err
+}
+
+func (s *RoleService) GrantRole(userId string, roleIds []string) error {
+	//1. 检查是否存在userid的授权记录 存在就删除 不存在就插入
+	//2. 插入新的数据
+	return global.DB.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Where("user_id = ?", userId).Delete(&system.UserRole{}).Error; err != nil {
+			return err
+		}
+		for _, roleId := range roleIds {
+			if err := tx.Create(&system.UserRole{UserId: userId, RoleId: roleId}).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+
+}
+
+func (s *RoleService) GrantMenu(roleId string, menuIds []string) error {
+	//1. 检查是否存在userid的授权记录 存在就删除 不存在就插入
+	//2. 插入新的数据
+	return global.DB.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Where("role_id = ?", roleId).Delete(&system.RoleMenu{}).Error; err != nil {
+			return err
+		}
+		for _, menuId := range menuIds {
+			if err := tx.Create(&system.RoleMenu{RoleId: roleId, MenuId: menuId}).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}

service/system/sys_user.go

@@ -0,0 +1,269 @@
+package system
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	url2 "net/url"
+	"strconv"
+	"sundynix-go/global"
+	common "sundynix-go/model/commom/request"
+	"sundynix-go/model/system"
+	systemReq "sundynix-go/model/system/request"
+	systemResp "sundynix-go/model/system/response"
+	"sundynix-go/pkg/httpclient"
+	"sundynix-go/utils"
+	location "sundynix-go/utils/location"
+	"sundynix-go/utils/uniqueid"
+	"sundynix-go/utils/wechat"
+
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+)
+
+type UserService struct{}
+
+var UserServiceApp = new(UserService)
+
+func (userService *UserService) Login(u *system.User) (userInfo *system.User, err error) {
+	var user system.User
+	// 查询出用户信息的同时查询出角色信息
+	err = global.DB.Model(&system.User{}).Where("account = ?", u.Account).First(&user).Error
+	if err == nil {
+		if ok := utils.BcryptCheck(u.Password, user.Password); !ok {
+			return nil, errors.New("密码错误")
+		}
+	}
+	return &user, err
+}
+
+func (userService *UserService) SaveUser(user system.User) error {
+	if !errors.Is(global.DB.Where("account = ?", user.Account).First(&system.User{}).Error, gorm.ErrRecordNotFound) {
+		return errors.New("存在重复Account，请修改Account")
+	}
+	user.Password = utils.BcryptHash(user.Password)
+	return global.DB.Create(&user).Error
+}
+
+func (userService *UserService) UpdateUser(user *system.User) (err error) {
+	var sysUser system.User
+	userMap := map[string]interface{}{
+		"account":   user.Account,
+		"phone":     user.Phone,
+		"name":      user.Name,
+		"avatar_id": user.AvatarId,
+	}
+	err = global.DB.Where("id = ?", user.Id).First(&sysUser).Error
+	if err != nil {
+		global.Logger.Debug(err.Error())
+		return errors.New("查询用户失败")
+	}
+	err = global.DB.Model(&sysUser).Updates(userMap).Error
+	return err
+}
+
+func (userService *UserService) GetUserList(info systemReq.GetUserList) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Current - 1)
+	db := global.DB.Model(&system.User{})
+	var userList []system.User
+
+	if info.Account != "" {
+		db = db.Where("account LIKE ?", "%"+info.Account+"%")
+	}
+	if info.Phone != "" {
+		db = db.Where("phone LIKE ?", "%"+info.Phone+"%")
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Limit(limit).Offset(offset).Find(&userList).Error
+	return userList, total, err
+}
+
+func (userService *UserService) DeleteUserByIds(ids common.IdsReq) error {
+	return global.DB.Where("id IN (?)", ids.Ids).Delete(&system.User{}).Error
+}
+
+func (userService *UserService) GetUserById(id string) (user *system.User, err error) {
+	var u system.User
+	err = global.DB.Where("id = ?", id).Preload("Avatar").First(&u).Error
+	return &u, err
+}
+
+func (userService *UserService) ChangePassword(id string, pwd string) (err error) {
+	return global.DB.Model(&system.User{}).Where("id = ?", id).Update("password", utils.BcryptHash(pwd)).Error
+}
+
+func (userService *UserService) MiniLogin(code string) (result *system.User, err error) {
+	//构建参数
+	params := url2.Values{}
+	params.Set("appid", global.Config.MiniProgram.AppId)
+	params.Set("secret", global.Config.MiniProgram.AppSecret)
+	params.Set("js_code", code)
+	params.Set("grant_type", "authorization_code")
+	fullURL := "https://api.weixin.qq.com/sns/jscode2session?" + params.Encode()
+
+	//1. 获取全局 HTTP Client（复用连接池）
+	myHttpClient := httpclient.GetClient()
+	//2.发起请求
+	resp, err := myHttpClient.Get(fullURL)
+	if err != nil {
+		global.Logger.Error("微信登录接口请求失败", zap.Error(err))
+		return nil, fmt.Errorf("微信登录接口请求失败: %w", err)
+	}
+	defer resp.Body.Close()
+	//3.读取响应
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		global.Logger.Error("读取微信接口响应失败", zap.Error(err))
+		return nil, fmt.Errorf("读取微信登录接口响应失败: %w", err)
+	}
+	// 4. 解析JSON（用结构体替代map，提升效率+类型安全）
+	var wxResp systemResp.WxCode2SessionResp
+	if err = json.Unmarshal(body, &wxResp); err != nil {
+		global.Logger.Error("解析微信接口响应失败", zap.Error(err))
+		return nil, fmt.Errorf("解析微信登录接口响应失败: %w", err)
+	}
+	// 5. 检查微信接口错误码（关键：原代码未处理errcode，导致无法定位真实错误）
+	if wxResp.Errcode != 0 {
+		errMsg := fmt.Sprintf("微信接口返回错误: errcode=%d, errmsg=%s", wxResp.Errcode, wxResp.Errmsg)
+		global.Logger.Error(errMsg)
+		return nil, errors.New(errMsg)
+	}
+	// 6. 校验openid（空值直接返回）
+	if wxResp.Openid == "" {
+		global.Logger.Error("微信接口返回openid为空")
+		return nil, errors.New("openid为空")
+	}
+
+	// 7. 根据openid查询用户 存在--> 更新session_key 返回数据
+	var user system.User
+	err = global.DB.Where("mini_open_id = ?", wxResp.Openid).Preload("Avatar").First(&user).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		// 8. 使用 Transaction 闭包管理事务
+		err = global.DB.Transaction(func(tx *gorm.DB) error {
+			// 创建新用户
+			newUser := system.User{
+				Name:       uniqueid.GenerateName(),
+				MiniOpenId: wxResp.Openid,
+				SessionKey: wxResp.SessionKey,
+			}
+			if err := tx.Create(&newUser).Error; err != nil {
+				return err
+			}
+			//// 归一化到当天的0点（本地时区）
+			//now := time.Now()
+			//today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
+			//personal := plant.Personal{
+			//	UserId:     newUser.Id,
+			//	JoinDate:   today,
+			//	PlantCount: 0,
+			//	CareCount:  0,
+			//	BadgeCount: 0,
+			//}
+			//if err := tx.Create(&personal).Error; err != nil {
+			//	return err
+			//}
+			// 赋值给外部变量以便返回
+			user = newUser
+			return nil
+		})
+		if err != nil {
+			global.Logger.Error("创建用户失败", zap.Error(err))
+			return nil, fmt.Errorf("登录失败: %w", err)
+		}
+		return &user, nil
+	}
+	if err == nil && user.Id != "" {
+		// UpdateColumn：只更新字段，不触发模型钩子，比Update更高效
+		if err = global.DB.Model(&user).UpdateColumn("session_key", wxResp.SessionKey).Error; err != nil {
+			global.Logger.Error("更新session_key失败", zap.Error(err))
+			return nil, fmt.Errorf("更新session_key失败: %w", err)
+		}
+		return &user, nil
+	}
+	return nil, errors.New("登录失败")
+}
+
+func (userService *UserService) LoginByPhone(code string, openId string) (result *system.User, err error) {
+	token := wechat.GetMiniAccessToken()
+	url := "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=" + token
+	data := map[string]interface{}{
+		"code": code,
+	}
+	jsonData, _ := json.Marshal(data)
+	resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
+	if err != nil {
+		log.Fatalf("Error making POST request: %s", err)
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatalf("Error reading response body: %s", err)
+	}
+	var dataMap map[string]interface{}
+	err = json.Unmarshal([]byte(body), &dataMap)
+	if err != nil {
+		log.Fatalf("Error unmarshalling JSON: %s", err)
+	}
+	//用户已经存在 --> 如果有手机号直接返回user,没有则更新手机号并返回user
+	if openId != "" {
+		var user system.User
+		err = global.DB.Where("mini_open_id = ?", openId).First(&user).Error
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.New("用户不存在")
+		}
+		if err == nil && user.Id != "" {
+			if user.Phone != "" {
+				return &user, nil
+			} else {
+				user.Phone = dataMap["phone_info"].(map[string]interface{})["phoneNumber"].(string)
+				return &user, global.DB.Save(&user).Error
+			}
+		}
+	}
+	return nil, errors.New("登录失败")
+}
+
+// GetLocation 获取位置信息
+func (userService *UserService) GetLocation(longitude, latitude string) (res map[string]interface{}, err error) {
+	long, err := strconv.ParseFloat(longitude, 32)
+	if err != nil {
+		return res, err
+	}
+	lati, err := strconv.ParseFloat(latitude, 32)
+	if err != nil {
+		return res, err
+	}
+
+	entity, err := location.Point2code(float32(long), float32(lati))
+	result := map[string]interface{}{
+		"city":   entity.AddressComponent.City.String(),
+		"adcode": entity.AddressComponent.Adcode,
+	}
+	return result, err
+}
+
+// GetWeather 获取天气信息 adcode 行政区划代码
+func (userService *UserService) GetWeather(adcode string) (res map[string]interface{}, err error) {
+	weatherResp, err := location.GetWeather(adcode, "base")
+	live := weatherResp.Lives[0] // 实时天气数组仅1条数据
+	result := map[string]interface{}{
+		"province":      live.Province,
+		"city":          live.City,
+		"adcode":        live.Adcode,
+		"weather":       live.Weather,
+		"temperature":   live.Temperature,
+		"windPower":     live.WindPower,
+		"windDirection": live.WindDirection,
+		"humidity":      live.Humidity,
+		"reportTime":    live.ReportTime,
+	}
+	return result, err
+}