1075 lines
24 KiB
Go
1075 lines
24 KiB
Go
package jdshopapi
|
||
|
||
import (
|
||
"bytes"
|
||
"crypto/aes"
|
||
"crypto/cipher"
|
||
"encoding/base64"
|
||
"fmt"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"golang.org/x/text/encoding/simplifiedchinese"
|
||
"golang.org/x/text/transform"
|
||
"io/ioutil"
|
||
"math"
|
||
"sort"
|
||
"strconv"
|
||
"testing"
|
||
)
|
||
|
||
func TestCreateShopCategory(t *testing.T) {
|
||
var CreateShopCategoryParams = []*CreateShopCategoryParam{
|
||
&CreateShopCategoryParam{
|
||
HomeShow: "0",
|
||
ID: "1",
|
||
Open: "",
|
||
OrderNo: "0",
|
||
ParentID: "",
|
||
Title: "测试1",
|
||
Type: "3",
|
||
},
|
||
}
|
||
result, _ := api.CreateShopCategory(CreateShopCategoryParams)
|
||
fmt.Println(result)
|
||
}
|
||
|
||
func TestUpdateStoreStatus(t *testing.T) {
|
||
err := api.UpdateStoreStatus(24332466, 1)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
|
||
func TestNewInfoList(t *testing.T) {
|
||
result, err := api.NewInfoList(1)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func Test11(t *testing.T) {
|
||
change := func(s ...string) {
|
||
s[0] = "Go"
|
||
s = append(s, "playground")
|
||
fmt.Println(s)
|
||
}
|
||
|
||
welcome := []string{"hello", "world"}
|
||
change(welcome...)
|
||
fmt.Println(welcome)
|
||
|
||
}
|
||
|
||
func TestAllOrders(t *testing.T) {
|
||
result, err := api.AllOrders(&AllOrdersParam{
|
||
Current: 1,
|
||
PageSize: 1,
|
||
OrderID: "206317669879",
|
||
})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestOrderDetail(t *testing.T) {
|
||
result, err := api.OrderDetail("213676047946")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestPhoneSensltiveInfo(t *testing.T) {
|
||
result, err := api.PhoneSensltiveInfo("124396047880", "10b1707dc87755373d488a7a4f422f7d")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestUpdateWaybill(t *testing.T) {
|
||
err := api.UpdateWaybill("123076499052", "1274", "88328977356545 ")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestTryGetCookie(t *testing.T) {
|
||
result, err := api.TryGetCookie()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestAAADS(t *testing.T) {
|
||
key, _ := base64.StdEncoding.DecodeString("DW+rL8hlSFt65gUnDXW13A==")
|
||
data, _ := base64.StdEncoding.DecodeString("Zh1/Gnb3GWkt7slPocCh5EjgfCrivUMrEjQZT+ND2fsDZYGXIny8NazZJ7UA8DgMpuJf9vBPlf3C8l8oT7aYebJMhAEx8kRFdQip8yEFqbzTfHfnNnMsI4Wkh1Ij06iLiZITnPUdWsuHjwI7BKKmZFDloiOkn3p+gtACFThm7B03SfPmvOdokdIQvDa1nEzPL/2DkfhAwDPxzgGHI0HaAQ==")
|
||
iv, _ := base64.StdEncoding.DecodeString("BBYl0UZhgnV59eP6MkxeeQ==")
|
||
result, _ := Decrypt(data, key, iv)
|
||
fmt.Println(string(result))
|
||
}
|
||
|
||
func Decrypt(decryptBytes, key, iv []byte) ([]byte, error) {
|
||
block, err := aes.NewCipher(key)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
blockMode := cipher.NewCBCDecrypter(block, iv)
|
||
blockMode.CryptBlocks(decryptBytes, decryptBytes)
|
||
return PKCS5UnPadding(decryptBytes), nil
|
||
}
|
||
|
||
func PKCS5UnPadding(decrypted []byte) []byte {
|
||
length := len(decrypted)
|
||
unPadding := int(decrypted[length-1])
|
||
return decrypted[:(length - unPadding)]
|
||
}
|
||
|
||
func TestShopDetail(t *testing.T) {
|
||
//result, err := api.ShopDetail(1000069719)
|
||
//if err != nil {
|
||
// t.Fatal(err)
|
||
//}
|
||
//t.Log(utils.Format4Output(result, false))
|
||
retVal, err := utils.TryStr2Time("2021-07-15 :00")
|
||
fmt.Println(retVal, err)
|
||
}
|
||
|
||
func TestSubmitBasic(t *testing.T) {
|
||
result, err := api.SubmitBasic(&UpdateBasicParam{
|
||
StoreName: "京西菜市石犀市场生鲜店",
|
||
CategoryID2: 62,
|
||
Coordinate: "30.692941,103.858781",
|
||
BussinessBeginTime: "08:30",
|
||
BussinessEndTime: "20:00",
|
||
ImgURL: "jfs/t1/141918/10/14803/148865/5fb4e8cbE95a606cb/08a8dc277eb97a16.png",
|
||
StorePhone: "13706546496",
|
||
AddName: "四川成都市温江区@!温江区锦泉街116号（优取舍）",
|
||
// AddCode1: 22,
|
||
// AddCode2: 1930,
|
||
AddCode3: 49315,
|
||
CategoryID1: 34,
|
||
QualificationRequests: []*QualificationRequests{
|
||
&QualificationRequests{
|
||
QualificationID: 41,
|
||
QualificationName: "营业执照",
|
||
QualificationNo: "11111",
|
||
QualificationURL: "jfs/t1/148622/37/14846/10266/5fb4e3e2Ef2f61870/a7cfba9c1513d95e.png",
|
||
StartTime: "2020-11-04 00:00:00",
|
||
EndingTime: "2020-11-06 23:59:59",
|
||
Time: []string{"2020-11-04 00:00:00", "2020-11-06 23:59:59"},
|
||
},
|
||
},
|
||
})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestUpdateBasic(t *testing.T) {
|
||
shop, _ := api.ShopList(1)
|
||
for _, v := range shop.List {
|
||
detail, _ := api.ShopDetail(v.StoreID)
|
||
api.UpdateBasic(&UpdateBasicParam{
|
||
StoreID: detail.StoreID,
|
||
StoreName: detail.StoreName,
|
||
CategoryID2: 62,
|
||
Coordinate: detail.Coordinate,
|
||
BussinessBeginTime: detail.BussinessBeginTime,
|
||
BussinessEndTime: detail.BussinessEndTime,
|
||
ImgURL: detail.ImgURL,
|
||
StorePhone: detail.StorePhone,
|
||
AddName: utils.LimitUTF8StringLen(detail.AddName, 100),
|
||
AddCode1: detail.AddCode1,
|
||
AddCode2: detail.AddCode2,
|
||
AddCode3: detail.AddCode3,
|
||
CategoryID1: 34,
|
||
QualificationRequests: []*QualificationRequests{
|
||
&QualificationRequests{
|
||
QualificationID: 41,
|
||
QualificationName: "营业执照",
|
||
QualificationNo: "91510106MA62QYUK9X",
|
||
QualificationURL: "jfs/t1/140863/13/17145/275844/5fc9ac7aE9a5f8d68/f9d459176d463cb5.jpg",
|
||
StartTime: "2017-03-01 00:00:00",
|
||
EndingTime: "2027-03-01 00:00:00",
|
||
Time: []string{"2017-03-01 00:00:00", "2027-03-01 00:00:00"},
|
||
},
|
||
},
|
||
})
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestUpdateExpand(t *testing.T) {
|
||
data, _, _ := DownloadFileByURL("http://image.jxc4.com/image/ac6c79112a0330006b40af3302df9f46.jpg")
|
||
fmt.Println(string(data))
|
||
}
|
||
|
||
func TestCreateGisFence(t *testing.T) {
|
||
err := api.CreateGisFence(1000069001, "3")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestUpdateDeliveryPromise(t *testing.T) {
|
||
err := api.UpdateDeliveryPromise("09:00", "20:00", 1000070127)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestUploadImageNew(t *testing.T) {
|
||
//dp[m][n] = dp[m-1][n] + dp[m][n-1]
|
||
fmt.Println(myAtoi("21A"))
|
||
}
|
||
|
||
func myAtoi(s string) (r int) {
|
||
abs, sign, i, n := 0, 1, 0, len(s)
|
||
for i < n && s[i] == ' ' {
|
||
i++
|
||
}
|
||
if i < n {
|
||
if s[i] == '-' {
|
||
sign = -1
|
||
i++
|
||
} else if s[i] == '+' {
|
||
sign = 1
|
||
i++
|
||
}
|
||
}
|
||
for i < n && s[i] >= '0' && s[i] <= '9' {
|
||
abs = 10*abs + int(s[i]-'0') //字节 byte '0' == 48
|
||
if sign*abs < math.MinInt32 { //整数超过 32 位有符号整数范围
|
||
return math.MinInt32
|
||
} else if sign*abs > math.MaxInt32 {
|
||
return math.MaxInt32
|
||
}
|
||
i++
|
||
}
|
||
return r
|
||
}
|
||
|
||
func minCostClimbingStairs(cost []int) int {
|
||
min := func(a, b int) int {
|
||
if a < b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
var dp = make([]int, len(cost))
|
||
dp[0] = 0
|
||
dp[1] = 0
|
||
for i := 2; i < len(cost); i++ {
|
||
dp[i] = min(dp[i-1]+cost[i], dp[i-2]+cost[i-1])
|
||
}
|
||
return dp[len(cost)]
|
||
}
|
||
|
||
func climbStairs(n int) int {
|
||
a, b, c := 0, 0, 1
|
||
for i := 1; i < n+1; i++ {
|
||
a = b
|
||
b = c
|
||
c = a + b
|
||
}
|
||
return c
|
||
}
|
||
|
||
//leetcode 1876
|
||
func countGoodSubstrings(s string) int {
|
||
if len(s) < 3 {
|
||
return 0
|
||
}
|
||
count := 0
|
||
a, b, c := s[0:1], s[1:2], s[2:3]
|
||
for i := 3; i < len(s)+1; i++ {
|
||
if a != b && b != c && a != c {
|
||
count++
|
||
}
|
||
if i == len(s) {
|
||
break
|
||
}
|
||
a = b
|
||
b = c
|
||
c = s[i : i+1]
|
||
}
|
||
return count
|
||
}
|
||
|
||
//T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
|
||
func tribonacci(n int) int {
|
||
if n == 0 || n == 1 {
|
||
return n
|
||
}
|
||
if n == 2 {
|
||
return 1
|
||
}
|
||
var tris = make([]int, n+1)
|
||
tris[0] = 0
|
||
tris[1] = 1
|
||
tris[2] = 1
|
||
for i := 3; i < n+1; i++ {
|
||
tris[i] = tris[i-1] + tris[i-2] + tris[i-3]
|
||
}
|
||
return tris[n]
|
||
}
|
||
|
||
func fib(n int) (result int) {
|
||
//if n == 0 || n == 1 {
|
||
// return n
|
||
//}
|
||
//var fibs = make([]int, n+1)
|
||
//fibs[0] = 0
|
||
//fibs[1] = 1
|
||
//for i := 2; i < n+1; i++ {
|
||
// fibs[i] = fibs[i-1] + fibs[i-2]
|
||
//}
|
||
//return fibs[n]
|
||
if n == 0 || n == 1 {
|
||
return n
|
||
}
|
||
a, b, c := 0, 0, 1
|
||
for i := 2; i < n+1; i++ {
|
||
a = b
|
||
b = c
|
||
c = a + b
|
||
}
|
||
return c
|
||
}
|
||
|
||
//经典dp
|
||
func dp2(m, n int) (result int) {
|
||
var dp = make([][]int, m)
|
||
for i := 0; i < m; i++ {
|
||
dp[i] = make([]int, n)
|
||
for j := 0; j < n; j++ {
|
||
if i == 0 || j == 0 {
|
||
dp[i][j] = 1
|
||
} else {
|
||
dp[i][j] = dp[i-1][j] + dp[i][j-1]
|
||
}
|
||
}
|
||
}
|
||
return dp[m-1][n-1]
|
||
}
|
||
|
||
func a(n int) (ans int) {
|
||
const mod int = 1e9 + 7
|
||
dp := make([][2][3]int, n+1) // 三个维度分别表示：长度，A 的数量，结尾连续 L 的数量
|
||
dp[0][0][0] = 1
|
||
for i := 1; i <= n; i++ {
|
||
// 以 P 结尾的数量
|
||
for j := 0; j <= 1; j++ {
|
||
for k := 0; k <= 2; k++ {
|
||
dp[i][j][0] = (dp[i][j][0] + dp[i-1][j][k]) % mod
|
||
}
|
||
}
|
||
// 以 A 结尾的数量
|
||
for k := 0; k <= 2; k++ {
|
||
dp[i][1][0] = (dp[i][1][0] + dp[i-1][0][k]) % mod
|
||
}
|
||
// 以 L 结尾的数量
|
||
for j := 0; j <= 1; j++ {
|
||
for k := 1; k <= 2; k++ {
|
||
dp[i][j][k] = (dp[i][j][k] + dp[i-1][j][k-1]) % mod
|
||
}
|
||
}
|
||
}
|
||
for j := 0; j <= 1; j++ {
|
||
for k := 0; k <= 2; k++ {
|
||
ans = (ans + dp[n][j][k]) % mod
|
||
}
|
||
}
|
||
return ans
|
||
}
|
||
|
||
func checkRecord(s string) bool {
|
||
countL := 0
|
||
countA := 0
|
||
for _, v := range s {
|
||
if v == 'A' {
|
||
countA++
|
||
if countA > 1 {
|
||
return false
|
||
}
|
||
}
|
||
if v == 'L' {
|
||
countL++
|
||
if countL > 2 {
|
||
return false
|
||
}
|
||
} else {
|
||
countL = 0
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func sink(array []int, length int) {
|
||
start := 0
|
||
for {
|
||
//2*n+1 可以画图就知道为什么了，是左边子节点
|
||
next := 2*start + 1
|
||
if next > length {
|
||
break
|
||
}
|
||
if next+1 <= length && array[next+1] < array[next] {
|
||
next++
|
||
}
|
||
|
||
//上层小于下面，不用互换了
|
||
if array[start] <= array[next] {
|
||
break
|
||
}
|
||
//互换继续下沉
|
||
array[start], array[next] = array[next], array[start]
|
||
start = next
|
||
}
|
||
}
|
||
|
||
//堆
|
||
//top k
|
||
func topk(s []int, k, i int) {
|
||
for {
|
||
left := i*2 + 1
|
||
right := i*2 + 2
|
||
if i < 0 {
|
||
break
|
||
}
|
||
if right == k {
|
||
if s[i] < s[left] {
|
||
s[i], s[left] = s[left], s[i]
|
||
}
|
||
} else {
|
||
if s[i] < s[left] || s[i] < s[right] {
|
||
if s[left] < s[right] {
|
||
s[i], s[right] = s[right], s[i]
|
||
} else {
|
||
s[i], s[left] = s[left], s[i]
|
||
}
|
||
}
|
||
}
|
||
if i-1 < 0 {
|
||
break
|
||
}
|
||
i = (i - 1) / 2
|
||
}
|
||
fmt.Println("loop s", s)
|
||
}
|
||
|
||
//给定一个包含正整数、加(+)、减(-)、乘(*)、除(/)的算数表达式(括号除外)，计算其结果。
|
||
//表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。
|
||
func calculate(s string) int {
|
||
return 1
|
||
}
|
||
|
||
//输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
|
||
func spiralOrder(matrix [][]int) []int {
|
||
var result []int
|
||
if len(matrix) == 0 {
|
||
return result
|
||
} else {
|
||
if len(matrix[0]) == 0 {
|
||
return result
|
||
}
|
||
}
|
||
l, h := len(matrix[0]), len(matrix)
|
||
left, right, top, bottom := 0, l-1, 0, h-1
|
||
lmax, tmax := 0, 0
|
||
if l%2 == 0 {
|
||
lmax = l / 2
|
||
} else {
|
||
lmax = l/2 + 1
|
||
}
|
||
if h%2 == 0 {
|
||
tmax = l / 2
|
||
} else {
|
||
tmax = l/2 + 1
|
||
}
|
||
|
||
for left <= lmax && top+1 <= tmax {
|
||
for left1 := left; left1 <= right; left1++ {
|
||
if len(result) >= l*h {
|
||
break
|
||
}
|
||
result = append(result, matrix[top][left1])
|
||
}
|
||
if h > 1 {
|
||
for top1 := top + 1; top1 <= bottom; top1++ {
|
||
if len(result) >= l*h {
|
||
break
|
||
}
|
||
result = append(result, matrix[top1][right])
|
||
}
|
||
if right > 0 {
|
||
for right1 := right - 1; right1 >= left; right1-- {
|
||
if len(result) >= l*h {
|
||
break
|
||
}
|
||
result = append(result, matrix[bottom][right1])
|
||
}
|
||
}
|
||
if bottom > 0 {
|
||
for bottom1 := bottom - 1; bottom1 >= top+1; bottom1-- {
|
||
if len(result) >= l*h {
|
||
break
|
||
}
|
||
result = append(result, matrix[bottom1][left])
|
||
}
|
||
}
|
||
}
|
||
left++
|
||
top++
|
||
right--
|
||
bottom--
|
||
}
|
||
return result
|
||
}
|
||
|
||
func addToArrayForm(A []int, K int) (a []int) {
|
||
B := []int{}
|
||
lengthK := 0
|
||
for i := 10; ; i = i * 10 {
|
||
if K/i == 0 {
|
||
lengthK++
|
||
break
|
||
}
|
||
lengthK++
|
||
}
|
||
for i := lengthK; i > 0; i-- {
|
||
if i == lengthK {
|
||
B = append(B, K/int(math.Pow10(i-1)))
|
||
} else if i == 1 {
|
||
gw := K
|
||
for j := lengthK; j > 1; j-- {
|
||
gw = gw % int(math.Pow10(j-1))
|
||
}
|
||
B = append(B, gw)
|
||
} else {
|
||
qtw := K
|
||
for j := lengthK; j > 1; j-- {
|
||
if j == i {
|
||
qtw = qtw / int(math.Pow10(j-1))
|
||
break
|
||
} else {
|
||
qtw = qtw % int(math.Pow10(j-1))
|
||
}
|
||
}
|
||
B = append(B, qtw)
|
||
}
|
||
}
|
||
flag := false
|
||
in := 0
|
||
for k := len(A) - 1; k >= 0; {
|
||
if flag {
|
||
break
|
||
}
|
||
for k1 := len(B) - 1; k1 >= 0; {
|
||
if A[k]+B[k1]+in < 10 {
|
||
if in == 0 {
|
||
a = append(a, A[k]+B[k1])
|
||
} else {
|
||
a = append(a, A[k]+B[k1]+in)
|
||
}
|
||
in = 0
|
||
} else {
|
||
if in == 0 {
|
||
a = append(a, (A[k]+B[k1])%10)
|
||
} else {
|
||
a = append(a, (A[k]+B[k1]+in)%10)
|
||
}
|
||
in = 0
|
||
in++
|
||
}
|
||
k--
|
||
k1--
|
||
if k == -1 && k1 == -1 && in != 0 {
|
||
a = append(a, 1)
|
||
}
|
||
if k < 0 {
|
||
in2 := 0
|
||
for i := k1; i >= 0; i-- {
|
||
if B[i]+in+in2 < 10 {
|
||
if in2 == 0 {
|
||
a = append(a, B[i]+in)
|
||
} else {
|
||
a = append(a, B[i]+in2+in)
|
||
}
|
||
in = 0
|
||
in2 = 0
|
||
} else {
|
||
if in2 == 0 {
|
||
a = append(a, (B[i]+in)%10)
|
||
} else {
|
||
a = append(a, (B[i]+in+in2)%10)
|
||
}
|
||
in = 0
|
||
in2 = 0
|
||
in2++
|
||
}
|
||
if i == 0 && in2 != 0 {
|
||
a = append(a, 1)
|
||
}
|
||
}
|
||
flag = true
|
||
break
|
||
}
|
||
if k1 < 0 {
|
||
in2 := 0
|
||
for i := k; i >= 0; i-- {
|
||
if A[i]+in+in2 < 10 {
|
||
if in2 == 0 {
|
||
a = append(a, A[i]+in)
|
||
} else {
|
||
a = append(a, A[i]+in2+in)
|
||
}
|
||
in = 0
|
||
in2 = 0
|
||
} else {
|
||
if in2 == 0 {
|
||
a = append(a, (A[i]+in)%10)
|
||
} else {
|
||
a = append(a, (A[i]+in+in2)%10)
|
||
}
|
||
in = 0
|
||
in2 = 0
|
||
in2++
|
||
}
|
||
if i == 0 && in2 != 0 {
|
||
a = append(a, 1)
|
||
}
|
||
}
|
||
flag = true
|
||
break
|
||
}
|
||
}
|
||
}
|
||
for i := 0; i < len(a)/2; i++ {
|
||
temp := a[i]
|
||
a[i] = a[len(a)-i-1]
|
||
a[len(a)-i-1] = temp
|
||
}
|
||
return a
|
||
}
|
||
|
||
func maximumProduct(nums []int) int {
|
||
sort.Ints(nums)
|
||
n := len(nums)
|
||
fmt.Println(nums)
|
||
return max(nums[0]*nums[1]*nums[n-1], nums[n-3]*nums[n-2]*nums[n-1])
|
||
}
|
||
|
||
func max(a, b int) int {
|
||
if a > b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func accountsMerge(accounts [][]string) (ans [][]string) {
|
||
emailToIndex := map[string]int{}
|
||
emailToName := map[string]string{}
|
||
for _, account := range accounts {
|
||
name := account[0]
|
||
for _, email := range account[1:] {
|
||
if _, has := emailToIndex[email]; !has {
|
||
emailToIndex[email] = len(emailToIndex)
|
||
emailToName[email] = name
|
||
}
|
||
}
|
||
}
|
||
fmt.Println(emailToIndex)
|
||
fmt.Println()
|
||
|
||
fmt.Println(emailToName)
|
||
parent := make([]int, len(emailToIndex))
|
||
for i := range parent {
|
||
parent[i] = i
|
||
}
|
||
var find func(int) int
|
||
find = func(x int) int {
|
||
if parent[x] != x {
|
||
parent[x] = find(parent[x])
|
||
}
|
||
return parent[x]
|
||
}
|
||
union := func(from, to int) {
|
||
parent[find(from)] = find(to)
|
||
}
|
||
|
||
for _, account := range accounts {
|
||
firstIndex := emailToIndex[account[1]]
|
||
for _, email := range account[2:] {
|
||
union(emailToIndex[email], firstIndex)
|
||
}
|
||
}
|
||
|
||
fmt.Println(parent)
|
||
fmt.Println()
|
||
fmt.Println(accounts)
|
||
|
||
indexToEmails := map[int][]string{}
|
||
for email, index := range emailToIndex {
|
||
index = find(index)
|
||
indexToEmails[index] = append(indexToEmails[index], email)
|
||
}
|
||
fmt.Println(indexToEmails)
|
||
|
||
for _, emails := range indexToEmails {
|
||
sort.Strings(emails)
|
||
account := append([]string{emailToName[emails[0]]}, emails...)
|
||
ans = append(ans, account)
|
||
}
|
||
return
|
||
}
|
||
|
||
func findRedundantConnection(edges [][]int) []int {
|
||
parent := make([]int, len(edges)+1)
|
||
for i := range parent {
|
||
parent[i] = i
|
||
}
|
||
fmt.Println("edges ", edges)
|
||
fmt.Println("parent ", parent)
|
||
var find func(int) int
|
||
find = func(x int) int {
|
||
if parent[x] != x {
|
||
parent[x] = find(parent[x])
|
||
}
|
||
return parent[x]
|
||
}
|
||
union := func(from, to int) bool {
|
||
fmt.Println(from, to)
|
||
x, y := find(from), find(to)
|
||
fmt.Println(x, y)
|
||
if x == y {
|
||
return false
|
||
}
|
||
parent[x] = y
|
||
fmt.Println(parent)
|
||
fmt.Println("-------------------------------")
|
||
return true
|
||
}
|
||
for _, e := range edges {
|
||
if !union(e[0], e[1]) {
|
||
return e
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func removeStones(stones [][]int) int {
|
||
fa := map[int]int{}
|
||
var find func(int) int
|
||
find = func(x int) int {
|
||
if _, has := fa[x]; !has {
|
||
fa[x] = x
|
||
}
|
||
if fa[x] != x {
|
||
fa[x] = find(fa[x])
|
||
}
|
||
fmt.Println(fa[x])
|
||
return fa[x]
|
||
}
|
||
union := func(x, y int) {
|
||
fmt.Println(x, y)
|
||
fx, fy := find(x), find(y)
|
||
if fx == fy {
|
||
return
|
||
}
|
||
fa[fy] = fx
|
||
fmt.Println(fa)
|
||
}
|
||
for _, p := range stones {
|
||
union(p[0], p[1]+10000)
|
||
}
|
||
ans := len(stones)
|
||
for x, fx := range fa {
|
||
if x == fx {
|
||
ans--
|
||
}
|
||
}
|
||
return ans
|
||
}
|
||
|
||
//动态规划
|
||
func maxUncrossedLines(A []int, B []int) (s int) {
|
||
var dynamic = make([][]int, len(A)+1, len(A)+1)
|
||
for index := range dynamic {
|
||
dynamic[index] = make([]int, len(B)+1, len(B)+1) //多创建一列，因为 index = 0 的时候，没有前置匹配
|
||
}
|
||
for _, v := range dynamic {
|
||
fmt.Println(v)
|
||
}
|
||
fmt.Println("---------------------")
|
||
for index, a := range A {
|
||
for i, b := range B {
|
||
if a == b {
|
||
dynamic[index+1][i+1] = dynamic[index][i] + 1
|
||
for _, v := range dynamic {
|
||
fmt.Println(v)
|
||
}
|
||
fmt.Println("---------------------")
|
||
} else {
|
||
dynamic[index+1][i+1] = dynamic[index][i+1]
|
||
if dynamic[index+1][i+1] < dynamic[index+1][i] {
|
||
dynamic[index+1][i+1] = dynamic[index+1][i] //判断大小，取大值
|
||
}
|
||
for _, v := range dynamic {
|
||
fmt.Println(v)
|
||
}
|
||
fmt.Println("---------------------")
|
||
}
|
||
}
|
||
}
|
||
return dynamic[len(A)][len(B)]
|
||
}
|
||
|
||
func TestShopList(t *testing.T) {
|
||
result, err := api.ShopList(25)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
fmt.Println("aaaaaaa", len(result.List))
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestWareSave(t *testing.T) {
|
||
// desc := `<p>因生鲜比较脆弱，发货途中如果有磕碰损坏，请收到联系客服，闪电赔付。请核对好地址，发货后不可修改地址，因改地址导致损坏不能赔付，谢谢理解</p><p><img style="width:auto;height:auto;max-width:100%;" src="//img10.360buyimg.com/imgzone/jfs/t1/126814/22/1326/472568/5ebb888dEa2cfb5f6/c0c81db660994246.jpg"><br></p><p><br></p>`
|
||
params := &WareSaveParam{
|
||
WareID: 0,
|
||
Height: 100,
|
||
CategoryID: 13574,
|
||
LastCategoryID: 13574,
|
||
VenderID: 10569615,
|
||
BrandID: 44259,
|
||
Length: 200,
|
||
Wide: 100,
|
||
WareStatus: 8,
|
||
Title: "散养土鸡蛋新鲜鸡蛋草鸡蛋柴鸡蛋顺丰包邮测试",
|
||
Weight: "1",
|
||
ShopCategorys: []int{15602325},
|
||
Notes: `
|
||
<p><img src="//img10.360buyimg.com/imgzone/jfs/t1/152741/14/7416/273609/5fbf645aEa1f7d6b7/dc1d9d997fe346b7.jpg" style="width: auto; height: auto; max-width: 100%;"><br></p><p><br></p>
|
||
`,
|
||
Skus: []*WareSaveSkus{
|
||
&WareSaveSkus{
|
||
// SkuID: 10024685331653,
|
||
JdPrice: "25",
|
||
StockNum: 9999,
|
||
Props: []*WareSaveSkusProp{
|
||
&WareSaveSkusProp{
|
||
AttrID: 1001027603,
|
||
AttrValues: 2517633718,
|
||
AttrValueAlias: "20个",
|
||
},
|
||
},
|
||
OuterID: "6045735",
|
||
},
|
||
// &WareSaveSkus{
|
||
// JdPrice: "31",
|
||
// StockNum: 5,
|
||
// Props: []*WareSaveSkusProp{
|
||
// &WareSaveSkusProp{
|
||
// AttrID: 1000022043,
|
||
// AttrValues: 2515430634,
|
||
// AttrValueAlias: "500g",
|
||
// },
|
||
// },
|
||
// },
|
||
},
|
||
PromiseID: 0,
|
||
MultiCateProps: []interface{}{},
|
||
PropsSet: []interface{}{},
|
||
SaleAttrs: []interface{}{},
|
||
TransparentImageAudit: []interface{}{},
|
||
OptionType: 1,
|
||
AvailableFeatures: []interface{}{},
|
||
CharacteristicService: []interface{}{},
|
||
ExtendFeatures: []interface{}{},
|
||
TempID: "10569615110055200", //必须要这个东西，不知道是啥
|
||
}
|
||
params.ImageMap.Num0000000000 = append(params.ImageMap.Num0000000000, &CreateSkuParamImages{
|
||
ColorID: "0000000000",
|
||
ImgIndex: 1,
|
||
ImgURL: "jfs/t1/149724/17/15786/39416/5fbf645aE948e4d7a/b13bcaee129676b2.jpg",
|
||
// ImgZoneID: "0000000000",
|
||
})
|
||
// , &CreateSkuParamImages{
|
||
// ColorID: "0000000000",
|
||
// ImgIndex: 2,
|
||
// ImgURL: "jfs/t1/142006/30/15024/504060/5fb636d4Ef12079f7/2adad323cbcf7c52.jpg",
|
||
// // ImgZoneID: "0000000000",
|
||
// })
|
||
result, err := api.WareSave(params)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestWareDoUpdate(t *testing.T) {
|
||
err := api.WareDoUpdate("up", "10020536451427")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestStoreWareDoUpdate(t *testing.T) {
|
||
err := api.StoreWareDoUpdate(1, 10024685331653, "1000063128")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestStoreUpdatePrice(t *testing.T) {
|
||
err := api.StoreUpdatePrice("16", 10033611936135, "1000116473")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestStoreUpdateStock(t *testing.T) {
|
||
err := api.StoreUpdateStock(80, 10024685331653, "1000063128")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestStoreSkuBindStore(t *testing.T) {
|
||
err := api.StoreSkuBindStore(false, []string{"10024685331653"}, []string{"1000063128"})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestSetOrderStateToWait(t *testing.T) {
|
||
err := api.SetOrderStateToWait(1)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
func TestStoreProductSearch(t *testing.T) {
|
||
result, _, err := api.StoreProductSearch(1, 20, []string{"1000069025"})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Log(utils.Format4Output(result, false))
|
||
}
|
||
|
||
//二进制转十六进制
|
||
func btox(b string) string {
|
||
base, _ := strconv.ParseInt(b, 2, 10)
|
||
return strconv.FormatInt(base, 16)
|
||
}
|
||
|
||
//十六进制转二进制
|
||
func xtob(x string) string {
|
||
base, _ := strconv.ParseInt(x, 16, 10)
|
||
return strconv.FormatInt(base, 2)
|
||
}
|
||
|
||
func h8l82int(h, l string) (i int64) {
|
||
s1, s2 := xtob(h), xtob(l)
|
||
flag1 := 8 - len(s1)
|
||
flag2 := 8 - len(s2)
|
||
for m := 0; m < flag1; m++ {
|
||
s1 = "0" + s1
|
||
}
|
||
for j := 0; j < flag2; j++ {
|
||
s2 = "0" + s2
|
||
}
|
||
i, _ = strconv.ParseInt(s1+s2, 2, 32)
|
||
return i
|
||
}
|
||
|
||
func TestUpdateStatus(t *testing.T) {
|
||
//data2 := []byte{0x00, 0x01}
|
||
//key := RandStringBytes(16)
|
||
//data, _ := Utf8ToGbk([]byte("[v2]"))
|
||
//fmt.Println(int2h8l8(int64(len("fd003401005b76325dc8d5d5d5cfe3c2afc9fad7cfd1cca3acd2a3bfb4c6d9b2bcb9d2c7b0b4a8a3acb7c9c1f7d6b1cfc2c8fdc7a7b3dfa3acd2c9cac7d2f8bad3c2e4bec5ccec") / 2)))
|
||
//fmt.Println(hex.EncodeToString(data))
|
||
//fmt.Println(fmt.Sprintf("%x", len("fd003401005b76325dc8d5d5d5cfe3c2afc9fad7cfd1cca3acd2a3bfb4c6d9b2bcb9d2c7b0b4a8a3acb7c9c1f7d6b1cfc2c8fdc7a7b3dfa3acd2c9cac7d2f8bad3c2e4bec5ccec")/2))
|
||
//mobile := &alipayapi.KeyMobile{}
|
||
//data, _ := base64.StdEncoding.DecodeString("QWja44PbYifX70Y74N3PU2dG2VedZFqqeXJhXV8g9cALnCOyXt25K6z2RQtAXlJR")
|
||
//key, _ := base64.StdEncoding.DecodeString("GHp3ojlVYRRu2XID4FX2ew==")
|
||
//iv := []byte{}
|
||
//iv = append(iv, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
|
||
//if result, err := utils.AESCBCDecpryt(data, key, iv); err == nil && result != nil {
|
||
// json.Unmarshal(result, &mobile)
|
||
//}
|
||
//fmt.Println(utils.Format4Output(mobile, true))
|
||
//data := "1e00180200015032303231303631353030303031308628e9"
|
||
//orderNo := h8l82int(data[len(data)-6:len(data)-4], data[len(data)-4:len(data)-2])
|
||
//base, _ := strconv.ParseInt(data[len(data)-6:len(data)-4]+data[len(data)-4:len(data)-2], 16, 10)
|
||
i, _ := strconv.ParseInt("8628", 16, 32)
|
||
fmt.Println(xtob("86"), xtob("28"), i)
|
||
}
|
||
|
||
func sss() (data2 []byte) {
|
||
dataLen := 34
|
||
data2 = make([]byte, 2)
|
||
data2[0] = (uint8)((dataLen & 0xFF00) >> 8)
|
||
data2[1] = (uint8)(dataLen & 0xFF)
|
||
return data2
|
||
}
|
||
|
||
func Utf8ToGbk(str []byte) (b []byte, err error) {
|
||
r := transform.NewReader(bytes.NewReader(str), simplifiedchinese.GBK.NewEncoder())
|
||
b, err = ioutil.ReadAll(r)
|
||
if err != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
func int2h8l8(i int64) (h, l string) {
|
||
origin2 := fmt.Sprintf("%b", i)
|
||
flag := 16 - len(origin2)
|
||
for i := 0; i < flag; i++ {
|
||
origin2 = "0" + origin2
|
||
}
|
||
begin8 := origin2[:8]
|
||
end8 := origin2[8:]
|
||
r1, _ := strconv.ParseInt(begin8, 2, 32)
|
||
r2, _ := strconv.ParseInt(end8, 2, 32)
|
||
h = fmt.Sprintf("%x", r1)
|
||
l = fmt.Sprintf("%x", r2)
|
||
if len(h) < 2 {
|
||
h = "0" + h
|
||
}
|
||
if len(l) < 2 {
|
||
l = "0" + l
|
||
}
|
||
return h, l
|
||
}
|
||
|
||
func Hextob(str string) []byte {
|
||
slen := len(str)
|
||
bHex := make([]byte, len(str)/2)
|
||
ii := 0
|
||
for i := 0; i < len(str); i = i + 2 {
|
||
if slen != 1 {
|
||
ss := string(str[i]) + string(str[i+1])
|
||
bt, _ := strconv.ParseInt(ss, 16, 32)
|
||
bHex[ii] = byte(bt)
|
||
ii = ii + 1
|
||
slen = slen - 2
|
||
}
|
||
}
|
||
return bHex
|
||
}
|