locking-kit-server/handler/http_handler.go

package handler

import (
	"bytes"
	"crypto/md5"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"locking-kit-server/consts"
	"locking-kit-server/db"
	"locking-kit-server/env"
	"locking-kit-server/utils"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

/**
 * @author yuanrh
 * @description http服务核心逻辑
 * @date 2021/6/28 11:11
 **/

//@title 同步文件夹至工作空间
//@param ids 项目id，逗号分隔
func SyncFolderToWorkSpace(w http.ResponseWriter, r *http.Request){

	//参数解析
	defer r.Body.Close()
	data := r.URL.Query()
	ids := strings.Split(data.Get("ids"),",")
	if len(ids) == 0{
		fmt.Fprintln(w, utils.BuildFail("ids为必填参数"))
		return
	}

	//遍历文件夹
	for _, id := range ids {
		//查询文件列表
		task,err := postQueryArchiveListByProjectId(id)
		if err !=nil{
			fmt.Fprintln(w, utils.BuildFail("同步失败!"))
			return
		}

		//添加同步任务
		err = batchInsertTask(task)
		if err !=nil{
			fmt.Fprintln(w, utils.BuildFail("同步失败!"))
			return
		}
	}

	fmt.Fprintln(w, utils.BuildSuccess())
}

//批量插入同步任务
func batchInsertTask(task []interface{}) error{

	for _, archiveObj := range task {
		//key=userId:TASK_SYNC_STATUS_WAIT:taskId
		taskId := utils.GeneraatorId()
		addAttribute(archiveObj.(map[string] interface{}), taskId, consts.TASK_SYNC_STATUS_WAIT, 0)
		archiveByte,err := json.Marshal(archiveObj)
		if err !=nil{
			return err
		}
		// key -> /userid/TASK_SYNC/417367746536689664
		key := fmt.Sprintf("/%v%v%v",env.CurrentUserPhone, consts.ETCD_DIRECTOR_TASK_SYNC,taskId)
		err = db.ReplaceInto(key,string(archiveByte))
		if err !=nil{
			return err
		}

		//添加到下载队列
		TaskToDownloadChanel <- archiveObj.(map[string] interface{})
	}
	return nil
}

func addAttribute(archiveObj map[string] interface{}, taskId int64, taskSyncStatus string, progress float64){
	archiveObj[consts.TASK_ID] = taskId
	archiveObj[consts.TASK_SYNC_STATUS] = taskSyncStatus
	archiveObj[consts.TASK_SYNC_PROGRESS] = progress
}


//@title 文件/文件夹下载
//@param filePath 文件/文件夹路径
func DownloadFile(w http.ResponseWriter, r *http.Request){

	//参数解析
	defer r.Body.Close()
	data := r.URL.Query()
	filePath := data.Get("filePath")
	if len(filePath) == 0{
		fmt.Fprintln(w, utils.BuildFail("filePath为必填参数"))
		return
	}

	var task []interface{}
	var err error

	fileInfo,err := os.Stat(filePath)
	if err != nil{
		fmt.Fprintln(w, utils.BuildFail("filePath参数无效"))
		return
	}

	absFilePath := strings.Replace(filePath, env.WorkSpace, "", 1)
	blocks := strings.Split(absFilePath, string(os.PathSeparator))
	projectName := blocks[1]
	folderName := blocks[2]
	if fileInfo.IsDir() {
		relativePath := strings.Replace(absFilePath,  blocks[0]+string(os.PathSeparator)+projectName+string(os.PathSeparator)+folderName, "", 1)
		task, err = postQueryArchiveListByCondition(projectName, folderName, "", "", relativePath)
	}else{
		extension := strings.Replace(filepath.Ext(filePath), ".", "", 1)
		archName := strings.Replace(filepath.Base(filePath), filepath.Ext(filePath), "", 1)
		relativePath := strings.Replace(absFilePath, projectName+string(os.PathSeparator)+folderName, "", 1)
		relativePath = strings.Replace(relativePath, filepath.Base(filePath), "", 1)
		task, err = postQueryArchiveListByCondition(projectName, folderName, archName, extension, filepath.Clean(relativePath))
	}

	if err != nil{
		log.Printf("文件列表查询失败,%v", err)
		fmt.Fprintln(w, utils.BuildFail("同步失败!"))
		return
	}

	//添加同步任务
	err = batchInsertTask(task)
	if err !=nil{
		fmt.Fprintln(w, utils.BuildFail("同步失败!"))
		return
	}

	fmt.Fprintln(w, utils.BuildSuccess())
}

//根据项目Id查询所有文件列表
func postQueryArchiveListByProjectId(id string)(data []interface{},err error){

	url:=consts.SERVER_IP_PORT+"/api/pms/sdk/queryArchiveListByProjectId"

	var param struct{Id string; Digest string}
	param.Id = id

	//摘要
	text:=fmt.Sprintf("%v",param.Id)
	textByte := []byte(text)
	md5Byte := md5.Sum(textByte)
	digest := fmt.Sprintf("%x", md5Byte)
	param.Digest=digest
	jsonData,err :=json.Marshal(param)
	if  err!=nil{
		log.Printf("json序列化化错误！")
		return nil,err
	}

	resp, err := http.Post(url, consts.CONTENT_TYPE, bytes.NewReader(jsonData))
	if err != nil {
		log.Printf("post failed, err:%v\n", err)
		return nil,err
	}

	defer resp.Body.Close()
	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Printf("get resp failed,err:%v\n", err)
		return nil,err

	}
	returnValue := make(map[string] interface{})
	err=json.Unmarshal(b,&returnValue)
	if err!=nil{
		log.Printf("字符串%v反序列化出错", string(b[:]))
	}

	//成功
	if returnValue["Code"].(float64)==0{
		return returnValue["Data"].([] interface{}),nil
	}

	//失败
	return nil,errors.New(returnValue["Msg"].(string))
}

//根据条件查询所有文件列表
func postQueryArchiveListByCondition( projectName, folderName, archName, extension, relativePath string)(data []interface{},err error){

	url:=consts.SERVER_IP_PORT+"/api/pms/sdk/queryArchiveListByCondition"

	var param struct{ ProjectName, FolderName, ArchName, Extension, RelativePath, Digest string}
	param.ProjectName = projectName
	param.FolderName = folderName
	param.ArchName = archName
	param.Extension = extension
	param.RelativePath = relativePath

	//摘要
	text:=fmt.Sprintf("%v|%v|%v|%v|%v", param.ProjectName, param.FolderName, param.ArchName, param.Extension, param.RelativePath)
	textByte := []byte(text)
	md5Byte := md5.Sum(textByte)
	digest := fmt.Sprintf("%x", md5Byte)
	param.Digest=digest
	jsonData,err :=json.Marshal(param)
	if  err!=nil{
		log.Printf("json序列化化错误！")
		return nil,err
	}

	resp, err := http.Post(url, consts.CONTENT_TYPE, bytes.NewReader(jsonData))
	if err != nil {
		log.Printf("post failed, err:%v\n", err)
		return nil,err
	}

	defer resp.Body.Close()
	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Printf("get resp failed,err:%v\n", err)
		return nil,err

	}
	returnValue := make(map[string] interface{})
	err=json.Unmarshal(b,&returnValue)
	if err!=nil{
		log.Printf("字符串%v反序列化出错", string(b[:]))
	}

	//成功
	if returnValue["Code"].(float64)==0{
		return returnValue["Data"].([] interface{}),nil
	}

	//失败
	return nil,errors.New(returnValue["Msg"].(string))
}