From b48155c2498c07b343404a29e8afa4fd88261eb5 Mon Sep 17 00:00:00 2001 From: dudaodong Date: Sat, 19 Feb 2022 21:52:10 +0800 Subject: [PATCH] refactor: rename files *_util.go to *_internal.go --- cryptor/crypto_internal.go | 37 +++++++ formatter/formatter_internal.go | 40 +++++++ function/function_internal.go | 39 +++++++ netutil/net_internal.go | 186 ++++++++++++++++++++++++++++++++ slice/slice_internal.go | 65 +++++++++++ strutil/string_internal.go | 40 +++++++ 6 files changed, 407 insertions(+) create mode 100644 cryptor/crypto_internal.go create mode 100644 formatter/formatter_internal.go create mode 100644 function/function_internal.go create mode 100644 netutil/net_internal.go create mode 100644 slice/slice_internal.go create mode 100644 strutil/string_internal.go diff --git a/cryptor/crypto_internal.go b/cryptor/crypto_internal.go new file mode 100644 index 0000000..6005346 --- /dev/null +++ b/cryptor/crypto_internal.go @@ -0,0 +1,37 @@ +package cryptor + +import "bytes" + +func generateAesKey(key []byte) []byte { + genKey := make([]byte, 16) + copy(genKey, key) + for i := 16; i < len(key); { + for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 { + genKey[j] ^= key[i] + } + } + return genKey +} + +func generateDesKey(key []byte) []byte { + genKey := make([]byte, 8) + copy(genKey, key) + for i := 8; i < len(key); { + for j := 0; j < 8 && i < len(key); j, i = j+1, i+1 { + genKey[j] ^= key[i] + } + } + return genKey +} + +func pkcs7Padding(src []byte, blockSize int) []byte { + padding := blockSize - len(src)%blockSize + padText := bytes.Repeat([]byte{byte(padding)}, padding) + return append(src, padText...) +} + +func pkcs7UnPadding(src []byte) []byte { + length := len(src) + unPadding := int(src[length-1]) + return src[:(length - unPadding)] +} diff --git a/formatter/formatter_internal.go b/formatter/formatter_internal.go new file mode 100644 index 0000000..4928147 --- /dev/null +++ b/formatter/formatter_internal.go @@ -0,0 +1,40 @@ +package formatter + +import ( + "fmt" + "reflect" + "strconv" + "strings" +) + +func commaString(s string) string { + if len(s) <= 3 { + return s + } + return commaString(s[:len(s)-3]) + "," + commaString(s[len(s)-3:]) +} + +func numString(value interface{}) string { + switch reflect.TypeOf(value).Kind() { + case reflect.Int, reflect.Int64, reflect.Float32, reflect.Float64: + return fmt.Sprintf("%v", value) + case reflect.String: + { + sv := fmt.Sprintf("%v", value) + if strings.Contains(sv, ".") { + _, err := strconv.ParseFloat(sv, 64) + if err == nil { + return sv + } + } else { + _, err := strconv.ParseInt(sv, 10, 64) + if err == nil { + return sv + } + } + } + default: + return "" + } + return "" +} diff --git a/function/function_internal.go b/function/function_internal.go new file mode 100644 index 0000000..b819d95 --- /dev/null +++ b/function/function_internal.go @@ -0,0 +1,39 @@ +package function + +import ( + "fmt" + "reflect" +) + +func invokeFunc(fn interface{}, args ...interface{}) []reflect.Value { + fv := functionValue(fn) + params := make([]reflect.Value, len(args)) + for i, item := range args { + params[i] = reflect.ValueOf(item) + } + return fv.Call(params) +} + +func unsafeInvokeFunc(fn interface{}, args ...interface{}) []reflect.Value { + fv := reflect.ValueOf(fn) + params := make([]reflect.Value, len(args)) + for i, item := range args { + params[i] = reflect.ValueOf(item) + } + return fv.Call(params) +} + +func functionValue(function interface{}) reflect.Value { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } + return v +} + +func mustBeFunction(function interface{}) { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } +} diff --git a/netutil/net_internal.go b/netutil/net_internal.go new file mode 100644 index 0000000..de98f49 --- /dev/null +++ b/netutil/net_internal.go @@ -0,0 +1,186 @@ +package netutil + +import ( + "bytes" + "errors" + "fmt" + "io/ioutil" + "net/http" + "net/url" + "strings" +) + +func doHttpRequest(method, reqUrl string, params ...interface{}) (*http.Response, error) { + if len(reqUrl) == 0 { + return nil, errors.New("url should be specified") + } + + req := &http.Request{ + Method: method, + Header: make(http.Header), + Proto: "HTTP/1.1", + ProtoMajor: 1, + ProtoMinor: 1, + } + + client := &http.Client{} + err := setUrl(req, reqUrl) + if err != nil { + return nil, err + } + + switch len(params) { + case 1: + err = setHeader(req, params[0]) + if err != nil { + return nil, err + } + case 2: + err := setHeaderAndQueryParam(req, reqUrl, params[0], params[1]) + if err != nil { + return nil, err + } + case 3: + err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) + if err != nil { + return nil, err + } + case 4: + err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) + if err != nil { + return nil, err + } + client, err = getClient(params[3]) + if err != nil { + return nil, err + } + } + + resp, e := client.Do(req) + return resp, e +} + +func setHeaderAndQueryParam(req *http.Request, reqUrl string, header, queryParam interface{}) error { + err := setHeader(req, header) + if err != nil { + return err + } + err = setQueryParam(req, reqUrl, queryParam) + if err != nil { + return err + } + return nil +} + +func setHeaderAndQueryAndBody(req *http.Request, reqUrl string, header, queryParam, body interface{}) error { + err := setHeader(req, header) + if err != nil { + return err + } + err = setQueryParam(req, reqUrl, queryParam) + if err != nil { + return err + } + err = setBodyByte(req, body) + if err != nil { + return err + } + return nil +} + +func setHeader(req *http.Request, header interface{}) error { + if header != nil { + switch v := header.(type) { + case map[string]string: + for k := range v { + req.Header.Add(k, v[k]) + } + case http.Header: + for k, vv := range v { + for _, vvv := range vv { + req.Header.Add(k, vvv) + } + } + default: + return errors.New("header params type should be http.Header or map[string]string") + } + } + + if host := req.Header.Get("Host"); host != "" { + req.Host = host + } + + return nil +} + +func setUrl(req *http.Request, reqUrl string) error { + u, err := url.Parse(reqUrl) + if err != nil { + return err + } + req.URL = u + return nil +} + +func setQueryParam(req *http.Request, reqUrl string, queryParam interface{}) error { + var values url.Values + if queryParam != nil { + switch v := queryParam.(type) { + case map[string]interface{}: + values = url.Values{} + for k := range v { + values.Set(k, fmt.Sprintf("%v", v[k])) + } + case url.Values: + values = v + default: + return errors.New("query params type should be url.Values or map[string]interface{}") + } + } + + // set url + if values != nil { + if !strings.Contains(reqUrl, "?") { + reqUrl = reqUrl + "?" + values.Encode() + } else { + reqUrl = reqUrl + "&" + values.Encode() + } + } + u, err := url.Parse(reqUrl) + if err != nil { + return err + } + req.URL = u + + return nil +} + +func setBodyByte(req *http.Request, body interface{}) error { + if body != nil { + var bodyByte []byte + if body != nil { + switch v := body.(type) { + case []byte: + bodyByte = v + default: + return errors.New("body type should be []byte") + } + } + req.Body = ioutil.NopCloser(bytes.NewReader(bodyByte)) + } + return nil +} + +func getClient(client interface{}) (*http.Client, error) { + c := http.Client{} + if client != nil { + switch v := client.(type) { + case http.Client: + c = v + default: + return nil, errors.New("client type should be http.Client") + } + } + + return &c, nil +} diff --git a/slice/slice_internal.go b/slice/slice_internal.go new file mode 100644 index 0000000..b3113f1 --- /dev/null +++ b/slice/slice_internal.go @@ -0,0 +1,65 @@ +package slice + +import ( + "fmt" + "reflect" +) + +// sliceValue return the reflect value of a slice +func sliceValue(slice interface{}) reflect.Value { + v := reflect.ValueOf(slice) + if v.Kind() != reflect.Slice { + panic(fmt.Sprintf("Invalid slice type, value of type %T", slice)) + } + return v +} + +// functionValue return the reflect value of a function +func functionValue(function interface{}) reflect.Value { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } + return v +} + +// checkSliceCallbackFuncSignature Check func sign : s :[]type1{} -> func(i int, data type1) type2 +// see https://coolshell.cn/articles/21164.html#%E6%B3%9B%E5%9E%8BMap-Reduce +func checkSliceCallbackFuncSignature(fn reflect.Value, types ...reflect.Type) bool { + //Check it is a function + if fn.Kind() != reflect.Func { + return false + } + // NumIn() - returns a function type's input parameter count. + // NumOut() - returns a function type's output parameter count. + if (fn.Type().NumIn() != len(types)-1) || (fn.Type().NumOut() != 1) { + return false + } + // In() - returns the type of a function type's i'th input parameter. + // first input param type should be int + if fn.Type().In(0) != reflect.TypeOf(1) { + return false + } + for i := 0; i < len(types)-1; i++ { + if fn.Type().In(i) != types[i] { + return false + } + } + // Out() - returns the type of a function type's i'th output parameter. + outType := types[len(types)-1] + if outType != nil && fn.Type().Out(0) != outType { + return false + } + return true +} + +// sliceElemType get slice element type +func sliceElemType(reflectType reflect.Type) reflect.Type { + for { + if reflectType.Kind() != reflect.Slice { + return reflectType + } + + reflectType = reflectType.Elem() + } +} diff --git a/strutil/string_internal.go b/strutil/string_internal.go new file mode 100644 index 0000000..6776d43 --- /dev/null +++ b/strutil/string_internal.go @@ -0,0 +1,40 @@ +package strutil + +import "strings" + +// splitWordsToLower split a string into worlds by uppercase char +func splitWordsToLower(s string) []string { + var res []string + + upperIndexes := upperIndex(s) + l := len(upperIndexes) + if upperIndexes == nil || l == 0 { + if s != "" { + res = append(res, s) + } + return res + } + for i := 0; i < l; i++ { + if i < l-1 { + res = append(res, strings.ToLower(s[upperIndexes[i]:upperIndexes[i+1]])) + } else { + res = append(res, strings.ToLower(s[upperIndexes[i]:])) + } + } + return res +} + +// upperIndex get a int slice which elements are all the uppercase char index of a string +func upperIndex(s string) []int { + var res []int + for i := 0; i < len(s); i++ { + if 64 < s[i] && s[i] < 91 { + res = append(res, i) + } + } + if len(s) > 0 && res != nil && res[0] != 0 { + res = append([]int{0}, res...) + } + + return res +}