dsbqj_admin/app/service/version.go

package service

import (
	"context"
	"dsbqj-admin/app/task"
	"dsbqj-admin/model/mongo/version"

	"github.com/kamva/mgm/v3"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type VersionReloadService struct {
}

func (service *VersionReloadService) Reload() error {
	task.VersionTask.Exec()
	return nil
}

type VersionServerService struct {
	Channel string `json:"channel" binding:"required"`
}

func (service *VersionServerService) Servers() ([]*version.Version, error) {
	return task.VersionTask.Servers(service.Channel), nil
}

type VersionCheckService struct {
	Version    string `json:"version" binding:"required"`
	Channel    string `json:"channel" binding:"required"`
	EnvVersion string `json:"envVersion"`
}

func (service *VersionCheckService) Check() (*version.Version, error) {
	return task.VersionTask.Check(service.Version, service.Channel, service.EnvVersion), nil
}

type VersionShowService struct {
	CondPage
	Channel    string `form:"channel" json:"channel"`
	EnvVersion string `form:"envVersion" json:"envVersion"`
}

func (service *VersionShowService) List() ([]version.Version, error) {
	versions := make([]version.Version, 0)
	var queryDoc = bson.M{}
	if service.Channel != "" {
		queryDoc["channel"] = service.Channel
	}
	if service.EnvVersion != "" {
		envVersion := task.NormalizeEnvVersion(service.EnvVersion)
		if envVersion == "release" {
			queryDoc["$or"] = []bson.M{
				{"envVersion": envVersion},
				{"envVersion": ""},
				{"envVersion": bson.M{"$exists": false}},
			}
		} else {
			queryDoc["envVersion"] = envVersion
		}
	}

	err := mgm.Coll(&version.Version{}).SimpleFind(&versions, queryDoc)
	return versions, err
}

type VersionCreateService struct {
	Channel    string `json:"channel" binding:"required"`
	EnvVersion string `json:"envVersion"`
	Version    string `json:"version" binding:"required"`
	Name       string `json:"name" binding:"required"`
	CDN        string `json:"cdn" binding:"required"`
	Url        string `json:"url" binding:"required"`
}

func (service *VersionCreateService) Create() error {
	version := new(version.Version)
	version.Channel = service.Channel
	version.EnvVersion = task.NormalizeEnvVersion(service.EnvVersion)
	version.Name = service.Name
	version.Version = service.Version
	version.CDN = service.CDN
	version.Url = service.Url

	return mgm.Coll(version).Create(version)
}

type VersionEditService struct {
	Id         string  `json:"id" binding:"required"`
	Channel    *string `json:"channel"`
	EnvVersion *string `json:"envVersion"`
	Version    *string `json:"version"`
	Name       *string `json:"name"`
	CDN        *string `json:"cdn"`
	Url        *string `json:"url"`
	Default    *bool   `json:"default"`
}

func (service *VersionEditService) Edit() error {
	version := new(version.Version)

	objectId, _ := primitive.ObjectIDFromHex(service.Id)
	filterDoc := bson.M{"_id": objectId}
	updateDoc := bson.M{}
	if service.Channel != nil {
		updateDoc["channel"] = service.Channel
	}
	if service.EnvVersion != nil {
		updateDoc["envVersion"] = task.NormalizeEnvVersion(*service.EnvVersion)
	}
	if service.Name != nil {
		updateDoc["name"] = service.Name
	}
	if service.Version != nil {
		updateDoc["version"] = service.Version
	}
	if service.CDN != nil {
		updateDoc["cdn"] = service.CDN
	}
	if service.Url != nil {
		updateDoc["url"] = service.Url
	}
	if service.Default != nil {
		updateDoc["default"] = service.Default
	}

	_, err := mgm.Coll(version).UpdateOne(context.Background(), filterDoc, bson.M{"$set": updateDoc})

	return err
}

type VersionDeleteService struct {
	Id string `json:"id" binding:"required"`
}

func (service *VersionDeleteService) Delete() error {
	version := new(version.Version)
	objectId, _ := primitive.ObjectIDFromHex(service.Id)
	filterDoc := bson.M{"_id": objectId}

	_, err := mgm.Coll(version).DeleteOne(context.Background(), filterDoc)
	return err
}