package controller
|
|
import (
|
"encoding/json"
|
"fmt"
|
"io/ioutil"
|
"net/http"
|
"os"
|
"os/exec"
|
"path"
|
"path/filepath"
|
"sort"
|
"strconv"
|
"strings"
|
"time"
|
"vamicro/extend/code"
|
"vamicro/extend/util"
|
"vamicro/version-control/models"
|
"vamicro/version-control/routers"
|
"vamicro/version-control/service"
|
|
"basic.com/valib/bhomeclient.git"
|
"basic.com/valib/c_bhomebus.git/proto/source/bhome_msg"
|
"basic.com/valib/licence.git"
|
"basic.com/valib/logger.git"
|
"github.com/gin-gonic/gin"
|
)
|
|
type (
|
VersionRouter struct {
|
routers.Router
|
}
|
)
|
|
const (
|
basePath = "/version"
|
manifest = "dist/bin/manifest.ini"
|
zipDir = "dist/bin"
|
)
|
|
var (
|
CheckVersion *VersionRouter
|
Upgrade *VersionRouter
|
UploadDist *VersionRouter
|
SettingFetch *VersionRouter
|
SettingPush *VersionRouter
|
UpdateNotice *VersionRouter
|
DelayNotice *VersionRouter
|
PreUpLoad *VersionRouter
|
UpgradePreUpLoad *VersionRouter
|
RollBack *VersionRouter
|
Authorization *VersionRouter
|
GetSn *VersionRouter
|
Qrcode *VersionRouter
|
AuthorizationUpload *VersionRouter
|
CancelAuthorization *VersionRouter
|
CancelAuthorizationUpload *VersionRouter
|
|
ShopMakeSmsCod *VersionRouter
|
ShopCenterLogin *VersionRouter
|
ShopCenterGetOrderList *VersionRouter
|
AuthActiveByOrder *VersionRouter
|
|
AutoBakShow *VersionRouter
|
AutoBakConfSet *VersionRouter
|
AutoBakRightNow *VersionRouter
|
BackupListShow *VersionRouter
|
BackupRecov *VersionRouter
|
|
Ms *bhomeclient.MicroNode
|
)
|
|
func init() {
|
CheckVersion = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "check",
|
Handles: []gin.HandlerFunc{versionCheckHandle},
|
},
|
}
|
|
UploadDist = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "upload",
|
Handles: []gin.HandlerFunc{uploadDistHandle},
|
},
|
}
|
|
Upgrade = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "upgrade",
|
Handles: []gin.HandlerFunc{upgradeHandle},
|
},
|
}
|
|
SettingFetch = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet},
|
Path: "settings",
|
Handles: []gin.HandlerFunc{settingFetchHandle},
|
},
|
}
|
|
SettingPush = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "setting/update",
|
Handles: []gin.HandlerFunc{settingPushHandle},
|
},
|
}
|
|
UpdateNotice = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet},
|
Path: "notice",
|
Handles: []gin.HandlerFunc{updateNoticeHandle},
|
},
|
}
|
|
DelayNotice = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "notice/delay",
|
Handles: []gin.HandlerFunc{delayNoticeHandle},
|
},
|
}
|
PreUpLoad = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "upload/zip",
|
Handles: []gin.HandlerFunc{preUploadDistHandle},
|
},
|
}
|
UpgradePreUpLoad = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "upgrade/zip",
|
Handles: []gin.HandlerFunc{upgradePreUploadHandle},
|
},
|
}
|
RollBack = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "rollback",
|
Handles: []gin.HandlerFunc{RollBackHandle},
|
},
|
}
|
Authorization = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "authorization",
|
Handles: []gin.HandlerFunc{AuthorizationHandle},
|
},
|
}
|
|
AuthorizationUpload = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "authorization/upload",
|
Handles: []gin.HandlerFunc{AuthorizationUploadHandle},
|
},
|
}
|
|
GetSn = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "sn",
|
Handles: []gin.HandlerFunc{GetSnHandle},
|
},
|
}
|
Qrcode = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "offline/qrcode",
|
Handles: []gin.HandlerFunc{QrcodeHandle},
|
},
|
}
|
CancelAuthorization = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "cancelAuthorization",
|
Handles: []gin.HandlerFunc{CancelAuthorizationHandle},
|
},
|
}
|
CancelAuthorizationUpload = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet, http.MethodPost},
|
Path: "cancelAuthorization/upload",
|
Handles: []gin.HandlerFunc{CancelAuthorizationUploadHandle},
|
},
|
}
|
|
ShopMakeSmsCod = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet},
|
Path: "auth/shop/smsCode",
|
Handles: []gin.HandlerFunc{shopMakSmsHandle},
|
},
|
}
|
|
ShopCenterLogin = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "auth/shop/login",
|
Handles: []gin.HandlerFunc{shopCenterLoginHandle},
|
},
|
}
|
ShopCenterGetOrderList = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "auth/shop/getOrderList",
|
Handles: []gin.HandlerFunc{shopCenterGetOrderListHandle},
|
},
|
}
|
AuthActiveByOrder = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "auth/shop/activeByOrder",
|
Handles: []gin.HandlerFunc{authActiveByOrderHandle},
|
},
|
}
|
|
AutoBakShow = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet},
|
Path: "autoBak/config",
|
Handles: []gin.HandlerFunc{ShowAutoBakConf},
|
},
|
}
|
AutoBakConfSet = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "autoBak/saveConf",
|
Handles: []gin.HandlerFunc{SaveAutoBakConf},
|
},
|
}
|
AutoBakRightNow = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "autoBak/backupRN",
|
Handles: []gin.HandlerFunc{BackupRN},
|
},
|
}
|
BackupListShow = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodGet},
|
Path: "autoBak/list",
|
Handles: []gin.HandlerFunc{BackupList},
|
},
|
}
|
BackupRecov = &VersionRouter{
|
routers.Router{
|
Methods: []string{http.MethodPost},
|
Path: "autoBak/recover",
|
Handles: []gin.HandlerFunc{BackupRecover},
|
},
|
}
|
}
|
|
func (r *VersionRouter) GetPath() string {
|
return path.Join(basePath, r.Path)
|
}
|
|
//在系统配置app中，给页面调用，判断提醒有没有程序是否需要升级
|
func versionCheckHandle(c *gin.Context) {
|
_, version, intro := service.CheckVersion()
|
|
curVersion := service.GetCurVersion()
|
//curEnv, _ := service.GetRunVersionEnv()
|
//hasNewVersion := len(programs) > 0
|
hasNewVersion := version != curVersion
|
if version == "" {
|
hasNewVersion = false
|
version = curVersion
|
}
|
|
c.JSON(http.StatusOK, gin.H{
|
"code": 200,
|
"msg": "ok",
|
"data": map[string]interface{}{
|
"hasNewVersion": hasNewVersion,
|
"newVersion": version,
|
"newVersionInfo": intro,
|
"curVersion": curVersion,
|
"curVersionPath": curVersion,
|
},
|
})
|
}
|
|
func preUploadDistHandle(c *gin.Context) {
|
file, err := c.FormFile("archive")
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
UpgradePath := service.GetPreUploadPath()
|
err = os.RemoveAll(UpgradePath)
|
if nil == err {
|
_ = os.MkdirAll(UpgradePath, 0777)
|
} else {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle remove pre upload path failed, err:", err.Error())
|
return
|
}
|
fileMd5 := service.GetMd5(file.Filename) + ".tgz"
|
if err = c.SaveUploadedFile(file, path.Join(UpgradePath, fileMd5)); err != nil {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle save file failed, err:", err.Error())
|
return
|
}
|
logger.Info("uploadDistHandle saved to temp file ok:", fileMd5)
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": map[string]string{"id": fileMd5},
|
})
|
}
|
|
func upgradePreUploadHandle(c *gin.Context) {
|
upid := c.Query("id")
|
if upid == "" {
|
util.ResponseFormat(c, code.RequestParamError, "id不能为空")
|
return
|
}
|
UpgradePath := service.GetPreUploadPath()
|
upZip := path.Join(UpgradePath, upid)
|
if !util.FileExists(upZip) {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "升级包未找到!",
|
"data": []*models.Program{},
|
})
|
logger.Error("upgradePreUploadHandle upload file not found:", upZip)
|
return
|
}
|
|
logger.Info("开始升级！")
|
apps, err := service.UpgradeViaZip(upZip)
|
logger.Info("系统升级完成！！")
|
if nil != err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": err.Error(),
|
"data": apps,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": apps,
|
})
|
killApp(apps)
|
}
|
}
|
|
//在离线的情况，使用tgz包直接在内网上传离线安装包
|
func uploadDistHandle(c *gin.Context) {
|
file, err := c.FormFile("archive")
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
UpgradePath := service.GetPreUploadPath()
|
tmpFile, err := ioutil.TempFile(UpgradePath, "dist-*.tgz")
|
if nil != err {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle create temp file failed, err:", err.Error())
|
return
|
}
|
defer func() {
|
tmpFile.Close()
|
os.Remove(tmpFile.Name())
|
}()
|
|
if err = c.SaveUploadedFile(file, tmpFile.Name()); err != nil {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("uploadDistHandle save file failed, err:", err.Error())
|
return
|
}
|
logger.Info("uploadDistHandle saved to temp file ok:", tmpFile.Name())
|
|
apps, err := service.UpgradeViaZip(tmpFile.Name())
|
if nil != err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": err.Error(),
|
"data": apps,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": apps,
|
})
|
}
|
}
|
|
func upgradeHandle(c *gin.Context) {
|
apps, err := service.OnlineUpgrade()
|
if nil != err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": err.Error(),
|
"data": apps,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": apps,
|
})
|
//_ = syscall.Kill(syscall.Getpid(), syscall.SIGINT)
|
killApp(apps)
|
}
|
}
|
|
func killApp(apps []*models.Program) {
|
//循环杀死升级应用进程
|
versionControl := ""
|
for _, app := range apps {
|
if app.Name == "version-control" {
|
versionControl = app.Name
|
continue
|
}
|
if app.Type == "sys" || app.Type == "app" {
|
command := "pkill " + app.Name
|
result, err := execCommand(command)
|
logger.Info("执行命令【", command, "】")
|
logger.Info("执行结果【", result, "err:,", err, "】")
|
}
|
}
|
if versionControl != "" {
|
command := "pkill " + versionControl
|
result, err := execCommand(command)
|
logger.Info("执行命令【", command, "】")
|
logger.Info("执行结果【", result, "\n err:,", err, "】")
|
}
|
}
|
|
//执行命令
|
func execCommand(cmd string) ([]byte, error) {
|
return exec.Command("/bin/bash", "-c", cmd).Output()
|
}
|
|
//获取配置
|
func settingFetchHandle(c *gin.Context) {
|
var model models.SysSetting
|
settings, err := model.GetAllSetting()
|
if nil != err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": err.Error(),
|
"data": settings,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": settings,
|
})
|
}
|
}
|
|
//更新配置
|
func settingPushHandle(c *gin.Context) {
|
name := c.PostForm("name")
|
value := c.PostForm("value")
|
setting := models.SysSetting{Name: name, Value: value}
|
err := setting.SaveSetting(true)
|
if nil != err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": err.Error(),
|
"data": []interface{}{},
|
})
|
} else {
|
data, _ := json.Marshal(setting)
|
var nodes []bhome_msg.BHAddress
|
nodes = append(nodes, bhome_msg.BHAddress{})
|
go Ms.PublishNetTimeout(nodes, service.SysUpdateConfigTopic, data, 10)
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func updateNoticeHandle(c *gin.Context) {
|
notice := service.GetUpdateNotice()
|
uid, ok := c.Get("uid")
|
if ok {
|
LastNoticeTime, ok := notice.NoticeUser[uid.(string)]
|
if ok {
|
notice.LastNoticeTime = int64(LastNoticeTime)
|
}
|
}
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": notice,
|
})
|
}
|
|
func delayNoticeHandle(c *gin.Context) {
|
delaySecond := c.PostForm("delaySecond")
|
second, err := strconv.Atoi(delaySecond)
|
if nil == err {
|
uid, ok := c.Get("uid")
|
if ok {
|
notice := service.DelayNotice(uid.(string), second)
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": notice,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "未找到用户",
|
"data": []interface{}{},
|
})
|
}
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "参数错误",
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func RollBackHandle(c *gin.Context) {
|
version := c.PostForm("version")
|
err := service.Rollback(version)
|
if nil == err {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": []interface{}{},
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "回滚失败，" + err.Error(),
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func sn() map[string]interface{} {
|
data := make(map[string]interface{}, 0)
|
sn := util.GetSn()
|
data["sn"] = sn
|
auth := util.GetAuthorization()
|
data["expireTime"] = ""
|
|
authInfo, err := util.GetAuthorizationInfo(auth)
|
//logger.Debug("授权信息：", authInfo, err, licence.GetMachineCode())
|
if err == nil && authInfo.MachineCode == licence.GetMachineCode() {
|
expireUt := time.Unix(authInfo.ExpirationTime, 0)
|
expireTimeStr := expireUt.Format("2006-01-02 15:04:05")
|
data["expireTime"] = expireTimeStr
|
data["expire"] = false
|
if authInfo.ActivateCode != "" {
|
data["sn"] = authInfo.ActivateCode
|
}
|
if authInfo.DevCount == -1 { //试用版
|
data["sn"] = ""
|
}
|
if time.Now().Sub(expireUt) > 0 {
|
data["expire"] = true
|
data["sn"] = ""
|
}
|
if data["sn"] != "" {
|
data["authorization"] = auth
|
}
|
data["edition"] = authInfo.Edition
|
data["installTime"] = authInfo.InstallTime
|
if authInfo.Edition == "" || authInfo.InstallTime == "" {
|
if eii, err := util.GetEdtionSetFromIns(); err == nil {
|
if authInfo.Edition == "" {
|
data["edition"] = eii.Edition
|
}
|
if authInfo.InstallTime == "" {
|
data["installTime"] = eii.InstallTime
|
}
|
}
|
}
|
} else {
|
//测试版
|
eii, err := util.GetEdtionSetFromIns()
|
if err == nil {
|
insT, _ := time.ParseInLocation("2006-01-02 15:04:05", eii.InstallTime, time.Local)
|
if eii.OrderAuth != nil && eii.OrderAuth.ProductId != "" && eii.OrderAuth.OrderId != "" {
|
data["sn"] = ""
|
expireT := insT.AddDate(eii.OrderAuth.ServeYear, 0, 0)
|
data["expireTime"] = expireT.Format("2006-01-02 15:04:05")
|
if time.Now().Sub(expireT) > 0 {
|
data["expire"] = true
|
} else {
|
data["expire"] = false
|
}
|
} else {
|
data["sn"] = ""
|
expireT := insT.AddDate(0, 0, eii.Setting.TrialDays)
|
data["expireTime"] = expireT.Format("2006-01-02 15:04:05")
|
if time.Now().Sub(expireT) > 0 {
|
data["expire"] = true
|
} else {
|
data["expire"] = false
|
}
|
}
|
data["edition"] = eii.Edition
|
data["installTime"] = eii.InstallTime
|
} else {
|
logger.Error("Install info missing")
|
data["sn"] = ""
|
data["authorization"] = ""
|
data["expire"] = true
|
data["edition"] = "trial"
|
data["installTime"] = ""
|
}
|
}
|
|
data["q"] = service.GetQ()
|
return data
|
}
|
|
func GetSnHandle(c *gin.Context) {
|
data := sn()
|
/* set := logc.RuleServerPushLog{}
|
set.TaskName = "Test"
|
set.Type = 0
|
set.Info = "111222111"
|
uuid, _ := uuid.GenerateUUID()
|
set.ID = uuid
|
data2, _ := json.Marshal(set)
|
var nodes []bhome_msg.BHAddress
|
nodes = append(nodes, bhome_msg.BHAddress{})
|
go Ms.PublishNetTimeout(nodes, "ruleServerLogSaveTopic", data2, 10)*/
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": data,
|
})
|
}
|
|
func QrcodeHandle(c *gin.Context) {
|
png, url, err := service.GenQRCode()
|
if nil == err {
|
c.Header("content-disposition", `attachment; filename=qrcode.png`)
|
c.Header("qrcode-url", url)
|
c.Data(200, "image/png", png)
|
return
|
}
|
|
logger.Error("QrcodeHandle err!!!")
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "生成二维码失败",
|
"data": "",
|
})
|
}
|
|
func AuthorizationUploadHandle(c *gin.Context) {
|
codeF, err := c.FormFile("code") //就是商城中生成的产品密钥订单下载的文件
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
F, err := codeF.Open()
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
buffer := make([]byte, codeF.Size)
|
_, err = F.Read(buffer)
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
|
code := string(buffer)
|
if "" == code {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "产品密钥不能为空",
|
"data": []interface{}{},
|
})
|
return
|
}
|
|
_, err = service.Authorization(code, true)
|
if nil == err || strings.Contains(err.Error(), "成功") {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": string(code),
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "激活失败，" + err.Error(),
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func AuthorizationHandle(c *gin.Context) {
|
code := c.PostForm("code") //产品密钥的内容,就是商城中生成的产品密钥订单下载的文件内容
|
if "" == code {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "产品密钥不能为空",
|
"data": []interface{}{},
|
})
|
return
|
}
|
_, err := service.Authorization(code, true)
|
if nil == err || strings.Contains(err.Error(), "成功") {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": []interface{}{},
|
})
|
} else {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "激活失败，" + err.Error(),
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func CancelAuthorizationHandle(c *gin.Context) {
|
q := c.PostForm("q")
|
supperPasswd := c.PostForm("passwd")
|
down := c.PostForm("down")
|
|
err, authCode := service.CancelAuthorization(supperPasswd, q)
|
if err != nil && !strings.Contains(err.Error(), "成功") {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []interface{}{},
|
})
|
} else {
|
if "1" == down {
|
c.Header("content-disposition", `attachment; filename=authorization.txt`)
|
///c.Header("qrcode-url", url)
|
c.Data(200, "text/plain", []byte(authCode))
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": authCode,
|
})
|
}
|
}
|
}
|
|
func CancelAuthorizationUploadHandle(c *gin.Context) {
|
q, err := c.FormFile("q")
|
supperPasswd := c.PostForm("passwd")
|
down := c.PostForm("down")
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
F, err := q.Open()
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
buffer := make([]byte, q.Size)
|
_, err = F.Read(buffer)
|
if nil != err {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
})
|
logger.Error("AuthorizationUploadHandle upload field is not filled with a file, err:", err.Error())
|
return
|
}
|
|
err, authinfo := service.CancelAuthorization(supperPasswd, string(buffer))
|
if nil == err {
|
if "1" == down {
|
c.Header("content-disposition", `attachment; filename=authorization.txt`)
|
///c.Header("qrcode-url", url)
|
c.Data(200, "text/plain", []byte(authinfo))
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": authinfo,
|
})
|
}
|
} else {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []interface{}{},
|
})
|
}
|
}
|
|
func ShowAutoBakConf(c *gin.Context) {
|
var ab models.AutoBackupConf
|
i, e := ab.Select()
|
if e == nil && i > 0 {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "查询成功",
|
"data": ab,
|
})
|
return
|
}
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "查询成功",
|
"data": models.AutoBackupConf{
|
Dir: util.GetVamicroPath() + "/backup_auto",
|
},
|
})
|
}
|
|
func SaveAutoBakConf(c *gin.Context) {
|
var reqBody models.AutoBackupConf
|
err := c.BindJSON(&reqBody)
|
if err != nil {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []models.AutoBackupConf{},
|
})
|
return
|
}
|
fmt.Println("go here 1 ", reqBody)
|
reqBody.Dir = util.GetVamicroPath() + "/backup_auto"
|
var ab models.AutoBackupConf
|
i, _ := ab.Select()
|
if i > 0 {
|
fmt.Println("go here 2 ", reqBody)
|
if reqBody.Update() {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "更新成功",
|
"data": reqBody,
|
})
|
} else {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "更新失败",
|
"data": nil,
|
})
|
}
|
} else {
|
fmt.Println("go here 3 ")
|
if reqBody.Insert() {
|
fmt.Println("go here 4 ")
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "保存成功",
|
"data": reqBody,
|
})
|
} else {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "保存失败",
|
"data": nil,
|
})
|
}
|
}
|
}
|
|
//立即备份操作
|
func BackupRN(c *gin.Context) {
|
var ab models.AutoBackupConf
|
i, e := ab.Select()
|
if i == 0 || e != nil {
|
ab.Dir = util.GetVamicroPath() + "/backup_auto"
|
}
|
err := service.DoAutoBackup(&ab)
|
if err != nil {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "立即备份失败:" + err.Error(),
|
"data": nil,
|
})
|
return
|
}
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "立即备份成功",
|
"data": nil,
|
})
|
}
|
|
//显示备份列表
|
func BackupList(c *gin.Context) {
|
var ab models.AutoBackupConf
|
i, e := ab.Select()
|
if i == 0 || e != nil {
|
ab.Dir = util.GetVamicroPath() + "/backup_auto/"
|
} else {
|
if !strings.HasSuffix(ab.Dir, "/") {
|
ab.Dir = ab.Dir + "/"
|
}
|
}
|
backList := make([]string, 0)
|
err := filepath.Walk(ab.Dir, func(src string, f os.FileInfo, err error) error {
|
if src == ab.Dir {
|
return nil
|
}
|
if f.IsDir() {
|
depth := strings.Count(src, "/") - strings.Count(ab.Dir, "/")
|
if depth != 0 {
|
return filepath.SkipDir
|
}
|
_, e := time.ParseInLocation("2006-01-02-15-04-05", f.Name(), time.Local)
|
if e != nil {
|
return e
|
}
|
backList = append(backList, f.Name())
|
}
|
return nil
|
})
|
|
if err != nil {
|
logger.Error("filepath.Walk ab.dir err:", err)
|
}
|
|
sort.Sort(sort.Reverse(sort.StringSlice(backList))) //降序排序
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "查询成功",
|
"data": backList,
|
})
|
}
|
|
//根据指定的还原节点进行还原操作
|
func BackupRecover(c *gin.Context) {
|
bakDir := c.PostForm("bakDir")
|
if bakDir == "" {
|
c.JSON(http.StatusBadRequest, gin.H{
|
"code": http.StatusBadRequest,
|
"msg": "参数有误，bakDir不能为空",
|
"data": nil,
|
})
|
return
|
}
|
var ab models.AutoBackupConf
|
i, e := ab.Select()
|
if i == 0 || e != nil {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "备份设置为空",
|
"data": nil,
|
})
|
return
|
}
|
fd := ab.Dir + "/" + bakDir
|
if !util.DirExists(fd) {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "当前备份文件夹已不存在,请检查",
|
"data": nil,
|
})
|
return
|
}
|
//执行还原操作
|
err := service.DoBackupRecover(fd)
|
if err != nil {
|
c.JSON(http.StatusInternalServerError, gin.H{
|
"code": http.StatusInternalServerError,
|
"msg": "还原失败:" + err.Error(),
|
"data": nil,
|
})
|
} else {
|
c.JSON(http.StatusOK, gin.H{
|
"code": http.StatusOK,
|
"msg": "还原成功",
|
"data": nil,
|
})
|
}
|
}
|
