zhangzengfei
2024-10-20 b916f7c68a3e16413eac4be13f0404267561f90c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package pkg
 
import (
    "fmt"
    "strconv"
    "strings"
)
 
// 已弃用
// 生成一个包含楼层的人脸id,解析楼层
// 使用48位源id, 其中前41位是imageid, 不可以修改 41-43位填 06 代表图像, +99 + 3位楼层(第一位0表示正,1表示负)
func GenerateFaceIdContainFloor(srcId, floorStr string) string {
    floorNum, _ := ParseFloor("0", floorStr)
    newId := srcId[0:43] + "99" + floorNum
    //newId := srcId[0:43] + "99" + floorNum + snowflake.CreateRandomNumber(1)
 
    return newId
}
 
func ParseFloorFromId(srcId string) (string, string, error) {
    if len(srcId) != 48 {
        return "", "", fmt.Errorf("invalid id %s", srcId)
    }
 
    if srcId[43:45] != "99" {
        return "", "", fmt.Errorf("invalid flag %s", srcId[43:45])
    }
 
    return RestoreFloor(srcId[45:48])
}
 
// ParseFloor parses the floor string and returns a three-character string
func ParseFloor(direction, floor string) (string, error) {
    var sign string
    var number string
 
    // Check if the floor is negative
    if strings.HasPrefix(floor, "-") {
        sign = "1"
        number = floor[1 : len(floor)-1]
    } else {
        sign = "0"
        number = floor[:len(floor)-1]
    }
 
    // Convert the number to an integer to validate and ensure it is a valid number
    if _, err := strconv.Atoi(number); err != nil {
        return "", err
    }
 
    // Format the number to be two digits
    formattedNumber := fmt.Sprintf("%02s", number)
 
    return direction + sign + formattedNumber, nil
}
 
// RestoreFloor restores the three-character string back to the original floor string
func RestoreFloor(encoded string) (string, string, error) {
    var direction, sign uint8
    var floorNumber, floorStr, directionStr string
 
    // 3位是旧的格式, 为了兼容, 暂时保留
    if len(encoded) == 3 {
        sign = encoded[0]
        floorNumber = encoded[1:]
    } else if len(encoded) == 4 {
        direction = encoded[0]
        sign = encoded[1]
        floorNumber = encoded[2:]
    } else {
        return "", "", fmt.Errorf("encoded string must be 3 characters long")
    }
 
    // Convert the number back to integer to remove any leading zeros
    parsedNumber, err := strconv.Atoi(floorNumber)
    if err != nil {
        return "", "", err
    }
 
    if sign == '1' {
        floorStr = fmt.Sprintf("-%dF", parsedNumber)
    } else if sign == '0' {
        floorStr = fmt.Sprintf("%dF", parsedNumber)
    } else {
        return "", "", fmt.Errorf("invalid sign character in encoded string")
    }
 
    if direction == '1' {
        directionStr = "in"
    } else if direction == '2' {
        directionStr = "out"
    }
 
    return directionStr, floorStr, nil
}