bl/modules/config/service/server.go

package service

import (
	"blazing/common/utils"
	"blazing/cool"
	"blazing/modules/config/model"
	"fmt"
	"sort"
	"time"

	"github.com/gogf/gf/v2/container/gmap"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/qiniu/go-sdk/v7/auth/qbox"
	"github.com/qiniu/go-sdk/v7/storage"
)

type ServerService struct {
	*cool.Service
	manager *storage.BucketManager
	bucket  string
}

type ServerShowInfo struct {
	OnlineID uint32 `json:"online_id"`
	Name     string `json:"name"`
	IP       string `json:"ip"`
	Port     uint32 `json:"port"`
	IsVip    uint32 `json:"is_vip"`
	IsDebug  uint8  `json:"is_debug"`
	IsOpen   uint8  `json:"is_open"`
	//Owner    uint32 `json:"owner"`
	// ExpireTime time.Time         `json:"expire_time"`
	// ServerShow *model.ServerShow `json:"servershow,omitempty"`
}

type DonationOwnedServerInfo struct {
	ServerID   uint32    `json:"server_id"`
	ServerName string    `json:"server_name"`
	Remark     string    `json:"remark"`
	ExpireTime time.Time `json:"expire_time"`
}

func NewServerService() *ServerService {
	cf := &ServerService{
		Service: &cool.Service{
			Model: model.NewServerList(),
		},
	}
	cf.PageQueryOp = &cool.QueryOp{
		ModifyResult: func(ctx g.Ctx, data interface{}) interface{} {
			var rr []g.MapStrAny
			r, _ := gconv.Map(data)["list"].(gdb.Result)

			now := time.Now()
			serverIDs := make([]uint32, 0, len(r))
			for i := 0; i < len(r); i++ {
				serverID := gconv.Uint32(r[i].Map()["online_id"])
				if serverID == 0 {
					continue
				}
				serverIDs = append(serverIDs, serverID)
			}
			showMap := cf.getPrimaryActiveServerShowMap(serverIDs, now)

			for i := 0; i < len(r); i++ {
				t, ok := cool.GetClient(gconv.Uint32(r[i].Map()["online_id"]), gconv.Uint32(r[i].Map()["port"]))
				subm := r[i].GMap()
				cf.applyServerShowMap(subm, gconv.Uint32(r[i].Map()["online_id"]), showMap)

				if ok {
					err := t.KickPerson(0) //实现指定服务器踢人
					if err == nil {
						r, _ := utils.TcpPing(fmt.Sprintf("%s:%d", r[i].Map()["ip"], r[i].Map()["port"]))
						subm.Set("isonline", r)
					} else {
						subm.Set("isonline", 0)
					}
				} else {
					subm.Set("isonline", 0)
				}
				rr = append(rr, subm.MapStrAny())
			}

			data.(map[string]interface{})["list"] = rr
			return data
		},
	}

	cfg := storage.Config{
		Zone:          &storage.ZoneHuadong,
		UseHTTPS:      true,
		UseCdnDomains: true,
	}
	mac := qbox.NewMac("DzMpomnPxqBHkIcvxTbC-hl_8LjVB0LXZuhCky_u", "bhoxrpG1s7MBmSS2I1k5t9zMpuiderpBDZoIPQKU")
	cf.bucket = "blazingt"
	cf.manager = storage.NewBucketManager(mac, &cfg)
	return cf
}

func (s *ServerService) GetPort(DepartmentID uint) []ServerShowInfo {
	servers := s.getRawServers()
	now := time.Now()
	showMap := s.getActiveServerShowListMap(s.collectServerIDs(servers), now)
	items := make([]ServerShowInfo, 0, len(servers))
	for _, server := range servers {
		if server.IsOpen != 1 {
			continue
		}
		if DepartmentID == 1 && server.IsDebug != 0 {
			continue
		}
		items = append(items, ServerShowInfo{
			OnlineID: server.OnlineID,
			Name:     server.Name,
			IP:       server.IP,
			Port:     server.Port,
			IsVip:    server.IsVip,
			IsDebug:  server.IsDebug,
			IsOpen:   server.IsOpen,
			//Owner:    0,
			//	ExpireTime: time.Time{},
		})
		for i := range showMap[server.OnlineID] {
			show := &showMap[server.OnlineID][i]
			itemOnlineID := server.OnlineID
			if show.ID > 0 {
				itemOnlineID = uint32(show.ID)
			}
			item := ServerShowInfo{
				OnlineID: itemOnlineID,
				Name:     server.Name,
				IP:       server.IP,
				Port:     server.Port,
				IsVip:    server.IsVip,
				IsDebug:  server.IsDebug,
				IsOpen:   server.IsOpen,

				// ExpireTime: show.ExpireTime,
				// ServerShow: show,
			}
			if show.Name != "" {
				item.Name = show.Name
			}
			items = append(items, item)
		}
	}
	return items
}

