Files
yunzerwebsiteallinone/go/services/system_sitereminder.go
T
2026-11-16 17:22:50 +08:00

519 lines
14 KiB
Go

package services
import (
"context"
"encoding/json"
"fmt"
"strconv"
"time"
"server/models"
"server/services/wechatmini"
"github.com/beego/beego/v2/client/orm"
"github.com/beego/beego/v2/core/logs"
)
func GetSiteReminderConfig() (models.SystemSiteReminder, error) {
retentionDaysStr := models.GetPlatformSettingValue("sitemsg_retention_days", "30")
autoReadStr := models.GetPlatformSettingValue("sitemsg_auto_read", "0")
retentionDays, _ := strconv.Atoi(retentionDaysStr)
if retentionDays <= 0 {
retentionDays = 30
}
autoRead := int8(0)
if autoReadStr == "1" {
autoRead = 1
}
now := time.Now()
row := models.SystemSiteReminder{
ID: 1,
RetentionDays: retentionDays,
AutoRead: autoRead,
CreateTime: &now,
UpdateTime: &now,
}
return row, nil
}
func SaveSiteReminderConfig(retentionDays int, autoRead int8) error {
if retentionDays <= 0 {
retentionDays = 30
}
autoReadStr := "0"
if autoRead == 1 {
autoReadStr = "1"
}
settings := []struct {
code string
name string
value string
remark string
}{
{"sitemsg_retention_days", "站内信消息保留天数", strconv.Itoa(retentionDays), ""},
{"sitemsg_auto_read", "自动标记已读状态", autoReadStr, "0为关闭,1为开启"},
}
for _, item := range settings {
var setting models.PlatformNormalSetting
err := models.Orm.QueryTable(new(models.PlatformNormalSetting)).
Filter("code", item.code).
Filter("delete_time__isnull", true).
One(&setting)
if err == nil {
setting.Value = item.value
setting.Name = item.name
setting.Remark = item.remark
now := time.Now()
setting.UpdateTime = &now
_, err = models.Orm.Update(&setting, "Value", "Name", "Remark", "UpdateTime")
if err != nil {
return err
}
} else {
newSetting := models.PlatformNormalSetting{
Name: item.name,
Code: item.code,
Value: item.value,
Remark: item.remark,
CreateTime: time.Now(),
}
_, err = models.Orm.Insert(&newSetting)
if err != nil {
return err
}
}
}
return nil
}
type reminderReceiver struct {
ID uint64
Type string
}
func queryEnabledAdminUserIDs(cond *orm.Condition) ([]uint64, error) {
qs := models.Orm.QueryTable(new(models.AdminUser)).
Filter("status", 1).
Filter("delete_time__isnull", true)
if cond != nil {
qs = qs.SetCond(orm.NewCondition().
And("status", 1).
And("delete_time__isnull", true).
AndCond(cond))
}
var list []models.AdminUser
if _, err := qs.All(&list, "id"); err != nil {
return nil, err
}
ids := make([]uint64, 0, len(list))
for _, u := range list {
ids = append(ids, u.ID)
}
return ids, nil
}
func queryEnabledTenantUserIDs(cond *orm.Condition) ([]uint64, error) {
qs := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("status", 1).
Filter("delete_time__isnull", true)
if cond != nil {
qs = qs.SetCond(orm.NewCondition().
And("status", 1).
And("delete_time__isnull", true).
AndCond(cond))
}
var list []models.SystemTenantUser
if _, err := qs.All(&list, "id"); err != nil {
return nil, err
}
ids := make([]uint64, 0, len(list))
for _, u := range list {
ids = append(ids, u.ID)
}
return ids, nil
}
func marshalTargetIDs(targetIDs []uint64) *string {
if len(targetIDs) == 0 {
return nil
}
b, err := json.Marshal(targetIDs)
if err != nil {
return nil
}
s := string(b)
return &s
}
func legacyTargetColumns(targetType string, targetIDs []uint64) (roleID, tenantID uint64) {
if len(targetIDs) == 0 {
return 0, 0
}
switch targetType {
case "role":
return targetIDs[0], 0
case "tenant":
return 0, targetIDs[0]
}
return 0, 0
}
func resolveReminderReceivers(targetType string, targetIDs []uint64) ([]reminderReceiver, error) {
receivers := make([]reminderReceiver, 0)
seen := map[string]bool{}
appendIDs := func(ids []uint64, rtype string) {
for _, id := range ids {
if id == 0 {
continue
}
key := fmt.Sprintf("%s_%d", rtype, id)
if seen[key] {
continue
}
seen[key] = true
receivers = append(receivers, reminderReceiver{ID: id, Type: rtype})
}
}
switch targetType {
case "all":
adminIDs, err := queryEnabledAdminUserIDs(nil)
if err != nil {
return nil, fmt.Errorf("查询平台用户失败: %w", err)
}
tenantIDs, err := queryEnabledTenantUserIDs(nil)
if err != nil {
return nil, fmt.Errorf("查询租户用户失败: %w", err)
}
appendIDs(adminIDs, "platform")
appendIDs(tenantIDs, "tenant")
case "platform":
adminIDs, err := queryEnabledAdminUserIDs(nil)
if err != nil {
return nil, fmt.Errorf("查询平台用户失败: %w", err)
}
appendIDs(adminIDs, "platform")
case "tenant_all":
tenantIDs, err := queryEnabledTenantUserIDs(nil)
if err != nil {
return nil, fmt.Errorf("查询租户用户失败: %w", err)
}
appendIDs(tenantIDs, "tenant")
case "tenant_role":
if len(targetIDs) == 0 {
return nil, fmt.Errorf("请选择接收的租户角色")
}
tenantIDs, err := queryEnabledTenantUserIDs(orm.NewCondition().And("group_id__in", targetIDs))
if err != nil {
return nil, fmt.Errorf("根据租户角色查询用户失败: %w", err)
}
appendIDs(tenantIDs, "tenant")
case "tenant":
if len(targetIDs) == 0 {
return nil, fmt.Errorf("请选择接收的租户")
}
tenantIDs, err := queryEnabledTenantUserIDs(orm.NewCondition().And("tid__in", targetIDs))
if err != nil {
return nil, fmt.Errorf("根据租户查询用户失败: %w", err)
}
appendIDs(tenantIDs, "tenant")
case "tenant_user":
if len(targetIDs) == 0 {
return nil, fmt.Errorf("请选择接收的租户用户")
}
tenantIDs, err := queryEnabledTenantUserIDs(orm.NewCondition().And("id__in", targetIDs))
if err != nil {
return nil, fmt.Errorf("查询租户用户失败: %w", err)
}
appendIDs(tenantIDs, "tenant")
case "role":
if len(targetIDs) == 0 {
return nil, fmt.Errorf("请选择接收的角色")
}
adminIDs, err := queryEnabledAdminUserIDs(orm.NewCondition().And("role_id__in", targetIDs))
if err != nil {
return nil, fmt.Errorf("根据角色查询用户失败: %w", err)
}
appendIDs(adminIDs, "platform")
default:
return nil, fmt.Errorf("未知的发送目标类型: %s", targetType)
}
return receivers, nil
}
func SendSiteReminder(title, content string, senderID uint64, senderType string, targetType string, targetIDs []uint64) error {
receivers, err := resolveReminderReceivers(targetType, targetIDs)
if err != nil {
return err
}
if len(receivers) == 0 {
return nil
}
targetIDsJSON := marshalTargetIDs(targetIDs)
legacyRoleID, legacyTenantID := legacyTargetColumns(targetType, targetIDs)
now := time.Now()
batchID := fmt.Sprintf("%d_%d", now.UnixNano(), senderID)
reminders := make([]models.SystemReminderList, 0, len(receivers))
for _, r := range receivers {
reminders = append(reminders, models.SystemReminderList{
Title: title,
Content: content,
SenderID: senderID,
SenderType: senderType,
ReceiverID: r.ID,
ReceiverType: r.Type,
IsRead: 0,
CreateTime: &now,
BatchID: batchID,
TargetType: targetType,
TargetIDs: targetIDsJSON,
TargetRoleID: legacyRoleID,
TargetTenantID: legacyTenantID,
})
}
if _, err = models.Orm.InsertMulti(100, reminders); err != nil {
return err
}
for _, r := range receivers {
if r.Type != "tenant" {
continue
}
tenantUserID := r.ID
titleCopy, contentCopy := title, content
go func(uid uint64, t, c string) {
res := wechatmini.PushTenantNotice(uid, t, c)
if res.Sent > 0 {
logs.Info("[wechat-mini] 站内信已推送订阅消息: user=%d sent=%d", uid, res.Sent)
}
for _, e := range res.Errors {
logs.Info("[wechat-mini] 订阅消息推送失败: user=%d err=%v", uid, e)
}
}(tenantUserID, titleCopy, contentCopy)
}
return nil
}
func ListReminders(receiverID uint64, receiverType string, page, pageSize int, isRead *int8) ([]models.SystemReminderList, int64, error) {
if page <= 0 {
page = 1
}
if pageSize <= 0 {
pageSize = 10
}
var list []models.SystemReminderList
qs := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("receiver_id", receiverID).
Filter("receiver_type", receiverType).
Filter("delete_time__isnull", true)
if isRead != nil {
qs = qs.Filter("is_read", *isRead)
}
total, err := qs.Count()
if err != nil {
return nil, 0, err
}
offset := (page - 1) * pageSize
_, err = qs.OrderBy("-create_time", "-id").Limit(pageSize, offset).All(&list)
return list, total, err
}
func MarkReminderRead(id uint64, receiverID uint64, receiverType string) error {
now := time.Now()
_, err := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("id", id).
Filter("receiver_id", receiverID).
Filter("receiver_type", receiverType).
Update(map[string]interface{}{
"is_read": 1,
"read_time": &now,
})
return err
}
func MarkAllRemindersRead(receiverID uint64, receiverType string) error {
now := time.Now()
_, err := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("receiver_id", receiverID).
Filter("receiver_type", receiverType).
Filter("is_read", 0).
Update(map[string]interface{}{
"is_read": 1,
"read_time": &now,
})
return err
}
func DeleteReminder(id uint64, receiverID uint64, receiverType string) error {
now := time.Now()
_, err := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("id", id).
Filter("receiver_id", receiverID).
Filter("receiver_type", receiverType).
Update(map[string]interface{}{
"delete_time": &now,
})
return err
}
func AutoCleanExpiredReminders() error {
cfg, err := GetSiteReminderConfig()
if err != nil {
return err
}
if cfg.RetentionDays <= 0 {
return nil
}
expireTime := time.Now().AddDate(0, 0, -cfg.RetentionDays)
_, err = models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("create_time__lt", expireTime).
Delete()
return err
}
func ListSentReminders(senderID uint64, page, pageSize int) ([]models.SystemReminderList, int64, error) {
if page <= 0 {
page = 1
}
if pageSize <= 0 {
pageSize = 10
}
offset := (page - 1) * pageSize
var total int64
err := models.Orm.Raw("SELECT COUNT(DISTINCT batch_id) FROM yz_system_reminderlist WHERE sender_id = ? AND delete_time IS NULL", senderID).QueryRow(&total)
if err != nil {
return nil, 0, err
}
var list []models.SystemReminderList
_, err = models.Orm.Raw("SELECT * FROM yz_system_reminderlist WHERE id IN (SELECT MIN(id) FROM yz_system_reminderlist WHERE sender_id = ? AND delete_time IS NULL GROUP BY batch_id) ORDER BY id DESC LIMIT ? OFFSET ?", senderID, pageSize, offset).QueryRows(&list)
if err != nil {
return nil, 0, err
}
return list, total, nil
}
func UpdateSentReminder(batchID string, title, content, targetType string, targetIDs []uint64) error {
var firstRecord models.SystemReminderList
err := models.Orm.QueryTable(new(models.SystemReminderList)).Filter("batch_id", batchID).Limit(1).One(&firstRecord)
if err != nil {
return fmt.Errorf("找不到该批次的站内信记录: %w", err)
}
senderID := firstRecord.SenderID
senderType := firstRecord.SenderType
receivers, err := resolveReminderReceivers(targetType, targetIDs)
if err != nil {
return err
}
targetIDsJSON := marshalTargetIDs(targetIDs)
legacyRoleID, legacyTenantID := legacyTargetColumns(targetType, targetIDs)
var existingRecords []models.SystemReminderList
_, err = models.Orm.QueryTable(new(models.SystemReminderList)).Filter("batch_id", batchID).All(&existingRecords)
if err != nil {
return fmt.Errorf("获取现有记录失败: %w", err)
}
existingMap := make(map[string]*models.SystemReminderList)
for i := range existingRecords {
key := fmt.Sprintf("%s_%d", existingRecords[i].ReceiverType, existingRecords[i].ReceiverID)
existingMap[key] = &existingRecords[i]
}
newReceiverMap := make(map[string]bool)
for _, r := range receivers {
key := fmt.Sprintf("%s_%d", r.Type, r.ID)
newReceiverMap[key] = true
}
now := time.Now()
err = models.Orm.DoTx(func(c context.Context, txOrm orm.TxOrmer) error {
for key, rec := range existingMap {
if !newReceiverMap[key] {
if rec.DeleteTime == nil {
rec.DeleteTime = &now
if _, e := txOrm.Update(rec, "DeleteTime"); e != nil {
return e
}
}
}
}
var newInserts []models.SystemReminderList
for _, r := range receivers {
key := fmt.Sprintf("%s_%d", r.Type, r.ID)
if rec, exists := existingMap[key]; exists {
rec.Title = title
rec.Content = content
rec.TargetType = targetType
rec.TargetIDs = targetIDsJSON
rec.TargetRoleID = legacyRoleID
rec.TargetTenantID = legacyTenantID
cols := []string{"Title", "Content", "TargetType", "TargetIDs", "TargetRoleID", "TargetTenantID"}
if rec.DeleteTime != nil {
rec.DeleteTime = nil
rec.IsRead = 0
rec.ReadTime = nil
cols = append(cols, "DeleteTime", "IsRead", "ReadTime")
}
if _, e := txOrm.Update(rec, cols...); e != nil {
return e
}
} else {
newInserts = append(newInserts, models.SystemReminderList{
Title: title,
Content: content,
SenderID: senderID,
SenderType: senderType,
ReceiverID: r.ID,
ReceiverType: r.Type,
IsRead: 0,
CreateTime: &now,
BatchID: batchID,
TargetType: targetType,
TargetIDs: targetIDsJSON,
TargetRoleID: legacyRoleID,
TargetTenantID: legacyTenantID,
})
}
}
if len(newInserts) > 0 {
if _, e := txOrm.InsertMulti(100, newInserts); e != nil {
return e
}
}
return nil
})
return err
}
func DeleteSentReminderBatch(batchID string) error {
now := time.Now()
_, err := models.Orm.QueryTable(new(models.SystemReminderList)).
Filter("batch_id", batchID).
Update(map[string]interface{}{
"delete_time": &now,
})
return err
}