add: 提交

lib/services/file.go

@@ -0,0 +1,356 @@
+package services
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"ems.agt/lib/log"
+)
+
+const (
+	RootPath      = "uploads/"
+	ChunkRootPath = "uploads_tmp/"
+)
+
+var (
+	// FilesMax 限制上传文件的大小为7 MB
+	FilesMax int64 = 32 << 20
+	// ValuesMax 限制POST字段内容的大小
+	ValuesMax int64 = 512
+)
+
+func GetPostFile(w http.ResponseWriter, r *http.Request) {
+	//获取文件流,第三个返回值是错误对象
+	file, header, _ := r.FormFile("file")
+	//读取文件流为[]byte
+	b, err := ioutil.ReadAll(file)
+	if err != nil {
+		log.Error("Failed to ReadAll:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	//把文件保存到指定位置
+	err = ioutil.WriteFile("./upload/test.zip", b, 0644)
+	if err != nil {
+		log.Error("Failed to WriteFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	//输出上传时文件名
+	log.Debug("filename:", header.Filename)
+}
+
+func GetUploadFile(w http.ResponseWriter, r *http.Request) {
+	log.Debug("GetUploadFile processing...")
+
+	file, err := os.Create("./test.zip")
+	if err != nil {
+		log.Error("Failed to Create:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	_, err = io.Copy(file, r.Body)
+	if err != nil {
+		log.Error("Failed to Copy:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+}
+
+func GetUploadFormFile(w http.ResponseWriter, r *http.Request) {
+	// 设置最大的内存限制为32MB
+	r.ParseMultipartForm(32 << 20)
+	file, handler, err := r.FormFile("file")
+	if err != nil {
+		log.Error("Failed to FormFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	defer file.Close()
+	log.Debug("Header:%v", handler.Header)
+	f, err := os.OpenFile("./"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
+	if err != nil {
+		log.Error("Failed to OpenFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	defer f.Close()
+	_, err = io.Copy(f, file)
+	if err != nil {
+		log.Error("Failed to Copy:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	log.Debug("File uploaded successfully:", handler.Filename)
+}
+
+func HandleUploadFile(r *http.Request, path, newFileName string) (string, error) {
+	var filePath, fileName string
+	reader, err := r.MultipartReader()
+	if err != nil {
+		log.Error("Failed to MultipartReader:", err)
+		return "", err
+	}
+
+	for {
+		part, err := reader.NextPart()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			log.Error("Failed to NextPart:", err)
+			return "", err
+		}
+
+		log.Debugf("FileName=[%s], FormName=[%s]", part.FileName(), part.FormName())
+		if part.FileName() == "" { // this is FormData
+			data, _ := ioutil.ReadAll(part)
+			log.Debugf("FormData=[%s]", string(data))
+		} else { // This is FileData
+
+			if newFileName != "" {
+				fileName = newFileName
+			} else {
+				fileName = part.FileName()
+			}
+
+			err := os.MkdirAll(path, os.ModePerm)
+			if err != nil {
+				log.Error("Failed to Mkdir:", err)
+				return "", err
+			}
+
+			filePath = path + "/" + fileName
+
+			file, err := os.Create(filePath)
+			if err != nil {
+				log.Error("Failed to Create:", err)
+				return "", err
+			}
+			defer file.Close()
+			_, err = io.Copy(file, part)
+			if err != nil {
+				log.Error("Failed to Copy:", err)
+				return "", err
+			}
+		}
+	}
+	return fileName, nil
+}
+
+func HandleUploadFormFile(w http.ResponseWriter, r *http.Request) {
+	r.ParseMultipartForm(32 << 20)
+	//mForm := r.MultipartForm
+
+	for k, _ := range r.MultipartForm.File {
+		// k is the key of file part
+		file, fileHeader, err := r.FormFile(k)
+		if err != nil {
+			fmt.Println("inovke FormFile error:", err)
+			return
+		}
+		defer file.Close()
+		fmt.Printf("the uploaded file: name[%s], size[%d], header[%#v]\n",
+			fileHeader.Filename, fileHeader.Size, fileHeader.Header)
+
+		// store uploaded file into local path
+		localFileName := "./upload/" + fileHeader.Filename
+		out, err := os.Create(localFileName)
+		if err != nil {
+			fmt.Printf("failed to open the file %s for writing", localFileName)
+			return
+		}
+		defer out.Close()
+		_, err = io.Copy(out, file)
+		if err != nil {
+			fmt.Printf("copy file err:%s\n", err)
+			return
+		}
+		fmt.Printf("file %s uploaded ok\n", fileHeader.Filename)
+	}
+}
+
+func PostFileHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("PostFileHandler processing... ")
+	if !strings.Contains(r.Header.Get("Content-Type"), "multipart/form-data") {
+		// 不支持的 Content-Type 类型
+		fmt.Println("Invalid Content-Type: ", r.Header.Get("Content-Type"))
+		http.Error(w, " 不支持的 Content-Type 类型", http.StatusBadRequest)
+		return
+	}
+
+	// 整个请求的主体大小设置为7.5Mb
+	r.Body = http.MaxBytesReader(w, r.Body, FilesMax+ValuesMax)
+	reader, err := r.MultipartReader()
+	if err != nil {
+		fmt.Println(err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	for {
+		// A Part represents a single part in a multipart body.
+		part, err := reader.NextPart()
+		if err != nil {
+			if err == io.EOF {
+
+				break
+			}
+
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		fileName := part.FileName()
+		formName := part.FormName()
+		var buf = &bytes.Buffer{}
+		// 非文件字段部分大小限制验证（非文件字段，go中filename会是空）
+		if fileName == "" {
+			var limitError = "请求主体中非文件字段" + formName + "超出大小限制"
+			err = uploadSizeLimit(buf, part, ValuesMax, limitError)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			continue
+		}
+
+		// 文件字段部分大小限制验证
+		var limitError = "请求主体中文件字段" + fileName + "超出大小限制"
+		err = uploadSizeLimit(buf, part, FilesMax, limitError)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// 文件创建部分
+		if err := uploadFileHandle(r.Header, fileName, buf); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// 非逻辑内容，仅为测试使用
+		var chunkNumber = r.Header.Get("chunk-number")
+		if chunkNumber == "" {
+			http.Error(w, "文件"+fileName+"上传成功", http.StatusOK)
+		} else {
+			http.Error(w, "分片文件"+fileName+chunkNumber+"上传成功", http.StatusOK)
+		}
+	}
+	return
+
+	http.NotFound(w, r)
+}
+
+// 上传内容大小限制
+func uploadSizeLimit(buf *bytes.Buffer, part *multipart.Part, maxLimit int64, limitError string) error {
+	n, err := io.CopyN(buf, part, maxLimit+1)
+	if err != nil && err != io.EOF {
+		fmt.Println("PostFileHandler:", err)
+		return err
+	}
+	maxLimit -= n
+	if maxLimit < 0 {
+		return errors.New(limitError)
+	}
+	return nil
+}
+
+// uploadFileHandle handle upload file
+func uploadFileHandle(header http.Header, fileName string, buf *bytes.Buffer) error {
+	var chunkNumberStr = header.Get("chunk-number")
+	// 1.普通文件上传处理
+	if chunkNumberStr == "" {
+		//创建文件并写入文件内容
+		return createFile(RootPath+fileName, buf.Bytes())
+	}
+	// 2.分片文件上传处理
+	//2.1读取分片编号
+	chunkNumber, err := strconv.Atoi(chunkNumberStr)
+	if err != nil {
+		return err
+	}
+	//2.2创建分片文件并写入分片内容
+	if err := createFile(fmt.Sprintf(ChunkRootPath+fileName+"%d.chunk", chunkNumber), buf.Bytes()); err != nil {
+		return err
+	}
+	//2.3确认是否上传完毕
+	if header.Get("chunk-final") == "true" {
+		//2.4合并文件
+		if err := mergeChunkFiles(fileName); err != nil {
+			return err
+		}
+		//2.5删除分片
+		for i := 0; ; i++ {
+			chunFileName := fmt.Sprintf(ChunkRootPath+fileName+"%d.chunk", i)
+			err := os.Remove(chunFileName)
+			if err != nil {
+				if os.IsNotExist(err) {
+					break
+				}
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// 创建文件并写入内容
+func createFile(fileName string, res []byte) error {
+	newFile, err := os.Create(fileName)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = newFile.Close()
+	}()
+	bufferedWriter := bufio.NewWriter(newFile)
+	_, err = bufferedWriter.Write(res)
+	if err != nil && err != io.EOF {
+		return err
+	}
+	return bufferedWriter.Flush()
+}
+
+// 合并分片文件
+func mergeChunkFiles(fileName string) error {
+	var (
+		n   int64
+		err error
+	)
+	finalFile, err := os.Create(RootPath + fileName)
+	if err != nil {
+		return err
+	}
+	defer finalFile.Close()
+	// 将分片内容写入最终文件
+	for i := 0; ; i++ {
+		chunFile, err := os.Open(fmt.Sprintf(ChunkRootPath+fileName+"%d.chunk", i))
+		if err != nil {
+			if os.IsNotExist(err) {
+				break
+			}
+			return err
+		}
+		n, err = io.Copy(finalFile, chunFile)
+		if err != nil {
+			return err
+		}
+		err = chunFile.Close()
+		if err != nil {
+			return err
+		}
+		if n < 1 {
+			break
+		}
+	}
+	return nil
+}

lib/services/requset.go

@@ -0,0 +1,45 @@
+package services
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+
+	"ems.agt/lib/global"
+)
+
+// 读取json请求结构团体
+func JSONBody(r *http.Request, args any) error {
+	body, err := io.ReadAll(io.LimitReader(r.Body, global.RequestBodyMaxLen))
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(body, args)
+	return err
+}
+
+// Get 查詢分頁值
+func GetPageNumSize(r *http.Request) (int, int) {
+	pageNumStr := r.URL.Query().Get("pageNum")
+	num := 1
+	if v, err := strconv.Atoi(pageNumStr); err == nil && v > 0 {
+		if v >= 100 {
+			num = 100
+		} else {
+			num = v
+		}
+	}
+
+	pageSizeStr := r.URL.Query().Get("pageSize")
+	size := 0
+	if v, err := strconv.Atoi(pageSizeStr); err == nil && v > 0 {
+		if v >= 60 {
+			size = 60
+		} else {
+			size = v
+		}
+	}
+
+	return num, size
+}

lib/services/services.go

@@ -0,0 +1,936 @@
+package services
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+
+	//	"log"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"ems.agt/lib/dborm"
+	"ems.agt/lib/global"
+	"ems.agt/lib/log"
+	"ems.agt/lib/oauth"
+	"ems.agt/restagent/config"
+	"github.com/gorilla/mux"
+)
+
+type NameValue struct {
+	Name  string
+	Value string
+}
+
+type NameOid struct {
+	Name string
+	Oid  string
+}
+
+type DataResponse struct {
+	Data interface{} `json:"data"`
+}
+
+type NullResponse struct {
+	nil interface{}
+}
+
+type ErrorResponse struct {
+	Error interface{} `json:"error"`
+}
+
+type ErrorMessage struct {
+	ErrorCode string `json:"errorCode"`
+	ErrorInfo string `json:"errorInfo"`
+}
+
+type SucceedOAuthResponse struct {
+	AccessToken string `json:"accessToken"`
+	Expires     string `json:"expires"`
+	// Enum: "0": 不需要修改密码, "1": "FirstLogin",首次登录, "2": PasswordAboutToExpire, 密码即将过期
+	ChangePasswordFlag int    `json:"changePasswordFlag"`
+	GroupName          string `json:"groupName"`
+}
+
+type ServiceResponse struct {
+}
+
+func GetUriParamString(r *http.Request, paramName string, sep string, brackets bool, apostr bool) string {
+	vars := r.URL.Query()
+	s, ok := vars[paramName]
+	if !ok {
+		log.Infof("Parameter Name is not exist, %s", paramName)
+		return ""
+	}
+	if apostr {
+		for i := 0; i < len(s); i++ {
+			s[i] = "'" + s[i] + "'"
+		}
+	}
+	pn := strings.Join(s, sep)
+	if brackets {
+		pn = fmt.Sprintf("(%s)", pn)
+	}
+
+	return pn
+}
+
+func GetUriWhereString(r *http.Request) string {
+	return GetUriParamString(r, "WHERE", " and ", false, false)
+}
+
+func GetUriLocString(r *http.Request) string {
+	return GetUriParamString(r, "loc", " and ", false, false)
+}
+
+func GetUriPageLimitString(r *http.Request) string {
+	vars := r.URL.Query()
+	p, ok := vars["PAGE"]
+	if !ok {
+		log.Info("page param is not exist")
+		return ""
+	}
+
+	l, ok := vars["LIMIT"]
+	if !ok {
+		log.Info("limit param is not exist")
+		return ""
+	}
+	li, _ := strconv.Atoi(l[0])
+	pi, _ := strconv.Atoi(p[0])
+	ls := fmt.Sprintf("limit %d, %d", li*(pi-1), li)
+
+	log.Debug("Limit array:", ls)
+	return ls
+}
+
+func ExtGetUriPageLimitString(r *http.Request) string {
+	vars := r.URL.Query()
+	p, ok := vars["page"]
+	if !ok {
+		log.Info("page param is not exist")
+		p = append(p, "1")
+	}
+
+	l, ok := vars["limit"]
+	if !ok {
+		log.Info("limit param is not exist")
+		l = append(l, strconv.Itoa(global.MaxLimitData))
+	}
+	limit, _ := strconv.Atoi(l[0])
+	if limit > global.MaxLimitData {
+		limit = global.MaxLimitData
+	}
+	page, _ := strconv.Atoi(p[0])
+	limitStr := fmt.Sprintf("limit %d, %d", limit*(page-1), limit)
+
+	log.Debug("limitStr:", limitStr)
+	return limitStr
+}
+
+func IsJsonContentType(r *http.Request) bool {
+	if strings.Contains(r.Header.Get("Content-Type"), "application/json") {
+		return true
+	}
+	return false
+}
+
+func IsValidOAuthUri(r *http.Request) bool {
+	vars := mux.Vars(r)
+	apiVer := vars["apiVersion"] // 获取Uri
+	if apiVer != "v1" {
+		return false
+	}
+
+	return true
+}
+
+func IsVallidContentType(r *http.Request, checkFlag bool) bool {
+	log.Debug("IsVallidContentType processing ...")
+	/*
+		ctype := r.Header["Content-Type"]
+		log.Debug("ctype:", ctype)
+		if len(ctype) != 0 && !strings.Contains(ctype[0], "application/json") {
+			return false
+		}
+	*/
+	if strings.Contains(r.Header.Get("Content-Type"), "application/json") || checkFlag == false {
+		return true
+	}
+	return false
+}
+
+func CheckParameterName(r *http.Request) []string {
+	var errorParams []string
+	vars := r.URL.Query()
+	for k, v := range vars {
+		log.Debug("vars:", k, v)
+		if k != "rmUIDs" && k != "fields" {
+			errorParams = append(errorParams, k)
+		}
+	}
+
+	return errorParams
+}
+
+func GetRmUIDArr(r *http.Request) []string {
+	vars := r.URL.Query()
+	rmUIDs, ok := vars["rmUIDs"]
+	if !ok {
+		log.Info("rmUIDs is not exist")
+		return nil
+	}
+
+	var rmUIDValues []string
+	for _, r := range rmUIDs {
+		if r != "" {
+			rmUIDValues = global.MergeStringArr(rmUIDValues, strings.Split(r, `,`))
+		}
+	}
+
+	return rmUIDValues
+}
+
+func GetAttrNameArr(r *http.Request) []string {
+	vars := r.URL.Query()
+	fields, ok := vars["fields"]
+	if !ok {
+		log.Info("attributeNames does not exist")
+		return nil
+	}
+	var attrNames []string
+	for _, a := range fields {
+		if a != "" {
+			attrNames = global.MergeStringArr(attrNames, strings.Split(a, `,`))
+		}
+	}
+
+	return attrNames
+}
+
+func CheckValidRmUID(rmUIDs []string) []string {
+	log.Debug("CheckValidRmUID processing... ")
+
+	var invalidRmUIDs []string
+	for _, r := range rmUIDs {
+		if !global.MatchRmUID(config.GetRmUIDRegexpFromConfig(), r) {
+			invalidRmUIDs = append(invalidRmUIDs, r)
+		}
+	}
+
+	return invalidRmUIDs
+}
+
+func CheckLocalRmUID(rmUIDs []string) string {
+	log.Debug("GetLocalRmUID processing... ")
+
+	rmUID := config.GetRmUIDFromConfig()
+	for _, r := range rmUIDs {
+		if r == rmUID {
+			return rmUID
+		}
+	}
+
+	return ""
+}
+
+func GetParamsArrByName(paramName string, r *http.Request) []string {
+	vars := r.URL.Query()
+	pns, ok := vars[paramName]
+	if !ok {
+		log.Infof("%s is not exist", paramName)
+		return nil
+	}
+
+	var pnArr []string
+	for _, pn := range pns {
+		if pn != "" {
+			pnArr = global.MergeStringArr(pnArr, strings.Split(pn, `,`))
+		}
+	}
+
+	return pnArr
+}
+
+func GetOperationTypeFromHttpRequest(r *http.Request) string {
+	for k, v := range r.Header {
+		log.Tracef("k:%s, v:%s", k, v)
+		if strings.ToLower(k) == "operationtype" && len(v) != 0 {
+			log.Trace("OperationType:", v[0])
+			return v[0]
+		}
+	}
+
+	return ""
+}
+
+func CheckNorthboundValidRequest(w http.ResponseWriter, r *http.Request) (string, error) {
+	log.Debug("CheckNorthboundValidRequest processing... ")
+
+	var token string = ""
+	var err error
+	var ret bool
+	// response 414-4 uri too long ? (optional)
+	// todo ... ?
+	if bytes.Count([]byte(r.RequestURI), nil) > config.GetUriMaxLenFromConfig() {
+		log.Error("Request Uri too long:", bytes.Count([]byte(r.RequestURI), nil), config.GetUriMaxLenFromConfig())
+		ResponseRequestURITooLong414UriTooLong(w)
+		return token, err
+	}
+
+	// check media type(content type) only support "application/json"
+	// response 415-1
+	if !IsJsonContentType(r) {
+		log.Error("Invalid Content-Type")
+		ResponseUnsupportedMediaType415(w)
+		return token, err
+	}
+
+	// error processing ...
+	// 401-1 response
+	token, ret = oauth.IsCarriedToken(r)
+	if ret == false {
+		log.Error("AccessToken is not carried")
+		ResponseUnauthorized401AccessTokenNotCarried(w)
+		return token, err
+	}
+
+	// 401-2 response
+	if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
+		log.Error("AccessToken fails or does not exist")
+		ResponseUnauthorized401AccessTokenNotExist(w)
+		return token, err
+	}
+
+	if operType := GetOperationTypeFromHttpRequest(r); operType != "auto" {
+		_, err = dborm.XormUpdateSessionShakeTime(token)
+		if err != nil {
+			log.Error("Failed to update session table:", err)
+			ResponseUnauthorized401AccessTokenNotExist(w)
+			return token, err
+		}
+	}
+
+	vars := mux.Vars(r)
+	apiVer := vars["apiVersion"]
+	if apiVer != global.ApiVersionV1 {
+		log.Error("Uri is invalid")
+		ResponseNotFound404UriNotExist(w, r)
+		return token, err
+	}
+
+	// response 406-1
+	rmUIDValues := GetRmUIDArr(r)
+	if rmUIDValues == nil {
+		log.Error("missing parameter: rmUIDs")
+		ResponseNotAcceptable406MissingParam(w)
+		return token, err
+	}
+
+	// response 406-2
+	errorParams := CheckParameterName(r)
+	if errorParams != nil {
+		log.Error("parameter name error: ", errorParams)
+		ResponseNotAcceptable406ParamError(w, errorParams)
+		return token, err
+	}
+
+	// response 400-5
+	if len(rmUIDValues) == 0 {
+		log.Error("rmUIDs is wrong or NULL")
+		ResponseBadRequest400WrongParamValue(w)
+		return token, err
+	}
+
+	// response 414-1
+	if len(rmUIDValues) > config.GetYamlConfig().Params.RmUIDMaxNum {
+		log.Error("rmUID greater than", config.GetYamlConfig().Params.RmUIDMaxNum)
+		ResponseRequestURITooLong414NRMNumExceed(w, config.GetYamlConfig().Params.RmUIDMaxNum)
+		return token, err
+	}
+
+	return token, nil
+}
+
+func CheckCommonValidRequest(w http.ResponseWriter, r *http.Request) (string, error) {
+	log.Debug("CheckCommonValidRequest processing... ")
+
+	var token string = ""
+	var err error
+	var ret bool
+	// response 414-4 uri too long ? (optional)
+	// todo ... ?
+	if bytes.Count([]byte(r.RequestURI), nil) > config.GetUriMaxLenFromConfig() {
+		log.Error("Request Uri too long:", bytes.Count([]byte(r.RequestURI), nil), config.GetUriMaxLenFromConfig())
+		ResponseRequestURITooLong414UriTooLong(w)
+		return token, err
+	}
+
+	// check media type(content type) only support "application/json"
+	// response 415-1
+	if !IsJsonContentType(r) {
+		log.Error("Invalid Content-Type")
+		ResponseUnsupportedMediaType415(w)
+		return token, err
+	}
+
+	// error processing ...
+	// 401-1 response
+	token, ret = oauth.IsCarriedToken(r)
+	if ret == false {
+		log.Error("AccessToken is not carried")
+		ResponseUnauthorized401AccessTokenNotCarried(w)
+		return token, err
+	}
+
+	// 401-2 response
+	if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
+		log.Error("AccessToken fails or does not exist")
+		ResponseUnauthorized401AccessTokenNotExist(w)
+		return token, err
+	}
+
+	if operType := GetOperationTypeFromHttpRequest(r); operType != "auto" {
+		_, err = dborm.XormUpdateSessionShakeTime(token)
+		if err != nil {
+			log.Error("Failed to update session table:", err)
+			ResponseUnauthorized401AccessTokenNotExist(w)
+			return token, err
+		}
+	}
+
+	vars := mux.Vars(r)
+	apiVer := vars["apiVersion"]
+	if apiVer != global.ApiVersionV1 {
+		log.Error("Uri is invalid")
+		ResponseNotFound404UriNotExist(w, r)
+		return token, err
+	}
+
+	return token, nil
+}
+
+func IsLocalhost(host string) bool {
+	if strings.Contains(host, "127.0.0.1") || strings.Contains(host, "::1") {
+		return true
+	}
+	return false
+}
+
+func CheckFrontValidRequest(w http.ResponseWriter, r *http.Request) (string, error) {
+	log.Debug("CheckFrontValidRequest processing... ")
+
+	var token string = ""
+	var err error
+	var ret bool
+	// response 414-4 uri too long ? (optional)
+	// todo ... ?
+	if bytes.Count([]byte(r.RequestURI), nil) > config.GetUriMaxLenFromConfig() {
+		err = errors.New("Request Uri too long")
+		log.Errorf("Request Uri too long: bytes=%d, MaxLen=%d", bytes.Count([]byte(r.RequestURI), nil), config.GetUriMaxLenFromConfig())
+		ResponseRequestURITooLong414UriTooLong(w)
+		return token, err
+	}
+
+	/*
+		// check media type(content type) only support "application/json"
+		// response 415-1
+		if !IsVallidContentType(r) {
+			err := errors.New("Invalid Content-Type")
+			log.Error(err)
+			ResponseUnsupportedMediaType415(w)
+			return err
+		}
+	*/
+
+	// error processing ...
+	// 401-1 response
+	if config.GetYamlConfig().Auth.Token && IsLocalhost(r.RemoteAddr) == false {
+		token, ret = oauth.IsCarriedToken(r)
+		if ret == false {
+			err = errors.New("AccessToken is not carried")
+			log.Error(err)
+			ResponseUnauthorized401AccessTokenNotCarried(w)
+			return token, err
+		}
+
+		// 401-2 response
+		if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
+			err = errors.New("AccessToken fails or does not exist")
+			log.Error(err)
+			ResponseUnauthorized401AccessTokenNotExist(w)
+			return token, err
+		}
+
+		if operType := GetOperationTypeFromHttpRequest(r); operType != "auto" {
+			_, err = dborm.XormUpdateSessionShakeTime(token)
+			if err != nil {
+				log.Error("Failed to update session table:", err)
+				ResponseUnauthorized401AccessTokenNotExist(w)
+				return token, err
+			}
+		}
+
+	}
+
+	/*
+		// response 403 Forbidden, permissions deny
+		// todo...
+		plist := globalSession.GetPermissionFromSession(token)
+		log.Debug("permission list:", plist)
+		if len(plist) == 0 || plist[0] == false {
+			log.Debug("User permission deny")
+			ResponseForbidden403NotPermission(w)
+			return
+		}
+	*/
+	vars := mux.Vars(r)
+	apiVer := vars["apiVersion"]
+	if apiVer != global.ApiVersionV1 {
+		err = errors.New("Uri is invalid")
+		log.Error(err)
+		ResponseNotFound404UriNotExist(w, r)
+		return token, err
+	}
+
+	return token, nil
+}
+
+func CheckExtValidRequest(w http.ResponseWriter, r *http.Request) (string, error) {
+	log.Debug("CheckExtValidRequest processing... ")
+
+	var token string = ""
+	var err error
+	var ret bool
+	// error processing ...
+	// 401-1 response
+	if config.GetYamlConfig().Auth.Token {
+		token, ret = oauth.IsCarriedToken(r)
+		if ret == false {
+			err = errors.New("AccessToken is not carried")
+			log.Error(err)
+			ResponseUnauthorized401AccessTokenNotCarried(w)
+			return token, err
+		}
+
+		// 401-2 response
+		if dborm.XormExistValidToken(token, config.GetExpiresFromConfig()) == false {
+			err = errors.New("AccessToken fails or does not exist")
+			log.Error(err)
+			ResponseUnauthorized401AccessTokenNotExist(w)
+			return token, err
+		}
+
+		if operType := GetOperationTypeFromHttpRequest(r); operType != "auto" {
+			_, err = dborm.XormUpdateSessionShakeTime(token)
+			if err != nil {
+				log.Error("Failed to update session table:", err)
+				ResponseUnauthorized401AccessTokenNotExist(w)
+				return token, err
+			}
+		}
+	}
+
+	vars := mux.Vars(r)
+	apiVer := vars["apiVersion"]
+	if apiVer != global.ApiVersionV1 {
+		err = errors.New("Uri is invalid")
+		log.Error(err)
+		ResponseNotFound404UriNotExist(w, r)
+		return token, err
+	}
+
+	return token, nil
+}
+
+func ResponseStatusOK200Login(w http.ResponseWriter, token string, user *dborm.User) {
+	var oAuthResponse SucceedOAuthResponse
+	oAuthResponse.AccessToken = token
+	oAuthResponse.Expires = strconv.Itoa((int)(config.GetExpiresFromConfig()))
+	oAuthResponse.ChangePasswordFlag = user.ChangePasswordFlag
+	oAuthResponse.GroupName = user.GroupName
+	ResponseWithJson(w, http.StatusOK, oAuthResponse)
+}
+
+func ResponseStatusOK200Null(w http.ResponseWriter) {
+	response := NullResponse{""}
+	ResponseWithJson(w, http.StatusOK, response)
+}
+
+func ResponseStatusOK204NoContent(w http.ResponseWriter) {
+	ResponseWithJson(w, http.StatusNoContent, "")
+}
+
+func ResponseRedirect(w http.ResponseWriter, redirectUrl string) {
+	w.Header().Set("Cache-Control", "must-revalidate, no-store")
+	w.Header().Set("Content-Type", " text/html;charset=UTF-8")
+	w.Header().Set("Location", redirectUrl)     //跳转地址设置
+	w.WriteHeader(http.StatusTemporaryRedirect) //重定向！
+}
+
+func ResponseBadRequest400RmUIDsIsInvalid(w http.ResponseWriter, rmUIDs []string) {
+	errorMessage := ErrorMessage{"1", "rmUIDs is invalid:" + strings.Join(rmUIDs, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400DuplicateSubId(w http.ResponseWriter, SubIds string) {
+	errorMessage := ErrorMessage{"2", "Duplicate with resource subscription id:" + SubIds}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400DuplicateAlarmId(w http.ResponseWriter, AlarmIds string) {
+	errorMessage := ErrorMessage{"3", "Duplicate with alarm subscription id: " + AlarmIds}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400IncorrectLogin(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"4", "Incorrect username and password"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400WrongParamValue(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"5", "Wrong parameter value"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400CMCALoginError(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"6", "CMCA centralized authentication login error"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusBadRequest, errorResponse)
+}
+
+func ResponseBadRequest400InvalidJson(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"7", "Invalid json format"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
+}
+
+func ResponseUnauthorized401AccessTokenNotCarried(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "AccessToken is not carried"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
+}
+
+func ResponseUnauthorized401AccessTokenNotExist(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"2", "AccessToken fails or does not exist"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusUnauthorized, errorResponse)
+}
+
+func ResponseForbidden403NotPermission(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "Do not have the operation permissions"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusForbidden, errorResponse)
+}
+
+func ResponseForbidden403MultiLoginNotAllowed(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"2", "Multiple logins are not allowed"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusForbidden, errorResponse)
+}
+
+func ResponseNotFound404UriNotExist(w http.ResponseWriter, r *http.Request) {
+	errorMessage := ErrorMessage{"1", "The requested URI does not exist"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404UriNotExistExt(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "The requested URI does not exist"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func CustomResponseNotFound404Handler() http.Handler {
+	return http.HandlerFunc(ResponseNotFound404UriNotExist)
+}
+
+func ResponseNotFound404NRMNotExist(w http.ResponseWriter, rmUIDs []string) {
+	errorMessage := ErrorMessage{"2", "rmUIDs does not exist: " + strings.Join(rmUIDs, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404PMNotExist(w http.ResponseWriter, rmUIDs []string) {
+	errorMessage := ErrorMessage{"3", "rmUIDs does not exist: " + strings.Join(rmUIDs, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404AlarmNotExist(w http.ResponseWriter, AlarmIds []string) {
+	errorMessage := ErrorMessage{"4", "AlarmIds does not exist: " + strings.Join(AlarmIds, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404GetSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
+	errorMessage := ErrorMessage{"5", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404DeleteSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
+	errorMessage := ErrorMessage{"6", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404GetAlarmSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
+	errorMessage := ErrorMessage{"7", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseNotFound404DeleteAlarmSubscriptionNotExist(w http.ResponseWriter, SubIds []string) {
+	errorMessage := ErrorMessage{"8", "Subscription id does not exist: " + strings.Join(SubIds, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotFound, errorResponse)
+}
+
+func ResponseMethodNotAllowed405(w http.ResponseWriter, r *http.Request) {
+	errorMessage := ErrorMessage{"1", "Method not allowed"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusMethodNotAllowed, errorResponse)
+}
+
+func CustomResponseMethodNotAllowed405Handler() http.Handler {
+	return http.HandlerFunc(ResponseMethodNotAllowed405)
+}
+
+func ResponseNotAcceptable406MissingParam(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "Missing parameter: rmUIDs"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
+}
+
+func ResponseNotAcceptable406ParamError(w http.ResponseWriter, errorParamsName []string) {
+	errorMessage := ErrorMessage{"2", "Parameter name error: " + strings.Join(errorParamsName, ",")}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
+}
+
+func ResponseNotAcceptable406QuerySQLError(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"3", "Wrong or non-query SQL statement"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusNotAcceptable, errorResponse)
+}
+
+func ResponseRequestEntityTooLarge413SubscriptionExceed(w http.ResponseWriter, num int) {
+	errorMessage := ErrorMessage{"1", "The number of subscriptions greater than " + strconv.Itoa(num)}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestEntityTooLarge, errorResponse)
+}
+
+func ResponseRequestEntityTooLarge413BodyToLarge(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"2", "The request entity too large"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestEntityTooLarge, errorResponse)
+}
+
+func ResponseRequestURITooLong414NRMNumExceed(w http.ResponseWriter, num int) {
+	errorMessage := ErrorMessage{"1", "The number of NRM rmUIDs greater than " + strconv.Itoa(num)}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
+}
+
+func ResponseRequestURITooLong414AlarmNumExceed(w http.ResponseWriter, num int) {
+	errorMessage := ErrorMessage{"2", "The number of alarmIds greater than " + strconv.Itoa(num)}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
+}
+
+func ResponseRequestURITooLong414PMNumExceed(w http.ResponseWriter, num int) {
+	errorMessage := ErrorMessage{"3", "The number of PM rmUIDs greater than " + strconv.Itoa(num)}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
+}
+
+func ResponseRequestURITooLong414UriTooLong(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"3", "Request URI too long"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusRequestURITooLong, errorResponse)
+}
+
+func ResponseUnsupportedMediaType415(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "Unsupported media type"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusUnsupportedMediaType, errorResponse)
+}
+
+func ResponseInternalServerError500NFConnectRefused(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"1", "Internal server error, NF connnect refused"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
+}
+
+func ResponseInternalServerError500DatabaseOperationFailed(w http.ResponseWriter) {
+	errorMessage := ErrorMessage{"2", "Internal server error, database opration failed"}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
+}
+
+func ResponseInternalServerError500ProcessError(w http.ResponseWriter, err error) {
+	em := fmt.Sprintf("Internal server error: %v", err)
+	errorMessage := ErrorMessage{"3", em}
+	errorResponse := ErrorResponse{errorMessage}
+	ResponseWithJson(w, http.StatusInternalServerError, errorResponse)
+}
+
+func ResponseWithJson(w http.ResponseWriter, code int, payload interface{}) {
+	log.Trace("payload: ", payload)
+
+	response, _ := json.Marshal(payload)
+	SetResponseHeader(w)
+	w.WriteHeader(code)
+	w.Write(response)
+	log.Trace("Response Code:", code)
+	log.Trace("Response Body:", string(response))
+}
+
+func ResponseWithZip(w http.ResponseWriter, payload interface{}) {
+	response, _ := json.Marshal(payload)
+	SetResponseHeader(w)
+	w.WriteHeader(http.StatusOK)
+	w.Write(response)
+	log.Trace("Response Body:", string(response))
+}
+
+func TransportResponse(w http.ResponseWriter, code int, payload []byte) {
+	var tempBody, transBody interface{}
+	switch code {
+	case http.StatusOK, http.StatusCreated, http.StatusNoContent, http.StatusAccepted:
+		json.Unmarshal(payload, &tempBody)
+		transBody = DataResponse{tempBody}
+	default:
+		json.Unmarshal(payload, &tempBody)
+		transBody = ErrorResponse{tempBody}
+	}
+	response, _ := json.Marshal(transBody)
+	log.Trace("transBody: ", transBody)
+	SetResponseHeader(w)
+	w.WriteHeader(code)
+	w.Write(response)
+	log.Trace("response: ", string(response))
+}
+
+func ResponseWithUnsortJson(w http.ResponseWriter, code int, payload map[string]interface{}) {
+	var om global.OrderedMap
+	om.Map = payload
+	response, _ := om.MarshalJson()
+	log.Trace("payload: ", payload)
+	SetResponseHeader(w)
+	w.WriteHeader(code)
+	w.Write(response)
+	log.Trace("response: ", string(response))
+}
+
+func ResponseErrorWithJson(w http.ResponseWriter, code int, nameValue interface{}) {
+	response := make(map[string]interface{})
+	response["error"] = nameValue
+	ResponseWithJson(w, code, response)
+}
+
+func SetCommonResponseHeader(w http.ResponseWriter) {
+	// To solve cross domain issue
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	//	w.Header().Set("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Methods", "*")
+	w.Header().Set("Access-Control-Allow-Headers", "*")
+	//	w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+	//	w.Header().Set("Access-Control-Allow-Headers", "AccessToken")
+	w.Header().Set("Access-Control-Expose-Headers", "Access-Control-Allow-Headers, Token")
+	w.Header().Set("Access-Control-Allow-Credentials", "true")
+}
+
+func SetResponseHeader(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "application/json;charset=UTF-8")
+	SetCommonResponseHeader(w)
+}
+
+// Creates a new file upload http request with optional extra params
+func ResponseUploadFile(w http.ResponseWriter, code int, params map[string]string, paramName, path string) {
+	file, err := os.Open(path)
+	if err != nil {
+		log.Errorf("Failed to open: %v", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
+	if err != nil {
+		log.Error("Failed to CreateFormFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	_, err = io.Copy(part, file)
+	if err != nil {
+		log.Error("Failed to Copy:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+
+	for key, val := range params {
+		_ = writer.WriteField(key, val)
+	}
+
+	err = writer.Close()
+	if err != nil {
+		log.Error("Failed to Close:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+
+	SetCommonResponseHeader(w)
+	w.Header().Set("Content-Type", writer.FormDataContentType())
+	w.WriteHeader(code)
+	w.Write(body.Bytes())
+	return
+}
+
+func ResponseFile(w http.ResponseWriter, code int, filePath string) {
+	fileBytes, err := os.ReadFile(filePath)
+	if err != nil {
+		log.Error("Failed to ReadFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	SetCommonResponseHeader(w)
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.WriteHeader(code)
+	w.Write(fileBytes)
+
+	return
+}
+
+func ResponseFileWithNameAndMD5(w http.ResponseWriter, code int, fileName, path, md5Sum string) {
+	filePath := path + "/" + fileName
+	fileBytes, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		log.Error("Failed to ReadFile:", err)
+		ResponseInternalServerError500ProcessError(w, err)
+		return
+	}
+	SetCommonResponseHeader(w)
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Header().Set("User-File", fileName)
+	w.Header().Set("MD5-Sum", md5Sum)
+	w.WriteHeader(code)
+	w.Write(fileBytes)
+
+	return
+}