func (s *ServerService) GetServer() []model.ServerList {
	item := s.getRawServers()
	s.applyServerShowList(item, time.Now())
	return item
}

func (s *ServerService) StartUPdate(OnlineID uint16, isinstall int) model.ServerList {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	if isinstall == 1 {
		tttt.IsOpen = uint8(0)
		m.Save(tttt)
	}
	return tttt
}

func (s *ServerService) SetServerID(OnlineID uint32, Port uint32) error {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	tttt.Port = Port
	tttt.OnlineID = OnlineID
	tttt.IsOpen = 1
	m.Save(tttt)
	return nil
}

func (s *ServerService) GetServerID(OnlineID uint32) model.ServerList {
	var tttt model.ServerList
	dbm_nocache_noenable(s.Model).Where("online_id", OnlineID).Scan(&tttt)
	showMap := s.getPrimaryActiveServerShowMap([]uint32{OnlineID}, time.Now())
	s.applyServerShow(&tttt, showMap[OnlineID], time.Now())
	return tttt
}

// GetDonationAvailableServerIDs 返回当前可被冠名占用的服务器ID列表。
func (s *ServerService) GetDonationAvailableServerIDs() []uint32 {
	servers := s.getRawServers()
	ids := make([]uint32, 0, len(servers))
	for _, server := range servers {
		if server.OnlineID == 0 {
			continue
		}
		ids = append(ids, server.OnlineID)
	}
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
	return ids
}

func (s *ServerService) GetOwnerActiveDonationServers(ownerID uint32) []DonationOwnedServerInfo {
	if ownerID == 0 {
		return []DonationOwnedServerInfo{}
	}

	now := time.Now()

	var shows []model.ServerShow
	dbm_nocache_noenable(model.NewServerShow()).Where("owner", ownerID).Scan(&shows)
	if len(shows) == 0 {
		return []DonationOwnedServerInfo{}
	}

	serverIDs := make([]uint32, 0, len(shows))
	for i := range shows {
		if !s.isActiveServerShow(&shows[i], now) {
			continue
		}
		serverIDs = append(serverIDs, shows[i].ServerID)
	}
	if len(serverIDs) == 0 {
		return []DonationOwnedServerInfo{}
	}

	var servers []model.ServerList
	dbm_nocache_noenable(s.Model).WhereIn("online_id", serverIDs).Scan(&servers)

	serverMap := make(map[uint32]model.ServerList, len(servers))
	for i := range servers {
		serverMap[servers[i].OnlineID] = servers[i]
	}

	items := make([]DonationOwnedServerInfo, 0, len(serverIDs))
	for i := range shows {
		show := &shows[i]
		if !s.isActiveServerShow(show, now) {
			continue
		}

		server, ok := serverMap[show.ServerID]
		if !ok || show.ServerID == 0 {
			continue
		}

		serverName := show.Name
		if serverName == "" {
			serverName = server.Name
		}

		items = append(items, DonationOwnedServerInfo{
			ServerID:   show.ServerID,
			ServerName: serverName,
			Remark:     server.Desc,
			ExpireTime: show.ExpireTime,
		})
	}

	sort.Slice(items, func(i, j int) bool {
		if !items[i].ExpireTime.Equal(items[j].ExpireTime) {
			return items[i].ExpireTime.After(items[j].ExpireTime)
		}
		return items[i].ServerID < items[j].ServerID
	})

	return items
}

// CanUseDonationName 校验目标服务器在当前时间点是否允许被冠名。
func (s *ServerService) CanUseDonationName(server model.ServerList, ownerID uint32, now time.Time) bool {
	return server.OnlineID != 0
}

func (s *ServerService) getRawServers() []model.ServerList {
	var item []model.ServerList
	dbm_nocache_noenable(s.Model).Scan(&item)
	return item
}

func (s *ServerService) collectServerIDs(servers []model.ServerList) []uint32 {
	serverIDs := make([]uint32, 0, len(servers))
	for i := range servers {
		if servers[i].OnlineID == 0 {
			continue
		}
		serverIDs = append(serverIDs, servers[i].OnlineID)
	}
	return serverIDs
}

