统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
1 parent
28cd9d3406
commit
f60d3b0880
603 files changed
+2351
-660
No files matched your search
@@ -0,0 +1,781 @@
|
||||
package group
|
||||
|
||||
import (
|
||||
errors2 "errors"
|
||||
"fmt"
|
||||
"git.pcux.cn/xuans/Smail/consts"
|
||||
"git.pcux.cn/xuans/Smail/db"
|
||||
"git.pcux.cn/xuans/Smail/dto"
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/utils/array"
|
||||
"git.pcux.cn/xuans/Smail/utils/context"
|
||||
"git.pcux.cn/xuans/Smail/utils/errors"
|
||||
"git.pcux.cn/xuans/Smail/utils/query"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"strings"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
"xorm.io/builder"
|
||||
"xorm.io/xorm"
|
||||
)
|
||||
|
||||
type GroupItem struct {
|
||||
Id int `json:"id"`
|
||||
Label string `json:"label"`
|
||||
Tag string `json:"tag"`
|
||||
Children []*GroupItem `json:"children"`
|
||||
}
|
||||
|
||||
const (
|
||||
maxGroupDepth = 100
|
||||
maxGroupPathLength = 600
|
||||
)
|
||||
|
||||
func CreateGroup(ctx *context.Context, name string, parentId int) (*models.Group, error) {
|
||||
name, err := normalizeGroupName(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 先查询是否存在
|
||||
if parentId < 0 {
|
||||
return nil, errors2.New("invalid parent group")
|
||||
}
|
||||
if parentId == 0 && isReservedGroupName(name) {
|
||||
return nil, errors2.New("reserved group name")
|
||||
}
|
||||
|
||||
group := models.Group{
|
||||
Name: name,
|
||||
ParentId: parentId,
|
||||
UserId: ctx.UserID,
|
||||
}
|
||||
group.FullPath, err = getLayerName(ctx, &group, true)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := validateGroupPath(group.FullPath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var existing models.Group
|
||||
found, err := db.Instance.Table("group").Where("full_path = ? and user_id = ?", group.FullPath, ctx.UserID).Get(&existing)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if found && existing.ID > 0 {
|
||||
return &existing, nil
|
||||
}
|
||||
|
||||
_, err = db.Instance.Insert(&group)
|
||||
return &group, err
|
||||
}
|
||||
|
||||
func Rename(ctx *context.Context, oldPath, newName string) error {
|
||||
newName, err := normalizeGroupName(newName)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
oldGroupInfo, err := GetGroupByPath(ctx, oldPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if oldGroupInfo == nil || oldGroupInfo.ID == 0 {
|
||||
return errors2.New("group not found")
|
||||
}
|
||||
if oldGroupInfo.ParentId == 0 && isReservedGroupName(newName) {
|
||||
return errors2.New("reserved group name")
|
||||
}
|
||||
if oldGroupInfo.Name == newName {
|
||||
return nil
|
||||
}
|
||||
oldGroupInfo.Name = newName
|
||||
oldGroupInfo.FullPath, err = getLayerName(ctx, oldGroupInfo, true)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateGroupPath(oldGroupInfo.FullPath); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
session := db.Instance.NewSession()
|
||||
defer session.Close()
|
||||
if err := session.Begin(); err != nil {
|
||||
return errors.Wrap(err)
|
||||
}
|
||||
|
||||
var groups []models.Group
|
||||
if err := session.Table("group").Where("user_id = ?", ctx.UserID).Find(&groups); err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors.Wrap(err)
|
||||
}
|
||||
updates, err := buildRenameUpdates(oldGroupInfo.ID, newName, oldGroupInfo.FullPath, groups)
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return err
|
||||
}
|
||||
|
||||
updatedIDs := make(map[int]struct{}, len(updates))
|
||||
updatedPaths := make(map[string]int, len(updates))
|
||||
for _, update := range updates {
|
||||
if ownerID, exists := updatedPaths[update.FullPath]; exists && ownerID != update.ID {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("group path conflict")
|
||||
}
|
||||
updatedIDs[update.ID] = struct{}{}
|
||||
updatedPaths[update.FullPath] = update.ID
|
||||
}
|
||||
for _, group := range groups {
|
||||
if _, updated := updatedIDs[group.ID]; updated {
|
||||
continue
|
||||
}
|
||||
if _, conflict := updatedPaths[group.FullPath]; conflict {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("group already exists")
|
||||
}
|
||||
}
|
||||
|
||||
for _, update := range updates {
|
||||
values := map[string]any{"full_path": update.FullPath}
|
||||
if update.ID == oldGroupInfo.ID {
|
||||
values["name"] = newName
|
||||
}
|
||||
rows, err := session.Table("group").Where("id = ? and user_id = ?", update.ID, ctx.UserID).Update(values)
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors.Wrap(err)
|
||||
}
|
||||
if rows != 1 {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("group update failed")
|
||||
}
|
||||
}
|
||||
|
||||
if err := session.Commit(); err != nil {
|
||||
return errors.Wrap(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type groupPathUpdate struct {
|
||||
ID int
|
||||
FullPath string
|
||||
}
|
||||
|
||||
type groupPathQueueItem struct {
|
||||
ID int
|
||||
Depth int
|
||||
}
|
||||
|
||||
func buildRenameUpdates(rootID int, newName, rootPath string, groups []models.Group) ([]groupPathUpdate, error) {
|
||||
if rootID <= 0 {
|
||||
return nil, errors2.New("invalid group")
|
||||
}
|
||||
if err := validateGroupPath(rootPath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
byID := make(map[int]models.Group, len(groups))
|
||||
children := make(map[int][]models.Group)
|
||||
for _, group := range groups {
|
||||
if group.ID <= 0 {
|
||||
return nil, errors2.New("invalid group hierarchy")
|
||||
}
|
||||
if _, exists := byID[group.ID]; exists {
|
||||
return nil, errors2.New("duplicate group id")
|
||||
}
|
||||
byID[group.ID] = group
|
||||
children[group.ParentId] = append(children[group.ParentId], group)
|
||||
}
|
||||
root, exists := byID[rootID]
|
||||
if !exists {
|
||||
return nil, errors2.New("group not found")
|
||||
}
|
||||
if root.ParentId != 0 {
|
||||
if _, exists := byID[root.ParentId]; !exists {
|
||||
return nil, errors2.New("group parent not found")
|
||||
}
|
||||
}
|
||||
|
||||
paths := map[int]string{rootID: rootPath}
|
||||
visited := make(map[int]struct{}, len(groups))
|
||||
queue := []groupPathQueueItem{{ID: rootID, Depth: 1}}
|
||||
updates := make([]groupPathUpdate, 0)
|
||||
for len(queue) > 0 {
|
||||
current := queue[0]
|
||||
queue = queue[1:]
|
||||
if current.Depth > maxGroupDepth {
|
||||
return nil, errors2.New("group hierarchy is too deep")
|
||||
}
|
||||
if _, exists := visited[current.ID]; exists {
|
||||
return nil, errors2.New("group hierarchy cycle detected")
|
||||
}
|
||||
visited[current.ID] = struct{}{}
|
||||
updates = append(updates, groupPathUpdate{ID: current.ID, FullPath: paths[current.ID]})
|
||||
|
||||
for _, child := range children[current.ID] {
|
||||
childName, err := normalizeGroupName(child.Name)
|
||||
if err != nil || childName != child.Name {
|
||||
return nil, errors2.New("invalid group hierarchy")
|
||||
}
|
||||
childPath := paths[current.ID] + "/" + childName
|
||||
if err := validateGroupPath(childPath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
paths[child.ID] = childPath
|
||||
queue = append(queue, groupPathQueueItem{ID: child.ID, Depth: current.Depth + 1})
|
||||
}
|
||||
}
|
||||
|
||||
if len(updates) == 0 || updates[0].ID != rootID || newName == "" {
|
||||
return nil, errors2.New("invalid group rename")
|
||||
}
|
||||
return updates, nil
|
||||
}
|
||||
|
||||
func GetGroupByName(ctx *context.Context, name string) (*models.Group, error) {
|
||||
var groups []models.Group
|
||||
if err := db.Instance.Table("group").Where("name = ? and user_id = ?", name, ctx.UserID).Limit(2).Find(&groups); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(groups) == 0 {
|
||||
return &models.Group{}, nil
|
||||
}
|
||||
if len(groups) > 1 {
|
||||
return nil, errors2.New("group name is ambiguous")
|
||||
}
|
||||
return &groups[0], nil
|
||||
}
|
||||
|
||||
func GetGroupByPath(ctx *context.Context, path string) (*models.Group, error) {
|
||||
group, err := GetGroupByFullPath(ctx, path)
|
||||
if err != nil || group.ID > 0 || strings.Contains(path, "/") {
|
||||
return group, err
|
||||
}
|
||||
return GetGroupByName(ctx, path)
|
||||
}
|
||||
|
||||
func GetGroupByFullPath(ctx *context.Context, fullPath string) (*models.Group, error) {
|
||||
var group models.Group
|
||||
_, err := db.Instance.Table("group").Where("full_path = ? and user_id = ?", fullPath, ctx.UserID).Get(&group)
|
||||
|
||||
return &group, err
|
||||
}
|
||||
|
||||
func DelGroup(ctx *context.Context, groupId int) (bool, error) {
|
||||
if groupId <= 0 {
|
||||
return false, errors2.New("invalid group")
|
||||
}
|
||||
var root models.Group
|
||||
found, err := db.Instance.Table("group").Where("id = ? and user_id = ?", groupId, ctx.UserID).Get(&root)
|
||||
if err != nil {
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
if !found {
|
||||
return false, nil
|
||||
}
|
||||
|
||||
allGroupIds, err := getAllChildIDs(ctx, groupId)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
allGroupIds = append(allGroupIds, groupId)
|
||||
placeholders, groupArgs, ok := query.IntList(allGroupIds, 10000)
|
||||
if !ok {
|
||||
return false, errors2.New("invalid group list")
|
||||
}
|
||||
|
||||
// 开启一个事务
|
||||
trans := db.Instance.NewSession()
|
||||
defer trans.Close()
|
||||
if err := trans.Begin(); err != nil {
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
|
||||
deleteArgs := append(append([]any{}, groupArgs...), ctx.UserID)
|
||||
deleteExecArgs := append([]any{db.WithContext(ctx, fmt.Sprintf("delete from `group` where id in (%s) and user_id =?", placeholders))}, deleteArgs...)
|
||||
res, err := trans.Exec(deleteExecArgs...)
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(trans)
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
num, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(trans)
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
|
||||
updateArgs := append(append([]any{}, groupArgs...), ctx.UserID)
|
||||
updateExecArgs := append([]any{db.WithContext(ctx, fmt.Sprintf("update user_email set group_id=0 where group_id in (%s) and user_id=?", placeholders))}, updateArgs...)
|
||||
_, err = trans.Exec(updateExecArgs...)
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(trans)
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
|
||||
if err := trans.Commit(); err != nil {
|
||||
return false, errors.Wrap(err)
|
||||
}
|
||||
|
||||
return num > 0, nil
|
||||
}
|
||||
|
||||
func rollbackGroupTransaction(session *xorm.Session) {
|
||||
if err := session.Rollback(); err != nil {
|
||||
log.WithError(err).Error("rollback group transaction failed")
|
||||
}
|
||||
}
|
||||
|
||||
type id struct {
|
||||
Id int `db:"id"`
|
||||
}
|
||||
|
||||
func getAllChildIDs(ctx *context.Context, rootID int) ([]int, error) {
|
||||
visited := map[int]struct{}{rootID: {}}
|
||||
queue := []int{rootID}
|
||||
ret := make([]int, 0)
|
||||
|
||||
for len(queue) > 0 {
|
||||
currentID := queue[0]
|
||||
queue = queue[1:]
|
||||
|
||||
var ids []id
|
||||
if err := db.Instance.Table("group").Where("parent_id=? and user_id=?", currentID, ctx.UserID).Find(&ids); err != nil {
|
||||
return nil, errors.Wrap(err)
|
||||
}
|
||||
for _, item := range ids {
|
||||
if item.Id <= 0 {
|
||||
return nil, errors2.New("invalid group hierarchy")
|
||||
}
|
||||
if _, exists := visited[item.Id]; exists {
|
||||
return nil, errors2.New("group hierarchy cycle detected")
|
||||
}
|
||||
visited[item.Id] = struct{}{}
|
||||
ret = append(ret, item.Id)
|
||||
queue = append(queue, item.Id)
|
||||
}
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
// GetGroupInfoList 获取全部的分组
|
||||
func GetGroupInfoList(ctx *context.Context) ([]*GroupItem, error) {
|
||||
return buildChildren(ctx, 0, make(map[int]struct{}), 0)
|
||||
}
|
||||
|
||||
// MoveMailToGroup 将某封邮件移动到某个分组中
|
||||
func MoveMailToGroup(ctx *context.Context, mailIDs []int, groupID int) error {
|
||||
if groupID <= 0 {
|
||||
return errors2.New("invalid message move request")
|
||||
}
|
||||
uniqueIDs, err := normalizeMoveMessageIDs(mailIDs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
session := db.Instance.NewSession()
|
||||
defer session.Close()
|
||||
if err := session.Begin(); err != nil {
|
||||
return fmt.Errorf("begin message move transaction: %w", err)
|
||||
}
|
||||
|
||||
var target models.Group
|
||||
found, err := session.Table("group").Where("id = ? and user_id = ?", groupID, ctx.UserID).Get(&target)
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("load move destination: %w", err)
|
||||
}
|
||||
if !found || target.ID == 0 {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("move destination not found")
|
||||
}
|
||||
|
||||
var relations []models.UserEmail
|
||||
if err := session.Table(&models.UserEmail{}).Where(builder.Eq{
|
||||
"email_id": uniqueIDs,
|
||||
"user_id": ctx.UserID,
|
||||
}).Find(&relations); err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("load message ownership: %w", err)
|
||||
}
|
||||
if len(relations) != len(uniqueIDs) {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("one or more messages are not owned by the user")
|
||||
}
|
||||
|
||||
expectedChanges := 0
|
||||
for _, relation := range relations {
|
||||
if relation.GroupId != groupID {
|
||||
expectedChanges++
|
||||
}
|
||||
}
|
||||
if expectedChanges > 0 {
|
||||
affected, err := session.Table(&models.UserEmail{}).Where(builder.Eq{
|
||||
"email_id": uniqueIDs,
|
||||
"user_id": ctx.UserID,
|
||||
}).Cols("group_id").Update(map[string]interface{}{"group_id": groupID})
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("move messages: %w", err)
|
||||
}
|
||||
if affected != int64(expectedChanges) {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("move messages affected %d rows, expected %d", affected, expectedChanges)
|
||||
}
|
||||
}
|
||||
|
||||
if err := session.Commit(); err != nil {
|
||||
return fmt.Errorf("commit message move transaction: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func buildChildren(ctx *context.Context, parentId int, visited map[int]struct{}, depth int) ([]*GroupItem, error) {
|
||||
if depth >= maxGroupDepth {
|
||||
return nil, errors2.New("group hierarchy is too deep")
|
||||
}
|
||||
var ret []*GroupItem
|
||||
var rootGroup []*models.Group
|
||||
if err := db.Instance.Table("group").Where("parent_id=? and user_id=?", parentId, ctx.UserID).Find(&rootGroup); err != nil {
|
||||
return nil, errors.Wrap(err)
|
||||
}
|
||||
|
||||
for _, group := range rootGroup {
|
||||
if group == nil || group.ID <= 0 {
|
||||
return nil, errors2.New("invalid group hierarchy")
|
||||
}
|
||||
if _, exists := visited[group.ID]; exists {
|
||||
return nil, errors2.New("group hierarchy cycle detected")
|
||||
}
|
||||
visited[group.ID] = struct{}{}
|
||||
children, err := buildChildren(ctx, group.ID, visited, depth+1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ret = append(ret, &GroupItem{
|
||||
Id: group.ID,
|
||||
Label: group.Name,
|
||||
Tag: dto.SearchTag{GroupId: group.ID, Status: -1, Type: -1}.ToString(),
|
||||
Children: children,
|
||||
})
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func GetGroupList(ctx *context.Context) ([]*models.Group, error) {
|
||||
var ret []*models.Group
|
||||
if err := db.Instance.Table("group").Where("user_id=?", ctx.UserID).Find(&ret); err != nil {
|
||||
return nil, errors.Wrap(err)
|
||||
}
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func hasChildren(ctx *context.Context, id int) bool {
|
||||
var parent []*models.Group
|
||||
if err := db.Instance.Table("group").Where("parent_id=? and user_id=?", id, ctx.UserID).Find(&parent); err != nil {
|
||||
log.WithContext(ctx).WithError(err).Error("query child groups failed")
|
||||
return false
|
||||
}
|
||||
return len(parent) > 0
|
||||
}
|
||||
|
||||
func getLayerName(ctx *context.Context, item *models.Group, allPath bool) (string, error) {
|
||||
return getLayerNameWithVisited(ctx, item, allPath, make(map[int]struct{}), 0)
|
||||
}
|
||||
|
||||
func getLayerNameWithVisited(ctx *context.Context, item *models.Group, allPath bool, visited map[int]struct{}, depth int) (string, error) {
|
||||
if depth >= maxGroupDepth {
|
||||
return "", errors2.New("group hierarchy is too deep")
|
||||
}
|
||||
if item == nil || item.UserId != ctx.UserID {
|
||||
return "", errors2.New("invalid group")
|
||||
}
|
||||
if item.ID > 0 {
|
||||
if _, exists := visited[item.ID]; exists {
|
||||
return "", errors2.New("group hierarchy cycle detected")
|
||||
}
|
||||
visited[item.ID] = struct{}{}
|
||||
}
|
||||
if item.ParentId == 0 {
|
||||
return item.Name, nil
|
||||
}
|
||||
var parent models.Group
|
||||
found, err := db.Instance.Table("group").Where("id=? and user_id=?", item.ParentId, ctx.UserID).Get(&parent)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !found || parent.ID == 0 {
|
||||
return "", errors2.New("group parent not found")
|
||||
}
|
||||
parentName, err := getLayerNameWithVisited(ctx, &parent, allPath, visited, depth+1)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if allPath {
|
||||
return parentName + "/" + item.Name, nil
|
||||
}
|
||||
return parentName, nil
|
||||
}
|
||||
|
||||
func normalizeGroupName(name string) (string, error) {
|
||||
name = strings.TrimSpace(name)
|
||||
if name == "" || strings.Contains(name, "/") || strings.IndexFunc(name, unicode.IsControl) >= 0 {
|
||||
return "", errors2.New("invalid group name")
|
||||
}
|
||||
if utf8.RuneCountInString(name) > 10 {
|
||||
return "", errors2.New("group name is too long")
|
||||
}
|
||||
return name, nil
|
||||
}
|
||||
|
||||
func validateGroupPath(path string) error {
|
||||
if path == "" || strings.HasPrefix(path, "/") || strings.HasSuffix(path, "/") || strings.Contains(path, "//") {
|
||||
return errors2.New("invalid group path")
|
||||
}
|
||||
if utf8.RuneCountInString(path) > maxGroupPathLength {
|
||||
return errors2.New("group path is too long")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func IsDefaultBox(box string) bool {
|
||||
return array.InArray(box, []string{"INBOX", "Sent Messages", "Drafts", "Deleted Messages", "Junk"})
|
||||
}
|
||||
|
||||
func isReservedGroupName(name string) bool {
|
||||
for _, reserved := range []string{"INBOX", "Sent Messages", "Drafts", "Deleted Messages", "Junk"} {
|
||||
if strings.EqualFold(name, reserved) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func GetGroupStatus(ctx *context.Context, groupName string, params []string) (string, map[string]int, error) {
|
||||
retMap := make(map[string]int, len(params))
|
||||
parts := make([]string, 0, len(params))
|
||||
|
||||
if !IsDefaultBox(groupName) {
|
||||
var group models.Group
|
||||
found, err := db.Instance.Table("group").Where("user_id=? and full_path=?", ctx.UserID, groupName).Get(&group)
|
||||
if err != nil {
|
||||
return "", nil, errors.Wrap(err)
|
||||
}
|
||||
if !found || group.ID == 0 {
|
||||
return "", nil, errors2.New("group not found")
|
||||
}
|
||||
for _, param := range params {
|
||||
var value int
|
||||
var err error
|
||||
switch param {
|
||||
case "MESSAGES":
|
||||
value, err = readGroupValue(db.Instance.Table("user_email").Select("count(1)").Where("group_id=? and user_id=?", group.ID, ctx.UserID), "query mailbox message count failed")
|
||||
case "UIDNEXT":
|
||||
value, err = readGroupValue(db.Instance.Table("user_email").Select("id").Where("group_id=? and user_id=?", group.ID, ctx.UserID).OrderBy("id desc"), "query mailbox next UID failed")
|
||||
value++
|
||||
case "UIDVALIDITY":
|
||||
value = group.ID
|
||||
case "UNSEEN":
|
||||
value, err = readGroupValue(db.Instance.Table("user_email").Select("count(1)").Where("group_id=? and user_id=? and is_read=0", group.ID, ctx.UserID), "query mailbox unseen count failed")
|
||||
default:
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
retMap[param] = value
|
||||
parts = append(parts, fmt.Sprintf("%s %d", param, value))
|
||||
}
|
||||
return formatGroupStatus(parts), retMap, nil
|
||||
}
|
||||
|
||||
for _, param := range params {
|
||||
var value int
|
||||
var err error
|
||||
switch param {
|
||||
case "MESSAGES":
|
||||
value, err = getGroupNum(ctx, groupName, false)
|
||||
case "UIDNEXT":
|
||||
value, err = getNextUID(ctx, groupName)
|
||||
case "UIDVALIDITY":
|
||||
value = models.GroupNameToCode[groupName]
|
||||
case "UNSEEN":
|
||||
value, err = getGroupNum(ctx, groupName, true)
|
||||
default:
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
retMap[param] = value
|
||||
parts = append(parts, fmt.Sprintf("%s %d", param, value))
|
||||
}
|
||||
return formatGroupStatus(parts), retMap, nil
|
||||
}
|
||||
|
||||
func formatGroupStatus(parts []string) string {
|
||||
if len(parts) == 0 {
|
||||
return ""
|
||||
}
|
||||
return "(" + strings.Join(parts, " ") + ")"
|
||||
}
|
||||
|
||||
func readGroupValue(querySession *xorm.Session, operation string) (int, error) {
|
||||
var value int
|
||||
if _, err := querySession.Get(&value); err != nil {
|
||||
return 0, fmt.Errorf("%s: %w", operation, err)
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
|
||||
func getNextUID(ctx *context.Context, groupName string) (int, error) {
|
||||
var querySession *xorm.Session
|
||||
switch groupName {
|
||||
case "INBOX":
|
||||
querySession = db.Instance.Table("user_email").Select("id").Where("user_id=? and group_id=0 and status = 0", ctx.UserID).OrderBy("id desc")
|
||||
case "Sent Messages":
|
||||
querySession = db.Instance.Table("user_email").Select("id").Where("user_id=? and group_id=0 and status = 1", ctx.UserID).OrderBy("id desc")
|
||||
case "Drafts":
|
||||
querySession = db.Instance.Table("user_email").Select("id").Where("user_id=? and group_id=0 and status = 4", ctx.UserID).OrderBy("id desc")
|
||||
case "Deleted Messages":
|
||||
querySession = db.Instance.Table("user_email").Select("id").Where("user_id=? and group_id=0 and status = 3", ctx.UserID).OrderBy("id desc")
|
||||
case "Junk":
|
||||
querySession = db.Instance.Table("user_email").Select("id").Where("user_id=? and group_id=0 and status = 5", ctx.UserID).OrderBy("id desc")
|
||||
default:
|
||||
return 0, errors2.New("invalid default mailbox")
|
||||
}
|
||||
value, err := readGroupValue(querySession, "query next mailbox UID failed")
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return value + 1, nil
|
||||
}
|
||||
|
||||
func getGroupNum(ctx *context.Context, groupName string, mustUnread bool) (int, error) {
|
||||
var querySession *xorm.Session
|
||||
switch groupName {
|
||||
case "INBOX":
|
||||
if mustUnread {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=0 and is_read=0", ctx.UserID)
|
||||
} else {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=0", ctx.UserID)
|
||||
}
|
||||
case "Sent Messages":
|
||||
if mustUnread {
|
||||
return 0, nil
|
||||
}
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=1", ctx.UserID)
|
||||
case "Drafts":
|
||||
if mustUnread {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=4 and is_read=0", ctx.UserID)
|
||||
} else {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=4", ctx.UserID)
|
||||
}
|
||||
case "Deleted Messages":
|
||||
if mustUnread {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=3 and is_read=0", ctx.UserID)
|
||||
} else {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=3", ctx.UserID)
|
||||
}
|
||||
case "Junk":
|
||||
if mustUnread {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=5 and is_read=0", ctx.UserID)
|
||||
} else {
|
||||
querySession = db.Instance.Table("user_email").Select("count(1)").Where("user_id=? and group_id=0 and status=5", ctx.UserID)
|
||||
}
|
||||
default:
|
||||
return 0, errors2.New("invalid default mailbox")
|
||||
}
|
||||
return readGroupValue(querySession, "query mailbox count failed")
|
||||
}
|
||||
|
||||
func normalizeMoveMessageIDs(mailIDs []int) ([]int, error) {
|
||||
if len(mailIDs) == 0 {
|
||||
return nil, errors2.New("empty message ID list")
|
||||
}
|
||||
uniqueIDs := make([]int, 0, len(mailIDs))
|
||||
seen := make(map[int]struct{}, len(mailIDs))
|
||||
for _, id := range mailIDs {
|
||||
if id <= 0 {
|
||||
return nil, errors2.New("invalid message ID")
|
||||
}
|
||||
if _, exists := seen[id]; exists {
|
||||
continue
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
uniqueIDs = append(uniqueIDs, id)
|
||||
}
|
||||
if len(uniqueIDs) > 10000 {
|
||||
return nil, errors2.New("too many message IDs")
|
||||
}
|
||||
return uniqueIDs, nil
|
||||
}
|
||||
|
||||
func Move2DefaultBox(ctx *context.Context, mailIDs []int, groupName string) error {
|
||||
var status int8
|
||||
switch groupName {
|
||||
case "INBOX":
|
||||
status = consts.EmailTypeReceive
|
||||
case "Sent Messages":
|
||||
status = consts.EmailStatusSent
|
||||
case "Drafts":
|
||||
status = consts.EmailStatusDrafts
|
||||
case "Deleted Messages":
|
||||
status = consts.EmailStatusDel
|
||||
case "Junk":
|
||||
status = consts.EmailStatusJunk
|
||||
default:
|
||||
return errors2.New("invalid default mailbox")
|
||||
}
|
||||
|
||||
uniqueIDs, err := normalizeMoveMessageIDs(mailIDs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
session := db.Instance.NewSession()
|
||||
defer session.Close()
|
||||
if err := session.Begin(); err != nil {
|
||||
return fmt.Errorf("begin default mailbox move transaction: %w", err)
|
||||
}
|
||||
|
||||
var relations []models.UserEmail
|
||||
if err := session.Table(&models.UserEmail{}).Where(builder.Eq{
|
||||
"email_id": uniqueIDs,
|
||||
"user_id": ctx.UserID,
|
||||
}).Find(&relations); err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("load default mailbox move ownership: %w", err)
|
||||
}
|
||||
if len(relations) != len(uniqueIDs) {
|
||||
rollbackGroupTransaction(session)
|
||||
return errors2.New("one or more messages are not owned by the user")
|
||||
}
|
||||
|
||||
expectedChanges := 0
|
||||
for _, relation := range relations {
|
||||
if relation.Status != status || relation.GroupId != 0 {
|
||||
expectedChanges++
|
||||
}
|
||||
}
|
||||
if expectedChanges > 0 {
|
||||
affected, err := session.Table(&models.UserEmail{}).Where(builder.Eq{
|
||||
"email_id": uniqueIDs,
|
||||
"user_id": ctx.UserID,
|
||||
}).Cols("status", "group_id").Update(map[string]interface{}{
|
||||
"status": status,
|
||||
"group_id": 0,
|
||||
})
|
||||
if err != nil {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("move messages to default mailbox: %w", err)
|
||||
}
|
||||
if affected != int64(expectedChanges) {
|
||||
rollbackGroupTransaction(session)
|
||||
return fmt.Errorf("default mailbox move affected %d rows, expected %d", affected, expectedChanges)
|
||||
}
|
||||
}
|
||||
if err := session.Commit(); err != nil {
|
||||
return fmt.Errorf("commit default mailbox move transaction: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in new issue
Block a user