model/channel_priority.go
Rama main · réplica de lectura del repositorio original.
package model
import (
"crypto/sha256"
"errors"
"fmt"
"slices"
"github.com/QuantumNous/new-api/common"
"gorm.io/gorm"
)
// Keep priorities lossless in the web console's JSON number representation.
const maxSortablePriority int64 = 1<<53 - 1
var ErrChannelPriorityConflict = errors.New("Channel priorities changed. Refresh and try again.")
var ErrChannelPriorityInvalid = errors.New("Invalid channel priority move")
var ErrChannelPriorityRange = errors.New("Channel priority is outside the sortable range")
type ChannelPriority struct {
ID int `json:"id"`
Priority *int64 `json:"priority"`
}
func (item ChannelPriority) value() int64 {
if item.Priority == nil {
return 0
}
return *item.Priority
}
type ChannelPriorityChange struct {
ID int `json:"id"`
Previous *int64 `json:"previous"`
Priority *int64 `json:"priority"`
}
type ChannelPriorityOrder struct {
Revision string `json:"revision"`
Items []ChannelPriority `json:"items"`
Changes []ChannelPriorityChange `json:"changes"`
}
type ChannelPriorityMove struct {
Revision string `json:"revision"`
ID int `json:"id"`
TargetID int `json:"target_id"`
Position string `json:"position"` // before / after use descending priority order
Preview bool `json:"preview"`
Restore []ChannelPriorityChange `json:"restore,omitempty"`
}
func channelPriorityRevision(items []ChannelPriority) string {
data, _ := common.Marshal(items)
return fmt.Sprintf("%x", sha256.Sum256(data))
}
func GetChannelPriorityOrder() (ChannelPriorityOrder, error) {
result := ChannelPriorityOrder{Items: []ChannelPriority{}, Changes: []ChannelPriorityChange{}}
err := DB.Model(&Channel{}).Select("id", "priority").Order("id").Find(&result.Items).Error
result.Revision = channelPriorityRevision(result.Items)
return result, err
}
// ReorderChannelPriority updates only priorities, including the routing copy in
// abilities. A snapshot check also protects preview/commit and undo from stale
// clients; row locks serialize concurrent reorders on MySQL and PostgreSQL.
func ReorderChannelPriority(move ChannelPriorityMove) (ChannelPriorityOrder, error) {
result := ChannelPriorityOrder{Items: []ChannelPriority{}, Changes: []ChannelPriorityChange{}}
err := DB.Transaction(func(tx *gorm.DB) error {
query := tx.Model(&Channel{}).Select("id", "priority").Order("id")
if !move.Preview {
query = lockForUpdate(query)
}
if err := query.Find(&result.Items).Error; err != nil {
return err
}
if move.Revision == "" || move.Revision != channelPriorityRevision(result.Items) {
return ErrChannelPriorityConflict
}
changes, err := planChannelPriorityMove(result.Items, move)
if err != nil {
return err
}
result.Changes = changes
byID := make(map[int]*ChannelPriority, len(result.Items))
for i := range result.Items {
byID[result.Items[i].ID] = &result.Items[i]
}
for _, change := range changes {
byID[change.ID].Priority = change.Priority
if move.Preview {
continue
}
if err := tx.Model(&Channel{}).Where("id = ?", change.ID).Update("priority", change.Priority).Error; err != nil {
return err
}
if err := tx.Model(&Ability{}).Where("channel_id = ?", change.ID).Update("priority", change.Priority).Error; err != nil {
return err
}
}
result.Revision = channelPriorityRevision(result.Items)
return nil
})
return result, err
}
// Equal-priority channels remain together. Opening a slot shifts the shorter
// contiguous run of occupied integer priorities, measured by affected channels.
func planChannelPriorityMove(items []ChannelPriority, move ChannelPriorityMove) ([]ChannelPriorityChange, error) {
changes := []ChannelPriorityChange{}
byID := make(map[int]ChannelPriority, len(items))
for _, item := range items {
if item.value() < -maxSortablePriority || item.value() > maxSortablePriority {
return nil, ErrChannelPriorityRange
}
byID[item.ID] = item
}
if len(move.Restore) > 0 {
if move.ID != 0 || move.TargetID != 0 || move.Position != "" {
return nil, ErrChannelPriorityInvalid
}
seen := make(map[int]bool, len(move.Restore))
for _, change := range move.Restore {
item, ok := byID[change.ID]
if !ok || seen[change.ID] || (change.Priority != nil && (*change.Priority < -maxSortablePriority || *change.Priority > maxSortablePriority)) {
return nil, ErrChannelPriorityInvalid
}
if !equalPriority(item.Priority, change.Previous) {
return nil, ErrChannelPriorityConflict
}
seen[change.ID] = true
if !equalPriority(item.Priority, change.Priority) {
changes = append(changes, change)
}
}
return changes, nil
}
item, ok := byID[move.ID]
target, targetOK := byID[move.TargetID]
if !ok || !targetOK || move.ID == move.TargetID || !slices.Contains([]string{"before", "after", "same"}, move.Position) {
return nil, ErrChannelPriorityInvalid
}
values := make(map[int]int64, len(items))
for _, entry := range items {
values[entry.ID] = entry.value()
}
if move.Position == "same" {
values[item.ID] = target.value()
} else {
counts := make(map[int64]int)
for _, entry := range items {
if entry.ID != item.ID {
counts[entry.value()]++
}
}
levels := make([]int64, 0, len(counts))
for level := range counts {
levels = append(levels, level)
}
slices.SortFunc(levels, func(a, b int64) int {
if a > b {
return -1
}
if a < b {
return 1
}
return 0
})
index := slices.Index(levels, target.value())
if move.Position == "after" {
index++
}
hi, lo := maxSortablePriority+1, -maxSortablePriority-1
if index > 0 {
hi = levels[index-1]
}
if index < len(levels) {
lo = levels[index]
}
// Dropping into the channel's existing slot must not renumber it.
if item.value() < hi && item.value() > lo {
return changes, nil
}
if hi-lo < 2 {
up, down := index-1, index
upCost, downCost := 0, 0
for up >= 0 {
upCost += counts[levels[up]]
if (up == 0 && levels[up] < maxSortablePriority) || (up > 0 && levels[up-1]-levels[up] > 1) {
break
}
up--
}
for down < len(levels) {
downCost += counts[levels[down]]
if (down == len(levels)-1 && levels[down] > -maxSortablePriority) || (down+1 < len(levels) && levels[down]-levels[down+1] > 1) {
break
}
down++
}
canUp, canDown := up >= 0 && index > 0, down < len(levels) && index < len(levels)
if !canUp && !canDown {
return nil, ErrChannelPriorityRange
}
if canUp && (!canDown || upCost < downCost) {
for id, value := range values {
if id != item.ID && value >= levels[index-1] && value <= levels[up] {
values[id]++
}
}
hi++
} else {
for id, value := range values {
if id != item.ID && value <= levels[index] && value >= levels[down] {
values[id]--
}
}
lo--
}
}
value := lo + (hi-lo)/2
if index == 0 {
value = min(maxSortablePriority, lo+10)
} else if index == len(levels) {
value = max(-maxSortablePriority, hi-10)
}
values[item.ID] = value
}
for _, entry := range items {
value := values[entry.ID]
if value != entry.value() {
changes = append(changes, ChannelPriorityChange{ID: entry.ID, Previous: entry.Priority, Priority: &value})
}
}
return changes, nil
}
func equalPriority(a, b *int64) bool {
if a == nil || b == nil {
return a == nil && b == nil
}
return *a == *b
}