// 保存版本号
func (s *ServerService) SetServerScreen(id uint32, name string) {
	cool.DBM(s.Model).Where("online_id", id).Data("old_screen", name).Update()
}

func (s *ServerService) GetFile() string {
	var files []File
	prefix := "logic"
	delimiter := "" // 用于分隔目录
	marker := ""    // 初始标记为空
	for {
		entries, _, nextMarker, hasNext, err := s.manager.ListFiles(s.bucket, prefix, delimiter, marker, 100)
		if err != nil {
			return ""
		}
		for _, entry := range entries {
			files = append(files, File{
				Name: entry.Key,
				Size: entry.Fsize,
				Path: entry.Key,
				Time: entry.PutTime,
			})
		}
		if !hasNext {
			break
		}
		marker = nextMarker
	}

	sort.Slice(files, func(i, j int) bool {
		return files[i].Time > files[j].Time
	})
	if len(files) == 0 {
		return ""
	}
	return files[0].Name
}

type File struct {
	Name     string `json:"name"`
	Path     string `json:"path"`
	Url      string `json:"url"`
	Size     int64  `json:"size"`
	Modified string `json:"modified"`
	Time     int64  `json:"time"`
}

func (s *ServerService) isActiveServerShow(show *model.ServerShow, now time.Time) bool {
	if show == nil {
		return false
	}
	if show.ServerID == 0 || show.Owner == 0 {
		return false
	}
	if show.ExpireTime.IsZero() {
		return false
	}
	return show.ExpireTime.After(now)
}

func (s *ServerService) applyServerShowList(servers []model.ServerList, now time.Time) {
	showMap := s.getPrimaryActiveServerShowMap(s.collectServerIDs(servers), now)
	for i := range servers {
		s.applyServerShow(&servers[i], showMap[servers[i].OnlineID], now)
	}
}

func (s *ServerService) applyServerShow(server *model.ServerList, show *model.ServerShow, now time.Time) {
	if server == nil {
		return
	}
	server.ServerShow = nil
	server.Owner = 0
	server.ExpireTime = time.Time{}
	if !s.isActiveServerShow(show, now) {
		return
	}
	server.ServerShow = show
	if show.Name != "" {
		server.Name = show.Name
	}
	server.Owner = show.Owner
	server.ExpireTime = show.ExpireTime
}

func (s *ServerService) getActiveServerShowListMap(serverIDs []uint32, now time.Time) map[uint32][]model.ServerShow {
	showMap := make(map[uint32][]model.ServerShow, len(serverIDs))
	if len(serverIDs) == 0 {
		return showMap
	}
	var shows []model.ServerShow
	dbm_nocache_noenable(model.NewServerShow()).WhereIn("server_id", serverIDs).Scan(&shows)
	for i := range shows {
		show := &shows[i]
		if !s.isActiveServerShow(show, now) {
			continue
		}
		showMap[show.ServerID] = append(showMap[show.ServerID], *show)
	}
	for serverID := range showMap {
		sort.Slice(showMap[serverID], func(i, j int) bool {
			left := showMap[serverID][i]
			right := showMap[serverID][j]
			if !left.ExpireTime.Equal(right.ExpireTime) {
				return left.ExpireTime.After(right.ExpireTime)
			}
			return left.ID > right.ID
		})
	}
	return showMap
}

func (s *ServerService) getPrimaryActiveServerShowMap(serverIDs []uint32, now time.Time) map[uint32]*model.ServerShow {
	listMap := s.getActiveServerShowListMap(serverIDs, now)
	showMap := make(map[uint32]*model.ServerShow, len(listMap))
	for serverID := range listMap {
		if len(listMap[serverID]) == 0 {
			continue
		}
		show := listMap[serverID][0]
		showMap[serverID] = &show
	}
	return showMap
}

func (s *ServerService) applyServerShowMap(serverMap *gmap.StrAnyMap, serverID uint32, showMap map[uint32]*model.ServerShow) {
	if serverMap == nil {
		return
	}
	serverMap.Set("owner", uint32(0))
	serverMap.Set("expire_time", time.Time{})
	show, ok := showMap[serverID]
	if !ok {
		return
	}
	if show.Name != "" {
		serverMap.Set("name", show.Name)
	}
	serverMap.Set("owner", show.Owner)
	serverMap.Set("expire_time", show.ExpireTime)
	serverMap.Set("servershow", show)
	return
}