|
|
package CommonUtil
|
|
|
|
|
|
import (
|
|
|
"bufio"
|
|
|
"bytes"
|
|
|
"crypto/md5"
|
|
|
"encoding/binary"
|
|
|
"encoding/hex"
|
|
|
"encoding/json"
|
|
|
"errors"
|
|
|
"fmt"
|
|
|
uuid "github.com/satori/go.uuid"
|
|
|
"io"
|
|
|
"log"
|
|
|
"math/rand"
|
|
|
"os"
|
|
|
"os/exec"
|
|
|
"path/filepath"
|
|
|
"regexp"
|
|
|
"strconv"
|
|
|
"strings"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
/**
|
|
|
功能：获取UUID
|
|
|
作者：黄海
|
|
|
时间：2020-02-03
|
|
|
*/
|
|
|
func GetUUID() string {
|
|
|
u2 := strings.ToUpper(uuid.NewV4().String())
|
|
|
return u2
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：判断是不是合法的日期格式
|
|
|
作者：黄海
|
|
|
时间：2020-03-23
|
|
|
*/
|
|
|
func IsDate(date string) bool {
|
|
|
_, err := time.Parse("2006-01-02 15:04:05", date)
|
|
|
if err != nil {
|
|
|
return false
|
|
|
} else {
|
|
|
return true
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：从一个数据库的查询返回结果中获取指定字段的IDS
|
|
|
作者：黄海
|
|
|
时间：2020-02-14
|
|
|
*/
|
|
|
func SelectIdsFromMapInterface(list []map[string]interface{}, key string) []string {
|
|
|
var ids []string
|
|
|
for i := 0; i < len(list); i++ {
|
|
|
switch list[i][key].(type) {
|
|
|
case string:
|
|
|
ids = append(ids, list[i][key].(string))
|
|
|
break
|
|
|
case int64:
|
|
|
ids = append(ids, strconv.FormatInt(list[i][key].(int64), 10))
|
|
|
}
|
|
|
}
|
|
|
return ids
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将一个数据库查询返回结果中的某一列，形成字典
|
|
|
作者：黄海
|
|
|
时间：2020-02-14
|
|
|
*/
|
|
|
func PutSelectResultToMapByField(list []map[string]interface{}, field string) map[string]interface{} {
|
|
|
_dict := make(map[string]interface{})
|
|
|
for i, _ := range list {
|
|
|
record := list[i]
|
|
|
switch record[field].(type) {
|
|
|
case int64:
|
|
|
_dict[strconv.FormatInt(record[field].(int64), 10)] = 1
|
|
|
default:
|
|
|
_dict[record[field].(string)] = 1
|
|
|
}
|
|
|
}
|
|
|
return _dict
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：通过字典获取字符串数组
|
|
|
作者：黄海
|
|
|
时间：2020-02-14
|
|
|
*/
|
|
|
func GetArrayByMap(_dict map[string]interface{}) []string {
|
|
|
Ids := make([]string, 0, len(_dict))
|
|
|
for k := range _dict {
|
|
|
Ids = append(Ids, k) //
|
|
|
}
|
|
|
return Ids
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将数据库返回的查询结果映射成字典，用于扩展字段
|
|
|
作者：黄海
|
|
|
时间：2020-02-14
|
|
|
*/
|
|
|
func ConvertMapInterfaceToMapByField(list []map[string]interface{}, key string, value string) map[string]string {
|
|
|
_map := make(map[string]string)
|
|
|
for i, _ := range list {
|
|
|
var areaTypeId string
|
|
|
switch list[i][key].(type) {
|
|
|
case int64:
|
|
|
areaTypeId = strconv.FormatInt(list[i][key].(int64), 10)
|
|
|
default:
|
|
|
areaTypeId = list[i][key].(string)
|
|
|
}
|
|
|
switch list[i][value].(type) {
|
|
|
case int64:
|
|
|
_map[areaTypeId] = strconv.FormatInt(list[i][value].(int64), 10)
|
|
|
default:
|
|
|
_map[areaTypeId] = list[i][value].(string)
|
|
|
}
|
|
|
}
|
|
|
return _map
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：扩展数据库查询结果集
|
|
|
作者：黄海
|
|
|
时间：2020-02-14
|
|
|
*/
|
|
|
func ExtendList(list *[]map[string]interface{}, _map map[string]string, key string, value string) {
|
|
|
for i, _ := range *list {
|
|
|
sourceRecord := (*list)[i]
|
|
|
var a string
|
|
|
switch sourceRecord[key].(type) {
|
|
|
case int64:
|
|
|
a = strconv.FormatInt(sourceRecord[key].(int64), 10)
|
|
|
default:
|
|
|
a = sourceRecord[key].(string)
|
|
|
}
|
|
|
sourceRecord[value] = _map[a]
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：带回显的执行DOS命令
|
|
|
作者：黄海
|
|
|
时间：2020-05-18
|
|
|
*/
|
|
|
func Exec(name string, args ...string) error {
|
|
|
cmd := exec.Command(name, args...)
|
|
|
stderr, _ := cmd.StderrPipe()
|
|
|
stdout, _ := cmd.StdoutPipe()
|
|
|
if err := cmd.Start(); err != nil {
|
|
|
log.Println("exec the cmd ", name, " failed")
|
|
|
return err
|
|
|
}
|
|
|
// 正常日志
|
|
|
logScan := bufio.NewScanner(stdout)
|
|
|
go func() {
|
|
|
for logScan.Scan() {
|
|
|
log.Println(logScan.Text())
|
|
|
}
|
|
|
}()
|
|
|
// 错误日志
|
|
|
errBuf := bytes.NewBufferString("")
|
|
|
scan := bufio.NewScanner(stderr)
|
|
|
for scan.Scan() {
|
|
|
s := scan.Text()
|
|
|
log.Println("", s)
|
|
|
errBuf.WriteString(s)
|
|
|
errBuf.WriteString("\n")
|
|
|
}
|
|
|
// 等待命令执行完
|
|
|
cmd.Wait()
|
|
|
if !cmd.ProcessState.Success() {
|
|
|
// 执行失败，返回错误信息
|
|
|
return errors.New(errBuf.String())
|
|
|
}
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
func CopyFile(dstName, srcName string) (written int64, err error) {
|
|
|
src, err := os.Open(srcName)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
defer src.Close()
|
|
|
dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
defer dst.Close()
|
|
|
return io.Copy(dst, src)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：是不是在指定的数组中存在
|
|
|
作者：黄海
|
|
|
时间：2020-05-15
|
|
|
*/
|
|
|
func IsContain(items []string, item string) bool {
|
|
|
for _, eachItem := range items {
|
|
|
if eachItem == item {
|
|
|
return true
|
|
|
}
|
|
|
}
|
|
|
return false
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：删除字符串多余的空格
|
|
|
作者：黄海
|
|
|
时间：2020-01-20
|
|
|
*/
|
|
|
func DeleteExtraSpace(s string) string {
|
|
|
//删除字符串中的多余空格，有多个空格时，仅保留一个空格
|
|
|
s1 := strings.Replace(s, " ", " ", -1) //替换tab为空格
|
|
|
regstr := "\\s{2,}" //两个及两个以上空格的正则表达式
|
|
|
reg, _ := regexp.Compile(regstr) //编译正则表达式
|
|
|
s2 := make([]byte, len(s1)) //定义字符数组切片
|
|
|
copy(s2, s1) //将字符串复制到切片
|
|
|
spcIndex := reg.FindStringIndex(string(s2)) //在字符串中搜索
|
|
|
for len(spcIndex) > 0 { //找到适配项
|
|
|
s2 = append(s2[:spcIndex[0]+1], s2[spcIndex[1]:]...) //删除多余空格
|
|
|
spcIndex = reg.FindStringIndex(string(s2)) //继续在字符串中搜索
|
|
|
}
|
|
|
return string(s2)
|
|
|
}
|
|
|
|
|
|
// Capitalize 字符首字母大写
|
|
|
func Capitalize(str string) string {
|
|
|
var upperStr string
|
|
|
vv := []rune(str) // 后文有介绍
|
|
|
for i := 0; i < len(vv); i++ {
|
|
|
if i == 0 {
|
|
|
if vv[i] >= 97 && vv[i] <= 122 { // 后文有介绍
|
|
|
vv[i] -= 32 // string的码表相差32位
|
|
|
upperStr += string(vv[i])
|
|
|
} else {
|
|
|
fmt.Println("Not begins with lowercase letter,")
|
|
|
return str
|
|
|
}
|
|
|
} else {
|
|
|
upperStr += string(vv[i])
|
|
|
}
|
|
|
}
|
|
|
return upperStr
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：获取蛇形命名的字符串
|
|
|
作者：黄海
|
|
|
时间：2020-01-22
|
|
|
*/
|
|
|
func GetSnakeCaseStr(str string) string {
|
|
|
array := strings.Split(str, "_")
|
|
|
var result string
|
|
|
for i := 0; i < len(array); i++ {
|
|
|
result = result + strings.ToUpper(array[i][0:1]) + array[i][1:]
|
|
|
}
|
|
|
return result
|
|
|
}
|
|
|
|
|
|
const (
|
|
|
// 可自定义盐值
|
|
|
TokenSalt = "DsideaL4r5t6y7u"
|
|
|
)
|
|
|
|
|
|
func MD5(data []byte) string {
|
|
|
_md5 := md5.New()
|
|
|
_md5.Write(data)
|
|
|
return hex.EncodeToString(_md5.Sum([]byte("")))
|
|
|
}
|
|
|
|
|
|
//isSymbol表示有无符号
|
|
|
func BytesToInt(b []byte, isSymbol bool) (int, error) {
|
|
|
if isSymbol {
|
|
|
return BytesToIntS(b)
|
|
|
}
|
|
|
return bytesToIntU(b)
|
|
|
}
|
|
|
|
|
|
//字节数(大端)组转成int(无符号的)
|
|
|
func bytesToIntU(b []byte) (int, error) {
|
|
|
if len(b) == 3 {
|
|
|
b = append([]byte{0}, b...)
|
|
|
}
|
|
|
bytesBuffer := bytes.NewBuffer(b)
|
|
|
switch len(b) {
|
|
|
case 1:
|
|
|
var tmp uint8
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
case 2:
|
|
|
var tmp uint16
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
case 4:
|
|
|
var tmp uint32
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
default:
|
|
|
return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//字节数(大端)组转成int(有符号)
|
|
|
func BytesToIntS(b []byte) (int, error) {
|
|
|
if len(b) == 3 {
|
|
|
b = append([]byte{0}, b...)
|
|
|
}
|
|
|
bytesBuffer := bytes.NewBuffer(b)
|
|
|
switch len(b) {
|
|
|
case 1:
|
|
|
var tmp int8
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
case 2:
|
|
|
var tmp int16
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
case 4:
|
|
|
var tmp int32
|
|
|
err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return int(tmp), err
|
|
|
default:
|
|
|
return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//整形转换成字节
|
|
|
func IntToBytes(n int, b byte) ([]byte, error) {
|
|
|
switch b {
|
|
|
case 1:
|
|
|
tmp := int8(n)
|
|
|
bytesBuffer := bytes.NewBuffer([]byte{})
|
|
|
binary.Write(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return bytesBuffer.Bytes(), nil
|
|
|
case 2:
|
|
|
tmp := int16(n)
|
|
|
bytesBuffer := bytes.NewBuffer([]byte{})
|
|
|
binary.Write(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return bytesBuffer.Bytes(), nil
|
|
|
case 3, 4:
|
|
|
tmp := int32(n)
|
|
|
bytesBuffer := bytes.NewBuffer([]byte{})
|
|
|
binary.Write(bytesBuffer, binary.BigEndian, &tmp)
|
|
|
return bytesBuffer.Bytes(), nil
|
|
|
}
|
|
|
return nil, fmt.Errorf("IntToBytes b param is invaild")
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：生成一个随机盐
|
|
|
作者: 黄海
|
|
|
时间：2020-02-18
|
|
|
*/
|
|
|
func GetRandomSalt() string {
|
|
|
return GetRandomString(8)
|
|
|
}
|
|
|
|
|
|
//生成随机字符串
|
|
|
func GetRandomString(l int) string {
|
|
|
str := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
|
bytes := []byte(str)
|
|
|
var result []byte
|
|
|
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
|
for i := 0; i < l; i++ {
|
|
|
result = append(result, bytes[r.Intn(len(bytes))])
|
|
|
}
|
|
|
return string(result)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：获取当前的时间戳，精确度纳秒
|
|
|
作者：黄海
|
|
|
时间：2020-02-18
|
|
|
*/
|
|
|
func GetCurrentTimestamp() int64 {
|
|
|
return time.Now().UnixNano()
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：获取当前的时间字符串
|
|
|
作者：黄海
|
|
|
时间：2020-02-21
|
|
|
*/
|
|
|
func GetCurrentTime() string {
|
|
|
timeStr := time.Now().Format("2006-01-02 15:04:05")
|
|
|
//当前时间的字符串，2006-01-02 15:04:05据说是golang的诞生时间，固定写法
|
|
|
return timeStr
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将Json格式的字符串转为map
|
|
|
作者：吴缤
|
|
|
日期：2020-02-21
|
|
|
*/
|
|
|
func JsonStrToMap(jsonStr string) (map[string]interface{}, error) {
|
|
|
var _map map[string]interface{}
|
|
|
err := json.Unmarshal([]byte(jsonStr), &_map)
|
|
|
if err == nil {
|
|
|
if _map["code"] != nil {
|
|
|
var _code = int(_map["code"].(float64))
|
|
|
_map["code"] = _code
|
|
|
}
|
|
|
return _map, nil
|
|
|
} else {
|
|
|
return nil, err
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
获取程序运行路径
|
|
|
*/
|
|
|
func GetCurrentDirectory() string {
|
|
|
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
|
|
|
if err != nil {
|
|
|
fmt.Println(err)
|
|
|
}
|
|
|
return strings.Replace(dir, "\\", "/", -1)
|
|
|
}
|
|
|
|
|
|
// 判断所给路径文件/文件夹是否存在
|
|
|
func Exists(path string) bool {
|
|
|
_, err := os.Stat(path) //os.Stat获取文件信息
|
|
|
if err != nil {
|
|
|
if os.IsExist(err) {
|
|
|
return true
|
|
|
}
|
|
|
return false
|
|
|
}
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将int数据类型转为int64
|
|
|
作者：黄海
|
|
|
时间：2020-02-18
|
|
|
*/
|
|
|
func ConvertIntToInt64(i int) int64 {
|
|
|
s := strconv.Itoa(i)
|
|
|
s64, _ := strconv.ParseInt(s, 10, 64)
|
|
|
return s64
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将字符串转为整数
|
|
|
作者：黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertStringToInt(s string) int {
|
|
|
i, _ := strconv.Atoi(s)
|
|
|
return i
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将字符串转为整数64
|
|
|
作者：黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertStringToInt64(s string) int64 {
|
|
|
i, _ := strconv.ParseInt(s, 10, 64)
|
|
|
return i
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将整数转为字符串
|
|
|
作者：黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertIntToString(i int) string {
|
|
|
s := strconv.Itoa(i)
|
|
|
return s
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将字符串转为int32整数
|
|
|
作者：黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertStringToInt32(s string) int32 {
|
|
|
i, _ := strconv.Atoi(s)
|
|
|
return int32(i)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将整数64转为字符串
|
|
|
作者：黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertInt64ToString(i int64) string {
|
|
|
s := strconv.FormatInt(i, 10)
|
|
|
return s
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将JSON字符串转化为map数组
|
|
|
作者: 黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertJsonStringToMapArray(data string) []map[string]interface{} {
|
|
|
var m = make([]map[string]interface{}, 0)
|
|
|
str := []byte(data)
|
|
|
json.Unmarshal(str, &m)
|
|
|
return m
|
|
|
}
|
|
|
|
|
|
func ConvertStringArrayToArray(data string) []string {
|
|
|
data = strings.ReplaceAll(data, "[", "")
|
|
|
data = strings.ReplaceAll(data, "]", "")
|
|
|
if len(data) > 0 {
|
|
|
return strings.Split(data, ",")
|
|
|
} else {
|
|
|
return []string{}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将JSON字符串转化为map数组
|
|
|
作者: 黄海
|
|
|
时间：2020-04-17
|
|
|
*/
|
|
|
func ConvertJsonStringToMap(data string) map[string]interface{} {
|
|
|
var m = make(map[string]interface{}, 0)
|
|
|
str := []byte(data)
|
|
|
json.Unmarshal(str, &m)
|
|
|
return m
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将int转化为string
|
|
|
作者：黄海
|
|
|
时间：2020-04-20
|
|
|
*/
|
|
|
func ConvertInt32ToString(n int32) string {
|
|
|
buf := [11]byte{}
|
|
|
pos := len(buf)
|
|
|
i := int64(n)
|
|
|
signed := i < 0
|
|
|
if signed {
|
|
|
i = -i
|
|
|
}
|
|
|
for {
|
|
|
pos--
|
|
|
buf[pos], i = '0'+byte(i%10), i/10
|
|
|
if i == 0 {
|
|
|
if signed {
|
|
|
pos--
|
|
|
buf[pos] = '-'
|
|
|
}
|
|
|
return string(buf[pos:])
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：将一个查询结果转化为字符串，方便返回
|
|
|
作者：黄海
|
|
|
时间:2020-04-22
|
|
|
*/
|
|
|
func SerializeToString(list interface{}) string {
|
|
|
switch list.(type) {
|
|
|
case []map[string]interface{}:
|
|
|
if len(list.([]map[string]interface{})) == 0 {
|
|
|
return "[]"
|
|
|
} else {
|
|
|
data, _ := json.Marshal(list)
|
|
|
return string(data)
|
|
|
}
|
|
|
case map[string]interface{}:
|
|
|
data, _ := json.Marshal(list)
|
|
|
return string(data)
|
|
|
default:
|
|
|
return ""
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：两个LIST进行合并
|
|
|
作者：吴缤
|
|
|
日期：2020-05-15
|
|
|
*/
|
|
|
func ListMerge(a string, b string, correspondSourceId string, correspondTargetId string, displaySourceKey string, displayTargetKey string) string {
|
|
|
aList := ConvertJsonStringToMapArray(a)
|
|
|
bList := ConvertJsonStringToMapArray(b)
|
|
|
bMap := make(map[string]interface{})
|
|
|
for i := 0; i < len(bList); i++ {
|
|
|
bRecord := (bList)[i]
|
|
|
var bKey string
|
|
|
switch bRecord[correspondTargetId].(type) {
|
|
|
case string:
|
|
|
bKey = bRecord[correspondTargetId].(string)
|
|
|
break
|
|
|
case int:
|
|
|
bKey = strconv.Itoa(bRecord[correspondTargetId].(int))
|
|
|
break
|
|
|
case int32:
|
|
|
bKey = ConvertInt32ToString(bRecord[correspondTargetId].(int32))
|
|
|
break
|
|
|
case int64:
|
|
|
bKey = strconv.FormatInt(bRecord[correspondTargetId].(int64), 10)
|
|
|
break
|
|
|
}
|
|
|
bMap[bKey] = bRecord[displayTargetKey]
|
|
|
}
|
|
|
|
|
|
for i := 0; i < len(aList); i++ {
|
|
|
aRecord := (aList)[i]
|
|
|
var aKey string
|
|
|
switch aRecord[correspondSourceId].(type) {
|
|
|
case string:
|
|
|
aKey = aRecord[correspondSourceId].(string)
|
|
|
break
|
|
|
case int:
|
|
|
aKey = strconv.Itoa(aRecord[correspondSourceId].(int))
|
|
|
break
|
|
|
case int32:
|
|
|
aKey = ConvertInt32ToString(aRecord[correspondSourceId].(int32))
|
|
|
break
|
|
|
case int64:
|
|
|
aKey = strconv.FormatInt(aRecord[correspondSourceId].(int64), 10)
|
|
|
}
|
|
|
display := ""
|
|
|
if bMap[aKey] != nil {
|
|
|
display = bMap[aKey].(string)
|
|
|
}
|
|
|
aRecord[displaySourceKey] = display
|
|
|
}
|
|
|
return SerializeToString(aList)
|
|
|
}
|
|
|
func ListCollectAttributes(listStr string, attr string) []string {
|
|
|
var orgIdArray []string
|
|
|
list := ConvertJsonStringToMapArray(listStr)
|
|
|
for i := 0; i < len(list); i++ {
|
|
|
orgId := list[i][attr].(string)
|
|
|
orgIdArray = append(orgIdArray, orgId)
|
|
|
}
|
|
|
return orgIdArray
|
|
|
}
|
