Skip to content

D
dc_golang_server_1
Commit ca8e0ad0 by zhangjiec
Options

初始工程

parents
Showing with 2650 additions and 0 deletions
.idea/.gitignore 0 → 100644
# 默认忽略的文件
/shelf/
/workspace.xml
# 数据源本地存储已忽略文件
/dataSources/
/dataSources.local.xml
# 基于编辑器的 HTTP 客户端请求
/httpRequests/
.idea/dc_golang_server_1.iml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<module type="WEB_MODULE" version="4">
<component name="Go" enabled="true" />
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>
\ No newline at end of file
.idea/modules.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/dc_golang_server_1.iml" filepath="$PROJECT_DIR$/.idea/dc_golang_server_1.iml" />
</modules>
</component>
</project>
\ No newline at end of file
.idea/vcs.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>
\ No newline at end of file
api/readme.md 0 → 100644
一、管理后台接口
1. 后台用户登录
传：LoginAccount、Password、验证码
成功则进入首页
成功回：token，Name， 菜单按钮权限，首页展示内容(后面做统计内容，现在先全为空)
2.
\ No newline at end of file
api/router.go 0 → 100644
package api
import (
"dc_golang_server_1/config"
"dc_golang_server_1/logger"
"dc_golang_server_1/middleware"
"fmt"
"github.com/gin-gonic/gin"
)
func InitRouter() { //*gin.Engine{
gin.SetMode(config.HttpServerMode)
r := gin.New()
r.Use(logger.HttpGinLog(), gin.Recovery())
r.Use(middleware.Cors()) //全局跨域 局部跨域的话在路由组里面去添加
r.Use(middleware.JwtToken()) //jwt 还是在对应需要token的路由组添加
user := r.Group("user/")
user.Use(middleware.JwtToken())
{ // 需要token的
//user.GET("users",GetUsers)
}
// 登录：用户名，密码，验证码 返回token 返回用户信息、账号、token、菜单权限
//
// 会员管理：
//家长信息(ID，微信UNIONID,手机号,昵称,注册时间,最后一次登录时间,卡用户绑定状态)
//学生信息(ID, 家长ID, 区域, 名字, 性别, 生日，年级，班级，学号，注册时间) 校区ID、家长ID、家长手机、学生名字
// 基础数据
// 区域
//router := r.Group("api/")
{
//router.POST()
}
err := r.Run(config.HttpServerPort)
if err != nil {
panic(err)
}
fmt.Println("GAME OVER")
}
cache/cache.go 0 → 100644
package cache
import (
"sync"
)
/*****************************************************后台管理账户*/
//var adminMap sync.Map //后台管理账户
//type AdminStruct struct {
// AdminID int
//
//}
/*---------------------------------------------------------------*/
/*********************************************************代理商**/
//// AgentMap 代理商
//var AgentMap sync.Map
/*---------------------------------------------------------------*/
/*********************************************************运营商**/
var operatorMap sync.Map //运营商id作为KEY
type OperatorStruct struct {
ShortName string
AreaID []int //区域ID
// 可再添加运营商属性
}
/*---------------------------------------------------------------*/
/******************************************************区域(校区)服务信息**/
var areaServiceMap sync.Map //area_service_id 作为KEY AreaStruct 作为VALUE
type AreaServiceStruct struct { //
AreaID int
ServiceID uint8 //服务项目 1公话 2定位 3饮水 4POS .........
OperatorID int32 //运营商ID
Name string //服务名字(例宿舍135栋饮水)name
Status bool //状态
}
/*---------------------------------------------------------------*/
/******************************************************后台管理用户**/
var adminMap sync.Map //后台管理用户 LoginAccount(string) 作为KEY
type AdminStruct struct {
Password [16]byte
tokenCreatTime uint32
Name string
//Phone string
//OperatorID []int
SystemAuth int //系统角色权限
AreaServiceAuth [][]int //area_service_id,role_id
}
/*---------------------------------------------------------------*/
// roleAuthMap /****************************角色权限(包含区域和系统角色)*/
var roleAuthMap sync.Map //role_id 作为KEY
type RoleAuthStruct struct {
Name string
// 考虑接口、菜单、按钮权限
}
/*---------------------------------------------------------------*/
/******************************************************区域(校区)**/
var areaMap sync.Map //area_id 作为KEY AreaStruct 作为VALUE
type AreaStruct struct { // AreaStruct 区域信息缓存，通过区域ID查出,后续再加支付信息
// OperatorID int32 //运营商ID
Name string
Status bool //校区状态
ServicePhone bool
ServiceWater bool
ServiceLocation bool
ServicePos bool
}
/*---------------------------------------------------------------*/
/***************************************************微信用户(家长)**/
var wechatCustomerMap sync.Map //微信的WechatUnionID(string)作为KEY
type WechatCustomerStruct struct {
tokenCreatTime uint32
CardUserID []int
}
/****************************************************************/
/***************************************************卡用户(学生)**/
var cardUserMap sync.Map //卡用户 CardUserID卡用户ID(int) 作为KEY
type CardUserType struct {
// WechatUnionID string
// AreaID int
AreaServiceID int
Name string
Sex uint8
// Birthday
Grade uint8
Class uint8
StudentNo string
Card CardStruct
}
type CardStruct struct {
Sim []string //电话卡 这里考虑下是否允许多张
Water []uint32 //水卡
Location []uint32 //定位卡
Pos []uint32 //pos消费卡
}
/*---------------------------------------------------------------*/
/*******************************************************电话设备**/
var phone20DeviceMap sync.Map //device_id 作为KEY Phone20DeviceStruct 作为VALUE
type Phone20DeviceStruct struct {
AreaServiceID int
AllowCallTime uint8 //允许通话时长,255表示不限制时长
Status bool
}
/*---------------------------------------------------------------*/
/********************************************************Sim卡信息**/
var simInfoMap sync.Map //card_id 作为KEY
type SimInfoStruct struct {
CardUserID int //卡用户ID
Status int8 //0没得这个数据 1 正常使用 其他各种异常
MonthTalkMinutes uint16
MonthPackageMinutes uint16
FamilyNum []FamilyOnePerson
}
type FamilyOnePerson struct {
Phone string
Nickname string
}
/*---------------------------------------------------------------*/
///********************************************************Sim卡信息(允许一卡多校区使用)**/
//var simInfoMap sync.Map //card_id 作为KEY
//type SimInfoStruct struct {
// Status int8 //0没得这个数据 1 正常使用 其他各种异常
// MonthTalkMinutes uint16
// MonthPackageMinutes uint16
// AreaFamilyNum []sync.Map //area_id为KEY , []familyOnePerson 为 VALUE
//}
//type FamilyOnePerson struct {
// Phone string
// Nickname string
//}
///*---------------------------------------------------------------*/
///*******************************************************定位设备**/
//var phone20DeviceMap sync.Map //device_id 作为KEY DeviceStruct 作为VALUE
//type Phone20DeviceStruct struct {
// AreaID int32
// AllowCallTime uint8 //允许通话时长,255表示不限制时长
// Status bool
//}
///*---------------------------------------------------------------*/
//
//
///*******************************************************饮水设备**/
//var phone20DeviceMap sync.Map //device_id 作为KEY DeviceStruct 作为VALUE
//type Phone20DeviceStruct struct {
// AreaID int32
// AllowCallTime uint8 //允许通话时长,255表示不限制时长
// Status bool
//}
///*---------------------------------------------------------------*/
func Init() {
initOperatorMap()
initWechatCustomerMap()
initCardUserMap()
initAreaMap()
initPhone20DeviceMap()
initSimFamilyNumMap()
}
cache/cmap_area.go 0 → 100644
package cache
import (
"dc_golang_server_1/dbmodel"
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"log"
"time"
)
func initAreaMap() {
fmt.Println(time.Now(), "cache: initDeviceMap begin")
var areaID int32
var temp AreaStruct
rows, err := dbmodel.PgDb.Query("SELECT id,name,status FROM b_area")
defer rows.Close()
if err != nil {
log.Panicln("SelectAreaToMap rows", err)
}
for rows.Next() {
err = rows.Scan(&areaID, &temp.Name, &temp.Status)
if err != nil {
log.Panicln("SelectAreaToMap rows.Scan", err)
}
phone20DeviceMap.Store(areaID, temp)
}
// 处理完毕后，需要判断一次遍历过程中是否有错误产生
if err = rows.Err(); err != nil {
logger.Log.Error("rows.Err()",
zap.Error(err),
zap.String("src", "initAreaMap"))
fmt.Println(time.Now(), "initAreaMap rows.Err()", err)
} else {
fmt.Println(time.Now(), "cache: initAreaMap end")
}
}
func GetAreaInfo(areaID int32) AreaStruct {
if info, ok := areaMap.Load(areaID); ok { //map有
if v, ok2 := info.(AreaStruct); ok2 { //类型断言正确
return v //,true
} else { //类型断言失败
areaMap.Delete(areaID)
logger.Log.Error("AreaMap 类型断言错误",
zap.Int32("areaID", areaID),
zap.String("src", "GetAreaInfo"))
}
}
var temp AreaStruct
var err error
for i := 0; i < 100; i++ {
err = dbmodel.PgDb.QueryRow("SELECT name,status FROM b_area WHERE id=$1",
areaID).Scan(&temp.Name, &temp.Status)
if err != nil {
fmt.Println("GetAreaInfo SELECT:", i, err)
time.Sleep(3 * time.Millisecond)
continue
}
areaMap.Store(areaID, temp)
logger.Log.Error("数据库有而缓存没有 GetAreaInfo",
zap.Int32("areaID", areaID),
zap.Error(err),
zap.String("src", "GetAreaInfo"))
return temp //,true
}
logger.Log.Error("GetAreaInfo SELECT operator_id,status FROM b_area WHERE id=$1",
zap.Int32("areaID", areaID),
zap.Error(err),
zap.String("src", "getDeviceInfo"))
return temp //,false
}
cache/cmap_carduser.go 0 → 100644
package cache
func initCardUserMap() {
}
cache/cmap_operator.go 0 → 100644
package cache
func initOperatorMap() { //todo 查询b_operator表得到ID和short_name; 查询b_area表得到AreaID
}
func GetOperatorMap(id int) OperatorStruct {
var temp OperatorStruct
return temp
}
cache/cmap_phone20device.go 0 → 100644
package cache
import (
"dc_golang_server_1/dbmodel"
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"log"
"time"
)
func initPhone20DeviceMap() {
fmt.Println(time.Now(), "cache: initDeviceMap begin")
var devID uint32
var temp Phone20DeviceStruct
rows, err := dbmodel.PgDb.Query("SELECT id,area_service_id,allow_call_time,status FROM d_device")
defer rows.Close()
if err != nil {
log.Panicln("SelectDeviceToMap rows", err)
}
for rows.Next() {
err = rows.Scan(&devID, &temp.AreaServiceID, &temp.AllowCallTime, &temp.Status)
if err != nil {
log.Panicln("SelectDeviceToMap rows.Scan", err)
}
phone20DeviceMap.Store(devID, temp)
}
// 处理完毕后，需要判断一次遍历过程中是否有错误产生
if err = rows.Err(); err != nil {
logger.Log.Error("rows.Err()",
zap.Error(err),
zap.String("src", "initDeviceMap"))
fmt.Println(time.Now(), "initDeviceMap rows.Err()", err)
} else {
fmt.Println(time.Now(), "cache: initDeviceMap end")
}
}
func GetDeviceInfo(devID uint32) Phone20DeviceStruct {
if info, ok := phone20DeviceMap.Load(devID); ok { //map有
if v, ok2 := info.(Phone20DeviceStruct); ok2 { //类型断言正确
return v //,true
} else { //类型断言失败
phone20DeviceMap.Delete(devID)
logger.Log.Error("DeviceMap 类型断言错误",
zap.Uint32("devID", devID),
zap.String("src", "getDeviceInfo"))
}
}
var temp Phone20DeviceStruct
var err error
for i := 0; i < 100; i++ {
err = dbmodel.PgDb.QueryRow("SELECT area_service_id,allow_call_time,status FROM d_device WHERE id=$1",
devID).Scan(&temp.AreaServiceID, &temp.AllowCallTime, &temp.Status)
if err != nil {
fmt.Println("getDeviceInfo SELECT:", i, err)
time.Sleep(3 * time.Millisecond)
continue
}
phone20DeviceMap.Store(devID, temp)
logger.Log.Error("数据库有而缓存没有 getDeviceInfo",
zap.Uint32("devID", devID),
zap.Error(err),
zap.String("src", "getDeviceInfo"))
return temp //,true
}
logger.Log.Error("getDeviceInfo SELECT area_id,allow_call_time,status FROM d_device WHERE id=$1",
zap.Uint32("devID", devID),
zap.Error(err),
zap.String("src", "getDeviceInfo"))
return temp //,false
}
cache/cmap_siminfo.go 0 → 100644
package cache
func initSimFamilyNumMap() {
//fmt.Println(time.Now(),"cache: initSimFamilyNumMap begin")
//var keyTemp simFamilyNumMapKeyStruct
//var newValue familyOnePerson
//var ok bool
//rows, err := model.PgDb.Query("SELECT card_id,phone,nickname,area_id FROM u_sim_family_num ORDER BY create_at")
//defer rows.Close()
//if err != nil{
// log.Panicln("SelectUserSimFamilyNumToMap rows",err)
//}
//for rows.Next() {
// var bufStruct SimFamilyNumStruct
// err = rows.Scan(&keyTemp.CardId,&newValue.Phone,&newValue.Nickname,&keyTemp.AreaId)
// if err != nil{
// log.Panicln("SelectUserSimFamilyNumToMap rows.Scan",err)
// }
// if bo,ok2 := simFamilyNumMap.Load(keyTemp); ok2 { //map已经有了,就不去查u_sim_info了
// if bufStruct, ok = bo.(SimFamilyNumStruct); ok == false { //类型断言错误
// simFamilyNumMap.Delete(keyTemp)
// logger.Log.Error("SimFamilyNumMap 类型断言错误",
// zap.String("cardId", keyTemp.CardId),
// zap.Int32("area_id", keyTemp.AreaId),
// zap.String("src", "InitSimFamilyNumMap"))
// err = model.PgDb.QueryRow("SELECT month_talk_minutes,month_package_minutes,status FROM u_sim_info WHERE card_id=$1",
// keyTemp.CardId).Scan(&bufStruct.MonthTalkMinutes,&bufStruct.MonthPackageMinutes,&bufStruct.Status)
// if err != nil {
// logger.Log.Error("已绑定亲情号码的卡号居然在u_sim_info查不到",
// zap.String("cardId", keyTemp.CardId),
// zap.Int32("area_id", keyTemp.AreaId),
// zap.String("src", "InitSimFamilyNumMap"))
// continue
// }
// }
// } else {
// err = model.PgDb.QueryRow("SELECT month_talk_minutes,month_package_minutes,status FROM u_sim_info WHERE card_id=$1",
// keyTemp.CardId).Scan(&bufStruct.MonthTalkMinutes,&bufStruct.MonthPackageMinutes,&bufStruct.Status)
// if err != nil {
// logger.Log.Error("已绑定亲情号码的卡号居然在u_sim_info查不到",
// zap.String("cardId", keyTemp.CardId),
// zap.Int32("area_id", keyTemp.AreaId),
// zap.String("src", "InitSimFamilyNumMap"))
// continue
// }
// }
// //map里还没有，新存一条
// bufStruct.Family = append(bufStruct.Family,newValue)
// simFamilyNumMap.Store(keyTemp,bufStruct)
//}
//// 处理完毕后，需要判断一次遍历过程中是否有错误产生
//if err = rows.Err();err != nil{
// logger.Log.Error("rows.Err()",
// zap.Error(err),
// zap.String("src", "InitSimFamilyNumMap"))
// fmt.Println(time.Now(),"initSimFamilyNumMap rows.Err()",err)
//} else {
// fmt.Println(time.Now(),"cache: initSimFamilyNumMap end")
//}
}
func GetSimFamilyNum(areaId int32, cardId string) []FamilyOnePerson {
//if s,ok := simFamilyNumMap.Load(simFamilyNumMapKeyStruct{
// areaId,
// cardId,
//});ok{ // map有
// if sim,ok4 := s.(SimFamilyNumStruct);ok4 { //类型断言正确
// return sim
// } else { //类型断言失败
// simFamilyNumMap.Delete(simFamilyNumMapKeyStruct{
// areaId,
// cardId,
// })
// logger.Log.Error("simFamilyNumMap 类型断言错误",
// zap.String("cardId", cardId),
// zap.Int32("area_id", areaId),
// zap.String("src", "GetSimFamilyNum"))
// }
//}
//
var temp []FamilyOnePerson
//
//// todo 再去查一盘库
return temp
}
// AddSimMonthTalkMinutes 缓存里增加本月通话分钟数
func AddSimMonthTalkMinutes(AreaId int32, CardId string) {
}
cache/cmap_wechatcustomer.go 0 → 100644
package cache
func initWechatCustomerMap() {
}
config.ini 0 → 100644
[database]
#阿里云9.9 外网
dbDSN = "user=higher password=hj^&bhjb789j$^* dbname=dctest1 host=pgm-2ze3yp0bss39cxvh1o.pg.rds.aliyuncs.com port=1921 sslmode=disable"
#阿里云9.9 内网 pgm-2ze3yp0bss39cxvh129210.pg.rds.aliyuncs.com
#dbDSN = "user=higher password=hj^&bhjb789j$^* dbname=jeff_study host=pgm-2ze3yp0bss39cxvh129210.pg.rds.aliyuncs.com port=1921 sslmode=disable"
#chengdu-office 内网 192.168.1.42:5432
#dbDSN = "user=postgres password=buzhidao123. dbname=dctest1 host=192.168.1.42 port=5432 sslmode=disable"
#chengdu-office 外网 to-chengdu-office.168cad.top:50032
#dbDSN = "user=postgres password=buzhidao123 dbname=dctest1 host=to-chengdu-office.168cad.top port=50032 sslmode=disable"
#ECS外网
#DbDSN = "user=postgres password=buzhidao123. dbname=testlog host=60.205.190.129 port=5432 sslmode=disable"
#ECS内网
#DbDSN = "user=postgres password=buzhidao123. dbname=testlog host=127.0.0.1 port=5432 sslmode=disable"
[http_server]
#debug release
ServerMode = release
ServerPort = :50000
[tcp_long_server]
#TCP服务监听的端口号
TcpPort = 60000
#TCP 最大连接数限制,建议设置实际设备数量的2.5倍
MaxConnections = 20000
#新建立的TCP连接，连上后多久完全没收到数据就判断为非法设备断掉,单位秒
NewConnReadDeadline = 60
#新建立的TCP连接，连上后多久没收到合法完整数据就判断为非法设备断掉,单位秒
NewConnRightfulTimeout = 120
#老连接(已验证通过确实是合法设备的tcp连接),多久没收到数据就断掉,这里设置为3倍心跳时间(若同一台设备建立了新连接，系统会立即释放老连接)
OldConnReadDeadline = 180
[log]
#debug info warn error 只允许设置这3个等级,以保证至少记录error DPanic Panci Fatal
#debug info: 记录流水数据(都存在info.log里)
#warn: 应检查原因,主要来自外部
#error DPanic Panci Fatal: 应立即检查原因来内部或硬件设备或业务服务器
Level = warn
#log文件的存储路径
Path = ./log/
#单个日志文件大小限制，单位MB
FileMaxSize = 10
#info级别日志最多保存多少份
InfoMaxFileNum = 30
#info日志最长保留天数
InfoWithMaxAge = 30
#warn级别日志最多保存多少份
WarnMaxFileNum = 30
#warn日志最长保留天数
WarnWithMaxAge = 90
#Error级别日志最多保存多少份
ErrorMaxFileNum = 10
#Error日志最长保留天数s
ErrorWithMaxAge = 180
config/setting.go 0 → 100644
package config
import (
"go.uber.org/zap/zapcore"
"gopkg.in/ini.v1"
"time"
)
var (
DbDSN string
HttpServerMode string
HttpServerPort string
TcpLongPort string
TcpLongMaxConnections int32
TcpLongNewConnReadDeadline time.Duration
TcpLongNewConnRightfulTimeout int64
TcpLongOldConnReadDeadline time.Duration
LogLevel zapcore.Level
LogPath string
LogFileMaxSize int // 单个日志文件的最大MB
LogInfoMaxFileNum int
LogInfoMaxFileDay int
LogWarnMaxFileNum int
LogWarnMaxFileDay int
LogErrorMaxFileNum int
LogErrorMaxFileDay int
)
func ConfigInit() {
file, err := ini.Load("./config.ini")
if err != nil {
// logger.Log.Panic("配置文件读取错误")
panic("配置文件读取错误")
}
DbDSN = file.Section("database").Key("dbDSN").MustString("user=higher password=hj^&bhjb789j$^* dbname=jeff_study host=pgm-2ze3yp0bss39cxvh1o.pg.rds.aliyuncs.com port=1921 sslmode=disable")
HttpServerMode = file.Section("http_server").Key("ServerMode").In("release", []string{"release", "debug"})
HttpServerPort = file.Section("http_server").Key("ServerPort").MustString(":50000")
TcpLongPort = file.Section("tcp_long_server").Key("TcpPort").MustString("60000")
TcpLongMaxConnections = int32(file.Section("tcp_long_server").Key("MaxConnections").MustUint(20000))
TcpLongNewConnReadDeadline = time.Duration(file.Section("tcp_long_server").Key("NewConnReadDeadline").MustInt(60)) * time.Second
TcpLongNewConnRightfulTimeout = file.Section("tcp_long_server").Key("NewConnRightfulTimeout").MustInt64(120)
TcpLongOldConnReadDeadline = time.Duration(file.Section("tcp_long_server").Key("OldConnReadDeadline").MustInt(180)) * time.Second
logLvlStr := file.Section("log").Key("Level").In("warn", []string{"trace", "debug", "info", "warn", "error"})
switch logLvlStr {
case "debug":
LogLevel = zapcore.DebugLevel
case "info":
LogLevel = zapcore.InfoLevel
case "warn":
LogLevel = zapcore.WarnLevel
case "error":
LogLevel = zapcore.ErrorLevel
}
LogPath = file.Section("log").Key("Path").MustString(".log")
LogFileMaxSize = file.Section("log").Key("FileMaxSize").MustInt(10)
LogInfoMaxFileNum = file.Section("log").Key("InfoMaxFileNum").MustInt(10)
LogInfoMaxFileDay = file.Section("log").Key("InfoWithMaxAge").MustInt(30)
LogWarnMaxFileNum = file.Section("log").Key("WarnMaxFileNum").MustInt(10)
LogWarnMaxFileDay = file.Section("log").Key("WarnWithMaxAge").MustInt(90)
LogErrorMaxFileNum = file.Section("log").Key("ErrorMaxFileNum").MustInt(10)
LogErrorMaxFileDay = file.Section("log").Key("ErrorWithMaxAge").MustInt(180)
}
dbmodel/d_device.go 0 → 100644
package dbmodel
//CREATE TABLE IF NOT EXISTS public.d_device
//(
//id bigint NOT NULL,
//area_id integer,
//service_code smallint,
//version_code character varying(3) COLLATE pg_catalog."default",
//place character varying(32) COLLATE pg_catalog."default",
//rate_id integer,
//status boolean,
//create_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP,
//update_at timestamp without time zone,
//CONSTRAINT d_device_pkey PRIMARY KEY (id)
//)
dbmodel/d_hex_command_err.go 0 → 100644
package dbmodel
import (
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"time"
)
//CREATE TABLE IF NOT EXISTS public.d_hex_command_err
//(
//device_id bigint NOT NULL,
//ciphertext character varying(512) COLLATE pg_catalog."default" NOT NULL,
//err character varying(32) COLLATE pg_catalog."default" NOT NULL,
//create_at timestamp without time zone NOT NULL DEFAULT CURRENT_TIMESTAMP
//)
//type TableDevHexCommandErr struct {
// devId uint32
// ciphertext string
// errMsg string
// createAt timestamp.Timestamp
//}
func InsertDevHexCommandErr(devId uint32, ciphertext string, errMsg string) {
var err error
for i := 0; i < 10; i++ {
_, err = PgDb.Exec("INSERT INTO d_hex_command_err VALUES($1,$2,$3)", devId, ciphertext, errMsg)
if err == nil {
return
}
fmt.Println("InsertDevHexCommandErr:", i, err)
time.Sleep(3 * time.Second)
}
logger.Log.Error("InsertDevHexCommandErr Err",
zap.Error(err))
}
dbmodel/d_hex_command_record.go 0 → 100644
package dbmodel
import (
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"time"
)
//CREATE TABLE IF NOT EXISTS public.d_hex_command_record
//(
//device_id bigint NOT NULL,
//dev_utc bigint NOT NULL,
//ctrl_code character(2) COLLATE pg_catalog."default" NOT NULL,
//data_len smallint NOT NULL,
//data_hex character varying(512) COLLATE pg_catalog."default",
//ciphertext character varying(512) COLLATE pg_catalog."default",
//direction smallint NOT NULL,
//create_at timestamp without time zone NOT NULL DEFAULT CURRENT_TIMESTAMP
//)
type TableDevHexCommandRecord struct {
DevID uint32
DevUtc uint32
CtrlCode string
DataLen uint8
DataHex string
Ciphertext string
Direction uint8
createAt time.Time
retry uint8 //测试用字段,后面压测完了可以删他妈的
}
func InsertDevHexCommandRecord(insertData TableDevHexCommandRecord) {
var err error
for i := 0; i < 10; i++ {
// _, err = StmtDevHexRecord.Exec(rData.DevID, rData.TimeUtc, strconv.FormatUint(uint64(rData.CtrlCode), 16), rData.Length, hex.EncodeToString(rData.Data[:rData.Length]), ciphertext, direction)
_, err = stmtInsertDevHexCommandRecord.Exec(insertData.DevID,
insertData.DevUtc,
insertData.CtrlCode,
insertData.DataLen,
insertData.DataHex,
insertData.Ciphertext,
insertData.Direction,
i,
)
if err == nil {
return
}
fmt.Println("InsertDevHexCommandRecord:", i, err)
time.Sleep(100 * time.Millisecond)
}
logger.Log.Error("InsertDevHexCommandRecord Error",
zap.Error(err))
}
dbmodel/d_hex_connect_record.go 0 → 100644
package dbmodel
import (
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"time"
)
//CREATE TABLE IF NOT EXISTS public.d_hex_connect_record
//(
//dev_id bigint NOT NULL,
//state smallint NOT NULL,
//create_at timestamp without time zone NOT NULL DEFAULT CURRENT_TIMESTAMP
//)
// state 0:新连接来了 1:设备正常离线 2:正常离线 3:新连接挤掉就连接 4:未知异常(连接池类型断言失败)
func DevHexConnectRecord(devId uint32, state uint8) {
var err error
for i := 0; i < 100; i++ {
_, err = stmtInsertDevHexConnectRecord.Exec(devId, state)
if err == nil {
return
}
fmt.Println("DevHexConnectRecord:", i, err)
time.Sleep(20 * time.Millisecond)
}
logger.Log.Error("DevHexConnectRecord Err",
zap.Error(err))
}
dbmodel/d_hex_reset_record.go 0 → 100644
package dbmodel
import (
"dc_golang_server_1/logger"
"fmt"
"go.uber.org/zap"
"time"
)
//CREATE TABLE IF NOT EXISTS public.d_hex_reset_record
//(
//device_id bigint NOT NULL,
//dev_utc bigint NOT NULL,
//reset_reason smallint NOT NULL,
//reset_code character varying(2) COLLATE pg_catalog."default",
//location point,
//firmware character varying(20) COLLATE pg_catalog."default",
//create_at timestamp without time zone NOT NULL DEFAULT CURRENT_TIMESTAMP
//)
type TableDevHexResetRecord struct {
DevId uint32
DevUtc uint32
ResetReason uint8
ResetCode string
Location [2]uint32
Firmware string
createAt time.Time
}
func InsertDevHexResetRecord(insertData TableDevHexResetRecord) {
var err error
for i := 0; i < 100; i++ {
_, err = stmtInsertDevHexCommandRecord.Exec(
insertData.DevId,
insertData.DevUtc,
insertData.ResetReason,
insertData.ResetCode,
insertData.Location[0],
insertData.Location[1],
insertData.Firmware,
)
if err == nil {
return
}
fmt.Println("InsertDevHexResetRecord:", i, err)
time.Sleep(100 * time.Millisecond)
}
logger.Log.Error("InsertDevHexResetRecord Err",
zap.Error(err))
}
dbmodel/db.go 0 → 100644
package dbmodel
import (
"database/sql"
"dc_golang_server_1/config"
_ "github.com/lib/pq"
)
var PgDb *sql.DB
var stmtInsertDevHexCommandRecord *sql.Stmt
var stmtInsertDevHexConnectRecord *sql.Stmt
var stmtInsertDevHexResetRecord *sql.Stmt
// var stmtInsertUCallRecordAndUpdateUSimInfo *sql.Stmt //用事务处理
var stmtInsertUserCardUser *sql.Stmt
func InitDb() {
var err error
PgDb, err = sql.Open("postgres", config.DbDSN)
if err != nil {
panic("数据库连接失败" + err.Error())
}
//PgDb.SetConnMaxLifetime()
//PgDb.SetConnMaxIdleTime()
//PgDb.SetMaxOpenConns()
//PgDb.Stats()
// 建立常用的预处理
stmtInsertDevHexCommandRecord, err = PgDb.Prepare("INSERT INTO d_command_record VALUES($1,$2,$3,$4,$5,$6,$7,$8)") //("INSERT INTO d_hex_command_record(device_id,ctrl_code,data_len,data_hex,ciphertext)VALUES($1,$2,$3,$4,$5)")
if err != nil {
panic("建立stmtDevHexCommandRecord失败:" + err.Error())
}
stmtInsertDevHexConnectRecord, err = PgDb.Prepare("INSERT INTO d_connect_record VALUES($1,$2)")
if err != nil {
panic("建立stmtDevHexConnectRecord失败:" + err.Error())
}
stmtInsertDevHexResetRecord, err = PgDb.Prepare("INSERT INTO d_reset_record VALUES($1,$2,$3,$4,point($5,$6),$7)")
if err != nil {
panic("建立stmtDevHexConnectRecord失败:" + err.Error())
}
//stmtInsertUserCallRecord, err = PgDb.Prepare("INSERT INTO u_call_record VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)")
//if err != nil {
// panic("建立stmtUserCallRecord失败:" + err.Error())
//}
stmtInsertUserCardUser, err = PgDb.Prepare("INSERT INTO u_card_user VALUES($1,$2,$3,$4,$5,$6,$7,$8)")
if err != nil {
panic("建立stmtUserCardUser失败:" + err.Error())
}
}
func CloseDb() {
_ = stmtInsertDevHexCommandRecord.Close()
_ = stmtInsertDevHexConnectRecord.Close()
_ = stmtInsertDevHexResetRecord.Close()
//_ = stmtInsertUCallRecordAndUpdateUSimInfo.Close()
_ = stmtInsertUserCardUser.Close()
_ = PgDb.Close()
}
dbmodel/u_call_record_sim_info.go 0 → 100644
package dbmodel
import (
"database/sql"
"dc_golang_server_1/logger"
"go.uber.org/zap"
"strings"
"time"
)
//CREATE TABLE IF NOT EXISTS public.u_call_record
//(
//customer_id integer,
//customer_name character varying(64) COLLATE pg_catalog."default",
//customer_phone character varying(12) COLLATE pg_catalog."default",
//card_user_id integer,
//card_user_name character varying(32) COLLATE pg_catalog."default",
//card_code character varying(32) COLLATE pg_catalog."default",
//card_type smallint,
//called_number character varying(12) COLLATE pg_catalog."default",
//called_nickname character varying(32) COLLATE pg_catalog."default",
//call_start_at timestamp without time zone,
//talk_time smallint,
//area_id integer,
//operator_id integer,
//device_id bigint,
//telephone_package_id integer,
//state smallint,
//create_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP
//)
type TableUserCallRecord struct {
CustomerId int32 //会员ID
CustomerPhone string //会员手机号 //character varying(11) COLLATE pg_catalog."default",
CardUserId int32 //卡用户ID //integer,
CardUserName string //卡用户姓名 character varying(32) COLLATE pg_catalog."default",
CardID string //卡ID character varying(32) COLLATE pg_catalog."default",
CardType int8 //卡类型 smallint,
CalledNumber string //被叫号码 character varying(12) COLLATE pg_catalog."default",
CalledNickname string //被叫昵称 character varying(32) COLLATE pg_catalog."default",
CallStartAt string //time.Time //通话开始时间 without time zone, .Format("2006-01-02 15:04:05.000"),
TalkTime int16 //通话时长 //integer,
AreaId int32 //区域(校区)ID //integer,
OperatorId int32 //运营商ID //integer,
DeviceId uint32 //设备ID //bigint,
Status uint8 //通话状态 //smallint,
CreateAt time.Time // timestamp without time zone DEFAULT CURRENT_TIMESTAMP
}
func clearTransaction(tx *sql.Tx) {
err := tx.Rollback()
if err != sql.ErrTxDone && err != nil {
logger.Log.Panic("InsertUCallRecordAndUpdateUSimInfo clearTransaction",
zap.Error(err))
}
}
func InsertUCallRecordAndUpdateUSimInfo(insertData TableUserCallRecord) uint8 { //0 成功 1 唯一约束重复 9 系统繁忙
tx, err := PgDb.Begin()
if err != nil {
logger.Log.Error("InsertUCallRecordAndUpdateUSimInfo PgDb.Begin():",
zap.Error(err))
return 9
}
defer clearTransaction(tx)
//先InsertUCallRecord
_, err = tx.Exec("INSERT INTO u_call_record(customer_id,customer_phone,card_user_id,card_user_name,card_id,card_type,called_number,called_nickname,call_start_at,talk_time,area_id,operator_id,device_id,status)VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)",
insertData.CustomerId,
insertData.CustomerPhone,
insertData.CardUserId,
insertData.CardUserName,
insertData.CardID,
insertData.CardType,
insertData.CalledNumber,
insertData.CalledNickname,
insertData.CallStartAt,
insertData.TalkTime,
insertData.AreaId,
insertData.OperatorId,
insertData.DeviceId,
insertData.Status,
)
if err != nil {
if strings.Contains(err.Error(), "duplicate key value") { //todo 这里应考虑去查出来看看内容是不是一样的
//fmt.Println("InsertUserCallRecord唯一约束重复", err)
return 1
}
logger.Log.Error("InsertUCallRecordAndUpdateUSimInfo InsertUserCallRecord:",
zap.Error(err))
return 9
}
//rowAffected, err := rs.RowsAffected()
//if err != nil {
// fmt.Println("插入电话记录表:rs.RowsAffected()", err)
// panic("反正是测试，先退出2")
//}
//fmt.Println(rowAffected)
_, err = tx.Exec("UPDATE u_sim_info SET total_talk_minutes=total_talk_minutes+$1 WHERE card_id=$2", (insertData.TalkTime+59)/60, insertData.CardID)
if err != nil {
logger.Log.Error("InsertUCallRecordAndUpdateUSimInfo UPDATE u_sim_info:",
zap.Error(err))
return 9
}
//rowAffected, err = rs.RowsAffected()
//if err != nil {
// fmt.Println("UPDATE u_sim_info:rs.RowsAffected()", err)
// panic("反正是测试，先退出4")
//}
//fmt.Println(rowAffected)
if err = tx.Commit(); err != nil {
logger.Log.Error("InsertUCallRecordAndUpdateUSimInfo Commit:",
zap.Error(err))
return 9
}
return 0
}
dbmodel/u_card_user.go 0 → 100644
package dbmodel
import "time"
//CREATE TABLE IF NOT EXISTS public.u_card_user
//(
//id integer NOT NULL DEFAULT nextval('u_card_user_id_seq'::regclass),
//customer_id integer,
//area_id integer,
//name character varying(32) COLLATE pg_catalog."default",
//sex smallint,
//birthday date,
//grade smallint,
//class smallint,
//student_no character varying(32) COLLATE pg_catalog."default",
//create_at timestamp without time zone,
//update_at timestamp without time zone,
//CONSTRAINT u_card_user_pkey PRIMARY KEY (id)
//)
type TableUserCardUser struct {
Id int32 //integer NOT NULL DEFAULT nextval('u_card_user_id_seq'::regclass),
CustomerId int32 //integer,
AreaId int32 //integer,
Name string //character varying(32) COLLATE pg_catalog."default",
Sex int8 //smallint,
Birthday time.Time
Grade int8 //smallint,
Class int8 //smallint,
StudentNo string //character varying(32) COLLATE pg_catalog."default",
CreateAt time.Time //timestamp without time zone,
UpdateAt time.Time //timestamp without time zone,
}
func InsertUserCardUser(insertData TableUserCardUser) int8 {
_, err := stmtInsertUserCardUser.Exec(
insertData.CustomerId,
insertData.AreaId,
insertData.Name,
insertData.Sex,
insertData.Birthday,
insertData.Grade,
insertData.Class,
insertData.StudentNo,
)
if err == nil {
return 0
}
return 1 //1
}
dbmodel/u_sim_family_num.go 0 → 100644
package dbmodel
import (
"time"
)
//CREATE TABLE IF NOT EXISTS public.u_sim_family_num
//(
//card_id character varying(32) COLLATE pg_catalog."default" NOT NULL,
//phone character varying(12) COLLATE pg_catalog."default",
//nickname character varying(32) COLLATE pg_catalog."default",
//area_id integer NOT NULL,
//create_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP,
//CONSTRAINT u_sim_family_num_pkey PRIMARY KEY (card_id, area_id)
//)
type TableUserSimFamilyNum struct {
CardId string //character varying(32) COLLATE pg_catalog."default",
Phone string //character varying(12) COLLATE pg_catalog."default",
Nickname string //character varying(32) COLLATE pg_catalog."default",
AreaId int32
CreateAt time.Time //timestamp without time zone DEFAULT CURRENT_TIMESTAMP
}
dbmodel/u_sim_info.go 0 → 100644
package dbmodel
//CREATE TABLE IF NOT EXISTS public.u_sim_info
//(
//card_id character varying(20) COLLATE pg_catalog."default",
//total_talk_minutes integer,
//month_talk_minutes integer,
//month_package_minutes integer,
//status smallint
//)
//type TableUserSimInfo struct {
// CardID string
//
//}
devproduct/dc_longtcp_hex_protocol.go 0 → 100644
package devproduct
import (
"dc_golang_server_1/dbmodel"
"dc_golang_server_1/logger"
"dc_golang_server_1/util"
"encoding/hex"
"go.uber.org/zap"
"net"
"strconv"
"time"
)
//type IDCLongTCPHex interface {
// receiveResponse(conn *net.TCPConn, data []byte, cnt int) bool
//}
type DCLongTCPHex struct {
TCPLongServer
password string
iv string
devType uint8
protocolAnalysis func(data *HexData) //HexData
}
//type Connection struct {
// conn *net.TCPConn
//}
type HexData struct {
TimeUtc uint32
//DevType uint8
DevID uint32
CtrlCode uint8
Length uint8
Data []byte
}
func /*(d *DCLongTCPHex)*/ insertDevHexCommandRecord(data *HexData, ciphertext string, direction uint8) {
go dbmodel.InsertDevHexCommandRecord(dbmodel.TableDevHexCommandRecord{
DevID: data.DevID,
DevUtc: data.TimeUtc,
CtrlCode: strconv.FormatUint(uint64(data.CtrlCode), 16),
DataLen: data.Length,
DataHex: hex.EncodeToString(data.Data[:data.Length]),
Ciphertext: ciphertext,
Direction: direction,
})
}
func (d *DCLongTCPHex) receiveResponse(conn *net.TCPConn, data []byte, nowConnDevID uint32) uint32 {
c, err := util.DecryptBase64ToBytes(data, d.password, d.iv)
if err != nil {
if nowConnDevID != 0 {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "Decrypt err")
}
return 0
}
if util.CheckCRC(c) == false {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "CheckCRC err")
return 0
}
cLen := len(c)
if cLen < 12 {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "cLen<12")
return 0
} else if int(c[9])+12 != cLen {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "cLen!=c[9]+12")
return 0
}
var rData HexData
rData.TimeUtc = uint32(c[3])<<24 | uint32(c[2])<<16 | uint32(c[1])<<8 | uint32(c[0]) // binary.Read(bytes.NewBuffer(cleartext[:4]), binary.BigEndian, &rData.timeUtc) 肯定效率低下，还是自己拼
// 时间有效性判断
nowTimeUtc := uint32(time.Now().Unix())
if nowTimeUtc > rData.TimeUtc+300 || rData.TimeUtc > nowTimeUtc+300 {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "utc err:"+strconv.FormatUint(uint64(rData.TimeUtc), 10))
return 0
}
// 设备类型判断
if c[4] != d.devType {
dbmodel.InsertDevHexCommandErr(nowConnDevID, string(data), "devType error")
return 0
}
rData.DevID = uint32(c[4])<<24 | uint32(c[5])<<16 | uint32(c[6])<<8 | uint32(c[7])
rData.CtrlCode = c[8]
rData.Length = c[9]
rData.Data = c[10 : cLen-2]
if rData.CtrlCode != 0x41 && rData.CtrlCode != 0x3f { //心跳不记 开机注册不记
insertDevHexCommandRecord(&rData, string(data), 0) //0接收 1回复 2主动下发 异步去搞
}
/*sBuf := */ d.protocolAnalysis(&rData)
if rData.CtrlCode > 0x80 { // 用来判断返回不为空 被动响应都大于0x80
sendStr := d.packageSendData(&rData)
sendStr[0] = '['
sendStr[len(sendStr)-1] = ']'
//if sendFlag {time.Sleep(20*time.Millisecond)} //这句话是为了多帧发送间隔20MS,可以不加试试
if _, err = conn.Write(sendStr); err != nil {
//logger.Log.Debug("conn.Write(sendStr) error", // 刚收到发来的，现在居然发不回去了
// zap.String("Src", "TCP-SERVER-receive"),
// zap.Uint32("DevID", rData.DevID),
// zap.String("RData", string(data)),
// zap.String("SendStr", string(sendStr)),
// zap.String("Conn", conn.RemoteAddr().String()))
//if nowConnDevID == 0 { //刚才没有ID的在这里记
// model.InsertDevHexCommandErr(rData.DevID,string(data),"A error")
//}
return 0
}
if rData.CtrlCode != 0xc1 && rData.CtrlCode != 0xbf { //心跳不记 开机注册不记
insertDevHexCommandRecord(&rData, string(sendStr), 1) //0接收 1回复 2主动下发 异步去搞
}
}
return rData.DevID //解密成功且CRC校验成功，设备类型一致，解析长度正确，则为合法设备
}
func (d *DCLongTCPHex) TCPSend(data *HexData) bool {
//d.ConnectMapRWMutex.RLock()
//c,ok := d.ConnectMap[data.DevID]// conn,ok := d.ConnectMap.Load(data.DevID)
//d.ConnectMapRWMutex.RUnlock()
if conn, ok := d.ConnectMap.Load(data.DevID); ok {
if c, ok := conn.(*net.TCPConn); ok { // 类型断言
sendStr := d.packageSendData(data)
sendStr[0] = '['
sendStr[len(sendStr)-1] = ']'
if _, err := c.Write(sendStr); err != nil {
//d.ConnectMapRWMutex.Lock()
//delete(d.ConnectMap,data.DevID)// d.ConnectMap.Delete(data.DevID)
//d.ConnectMapRWMutex.Unlock()
/*errC*/
_ = c.Close()
d.ConnectMap.Delete(data.DevID)
/*if errC != nil {
model.DevHexConnectRecord(data.DevID,false,'W')
} else {
model.DevHexConnectRecord(data.DevID,false,'w')
}*/
//logger.Log.Debug("conn.Write(sendStr) error", //
// zap.String("Src", "TCP-SERVER-TCPSend"),
// zap.Uint32("DevID", data.DevID),
// zap.Error(err),
// zap.String("SendStr", string(sendStr)),
// zap.String("Conn", c.RemoteAddr().String()),
// zap.String("State", "offline"))
return false
}
insertDevHexCommandRecord(data, string(sendStr), 2) //0接收 1回复 2主动下发
return true
} else {
// ntodo logger map里面存的内容居然类型不对
d.ConnectMap.Delete(data.DevID)
logger.Log.Error("conn.(*net.TCPConn) != ok", //
zap.String("Src", "TCP-SERVER-TCPSend"),
zap.Uint32("DevID", data.DevID),
zap.String("Conn", c.RemoteAddr().String()),
zap.String("State", "offline"))
}
}
return false
}
func (d *DCLongTCPHex) InitNewDCLongTCPHex(password string, iv string, devType uint8, f func(data *HexData)) {
d.password = password
d.iv = iv
d.devType = devType
d.protocolAnalysis = f
d.TCPReceive = d.receiveResponse
// d.ConnectMap = make(map[uint32]*net.TCPConn)
}
// 组装并加密数据
func (d *DCLongTCPHex) packageSendData(sData *HexData) []byte {
hexBuf := make([]byte, sData.Length+12)
sData.TimeUtc = uint32(time.Now().Unix())
hexBuf[0] = byte(sData.TimeUtc)
hexBuf[1] = byte(sData.TimeUtc >> 8)
hexBuf[2] = byte(sData.TimeUtc >> 16)
hexBuf[3] = byte(sData.TimeUtc >> 24)
hexBuf[4] = d.devType
hexBuf[5] = byte(sData.DevID >> 16)
hexBuf[6] = byte(sData.DevID >> 8)
hexBuf[7] = byte(sData.DevID)
hexBuf[8] = sData.CtrlCode
hexBuf[9] = sData.Length
//if sData.Length>0 {
copy(hexBuf[10:], sData.Data[:sData.Length])
//}
util.GetCRC(hexBuf, int(sData.Length)+10)
return util.EncryptBytesToBase64(hexBuf, d.password, d.iv)
}
devproduct/dcphone20/dc_phone20.go 0 → 100644
package dcphone20
import (
"dc_golang_server_1/config"
)
func NewDCPhone20() {
var dcPhone20TCP DCPhone20
dcPhone20TCP.NewDCPhone20("DCRYM-2018-pswd.", "I can't tell YOU", 0x5B) // config
dcPhone20TCP.TCPStart(config.TcpLongPort)
// dcPhone10TCP.NewDCPhone20API(r)
}
go.mod 0 → 100644
module dc_golang_server_1
go 1.17
require (
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/gin-gonic/gin v1.7.4 // indirect
github.com/go-playground/locales v0.14.0 // indirect
github.com/go-playground/universal-translator v0.18.0 // indirect
github.com/go-playground/validator/v10 v10.9.0 // indirect
github.com/golang/protobuf v1.5.2 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/leodido/go-urn v1.2.1 // indirect
github.com/lib/pq v1.10.3 // indirect
github.com/mattn/go-isatty v0.0.14 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/natefinch/lumberjack v2.0.0+incompatible // indirect
github.com/ugorji/go/codec v1.2.6 // indirect
go.uber.org/atomic v1.9.0 // indirect
go.uber.org/multierr v1.7.0 // indirect
go.uber.org/zap v1.19.1 // indirect
golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 // indirect
golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069 // indirect
golang.org/x/text v0.3.6 // indirect
google.golang.org/protobuf v1.27.1 // indirect
gopkg.in/ini.v1 v1.63.2 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
)
go.sum 0 → 100644
This diff is collapsed. Click to expand it.
log/panic.log 0 → 100644
panic: SelectAreaToMap rows pq: column "status" does not exist
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x0 pc=0x6f7cce]
goroutine 1 [running]:
database/sql.(*Rows).close(0x0, {0x0, 0x0})
C:/Users/Administrator/go/go1.17/src/database/sql/sql.go:3267 +0x8e
database/sql.(*Rows).Close(0x2f9620)
C:/Users/Administrator/go/go1.17/src/database/sql/sql.go:3263 +0x1d
panic({0x7681e0, 0xc0003851e0})
C:/Users/Administrator/go/go1.17/src/runtime/panic.go:1038 +0x215
log.Panicln({0xc00029fdf0, 0x902f30, 0xc0000aa1b0})
C:/Users/Administrator/go/go1.17/src/log/log.go:368 +0x65
dc_golang_server_1/cache.initAreaMap()
D:/work/SoftwareGroup/goland_project/dc_golang_server_1/cache/cmap_area.go:19 +0x1c8
dc_golang_server_1/cache.Init()
D:/work/SoftwareGroup/goland_project/dc_golang_server_1/cache/cache.go:165 +0x17
main.main()
D:/work/SoftwareGroup/goland_project/dc_golang_server_1/main.go:75 +0x51
logger/logger.go 0 → 100644
package logger
import (
config2 "dc_golang_server_1/config"
"github.com/gin-gonic/gin"
"github.com/natefinch/lumberjack"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
"os"
"time"
)
var Log *zap.Logger
func InitLogger() {
config := zapcore.EncoderConfig{
MessageKey: "msg", //结构化（json）输出：msg的key
LevelKey: "level", //结构化（json）输出：日志级别的key（INFO，WARN，ERROR等）
TimeKey: "ts", //结构化（json）输出：时间的key（INFO，WARN，ERROR等）
CallerKey: "file", //结构化（json）输出：打印日志的文件对应的Key
EncodeLevel: zapcore.CapitalLevelEncoder, //将日志级别转换成大写（INFO，WARN，ERROR等）
EncodeCaller: zapcore.ShortCallerEncoder, //采用短文件路径编码输出（test/main.go:14 ）
EncodeTime: func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
enc.AppendString(t.Format("2006-01-02 15:04:05.000"))
}, //输出的时间格式
//EncodeDuration: func(d time.Duration, enc zapcore.PrimitiveArrayEncoder) {
// enc.AppendInt64(int64(d) / 1000000)
//},//
}
//debug info
infoLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
return lvl < zapcore.WarnLevel && lvl >= config2.LogLevel
})
//warn
warnLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
return lvl == zapcore.WarnLevel && lvl >= config2.LogLevel
})
//error DPanic Panci Fatal
errorLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
return lvl > zapcore.WarnLevel && lvl >= config2.LogLevel
})
infoWriter := &lumberjack.Logger{
Filename: config2.LogPath + "info.log",
MaxSize: config2.LogFileMaxSize, //最大M数，超过则切割
MaxBackups: config2.LogInfoMaxFileNum, //最大文件保留数，超过就删除最老的日志文件
MaxAge: config2.LogInfoMaxFileDay, //保存30天
Compress: false, //是否压缩
}
warnWriter := &lumberjack.Logger{
Filename: config2.LogPath + "warn.log",
MaxSize: config2.LogFileMaxSize, //最大M数，超过则切割
MaxBackups: config2.LogWarnMaxFileNum, //最大文件保留数，超过就删除最老的日志文件
MaxAge: config2.LogWarnMaxFileDay, //保存30天
Compress: false, //是否压缩
}
errorWriter := &lumberjack.Logger{
Filename: config2.LogPath + "error.log",
MaxSize: config2.LogFileMaxSize, //最大M数，超过则切割
MaxBackups: config2.LogErrorMaxFileNum, //最大文件保留数，超过就删除最老的日志文件
MaxAge: config2.LogErrorMaxFileDay, //保存30天
Compress: false, //是否压缩
}
core := zapcore.NewTee(
zapcore.NewCore(zapcore.NewJSONEncoder(config), zapcore.AddSync(infoWriter), infoLevel), // zapcore.NewConsoleEncoder(encoder)
zapcore.NewCore(zapcore.NewJSONEncoder(config), zapcore.AddSync(warnWriter), warnLevel), //
zapcore.NewCore(zapcore.NewJSONEncoder(config), zapcore.AddSync(errorWriter), errorLevel), //
//zapcore.NewCore(zapcore.NewJSONEncoder(encoder), zapcore.NewMultiWriteSyncer(zapcore.AddSync(os.Stdout)), logLevel),//同时将日志输出到控制台，NewJSONEncoder 是结构化输出
)
Log = zap.New(core, zap.AddStacktrace(zap.ErrorLevel))
}
func HttpGinLog() gin.HandlerFunc { //logger *log.Log
return func(c *gin.Context) {
startTime := time.Now().UnixNano()
c.Next()
// stopTime := time.Since(startTime)
// spendTime := stopTime.Nanoseconds()/1000000///fmt.Sprintf("%d ms", (stopTime.Nanoseconds()+500000)/1000000)
spendTime := time.Now().UnixNano() - startTime
hostName, err := os.Hostname()
if err != nil {
hostName = "unknown"
}
statusCode := c.Writer.Status()
clientIp := c.ClientIP()
userAgent := c.Request.UserAgent()
dataSize := c.Writer.Size()
if dataSize < 0 {
dataSize = 0
}
method := c.Request.Method
path := c.Request.RequestURI
//c.Request.Body.Read()
//body := c.Request.Body
//para := c.Params
//entry := Log.WithFields(log.Fields{
// "HostName": hostName,
// "Status": statusCode,
// "SpendNanoS": spendTime,
// "Ip": clientIp,
// "Method": method,
// "Path": path,
// "DataSize": dataSize,
// "Agent": userAgent,
//})
if len(c.Errors) > 0 {
//entry.Error(c.Errors.ByType(gin.ErrorTypePrivate).String())
Log.Error(c.Errors.ByType(gin.ErrorTypePrivate).String(),
zap.String("HostName", hostName),
zap.Int("Status", statusCode),
zap.Int64("SpendNanoS", spendTime),
zap.String("Ip", clientIp),
zap.String("Method", method),
zap.String("Path", path),
zap.Int("DataSize", dataSize),
zap.String("Agent", userAgent))
}
if statusCode >= 500 {
Log.Error("",
zap.String("HostName", hostName),
zap.Int("Status", statusCode),
zap.Int64("SpendNanoS", spendTime),
zap.String("Ip", clientIp),
zap.String("Method", method),
zap.String("Path", path),
zap.Int("DataSize", dataSize),
zap.String("Agent", userAgent))
} else if statusCode >= 400 {
Log.Warn("",
zap.String("HostName", hostName),
zap.Int("Status", statusCode),
zap.Int64("SpendNanoS", spendTime),
zap.String("Ip", clientIp),
zap.String("Method", method),
zap.String("Path", path),
zap.Int("DataSize", dataSize),
zap.String("Agent", userAgent))
} else {
Log.Info("",
zap.String("HostName", hostName),
zap.Int("Status", statusCode),
zap.Int64("SpendNanoS", spendTime),
zap.String("Ip", clientIp),
zap.String("Method", method),
zap.String("Path", path),
zap.Int("DataSize", dataSize),
zap.String("Agent", userAgent))
}
}
}
//import (
// "github.com/gin-gonic/gin"
// rotatelogs "github.com/lestrrat-go/file-rotatelogs"
// "github.com/rifflock/lfshook"
// log "github.com/sirupsen/logrus"
// "jeff_workstation_1/util"
// "os"
// "time"
//)
//
//func InitLogger(filePath string){
//
// // log.SetOutput(colorable.NewColorableStdout())
//
// // log.SetOutput(f)
// log.SetLevel(util.LogLevel)
//
// TraceLogWriter,_ := rotatelogs.New(
// filePath+"Trace_%Y%m%d%H.log",
// rotatelogs.WithMaxAge(util.LogTraceWithMaxAge),
// rotatelogs.WithRotationTime(util.LogTraceWithRotationTime),
// //rotatelogs.WithLinkName(linkName),
// )
// DebugLogWriter,_ := rotatelogs.New(
// filePath+"Debug_%Y%m%d%H.log",
// rotatelogs.WithMaxAge(util.LogDebugWithMaxAge),
// rotatelogs.WithRotationTime(util.LogDebugWithRotationTime),
// //rotatelogs.WithLinkName(linkName),
// )
// infoLogWriter,_ := rotatelogs.New(
// filePath+"Info_%Y%m%d%H.log",
// rotatelogs.WithMaxAge(util.LogInfoWithMaxAge),
// rotatelogs.WithRotationTime(util.LogInfoWithRotationTime),
// //rotatelogs.WithLinkName("tcp_info.log"),
// )
// WarnLogWriter,_ := rotatelogs.New(
// filePath+"Warn_%Y%m%d%H.log",
// rotatelogs.WithMaxAge(util.LogWarnWithMaxAge),
// rotatelogs.WithRotationTime(util.LogWarnWithRotationTime),
// //rotatelogs.WithLinkName("tcp_warn.log"),
// )
// ErrorLogWriter,_ := rotatelogs.New(
// filePath+"Error_%Y%m%d%H.log",
// rotatelogs.WithMaxAge(util.LogErrorWithMaxAge),
// rotatelogs.WithRotationTime(util.LogErrorWithRotationTime),
// //rotatelogs.WithLinkName("tcp_error.log"),
// )
//
// writeMap := lfshook.WriterMap{
// log.TraceLevel: TraceLogWriter,
// log.DebugLevel: DebugLogWriter,
// log.InfoLevel: infoLogWriter,
// log.WarnLevel: WarnLogWriter,
// log.ErrorLevel: ErrorLogWriter,
// log.PanicLevel: ErrorLogWriter,
// log.FatalLevel: ErrorLogWriter,
// }
// hook := lfshook.NewHook(writeMap,&log.JSONFormatter{
// TimestampFormat: "2006-01-02 15:04:05.000000",
// })
//
// log.AddHook(hook)
// return
//}
//
//func HttpGinLog() gin.HandlerFunc{ //logger *log.Log
// return func(c *gin.Context) {
// startTime := time.Now().UnixNano()
// c.Next()
// //stopTime := time.Since(startTime)
// //spendTime := stopTime.Nanoseconds()/1000000///fmt.Sprintf("%d ms", (stopTime.Nanoseconds()+500000)/1000000)
// spendTime := time.Now().UnixNano() - startTime
// hostName, err := os.Hostname()
// if err != nil {
// hostName = "unknown"
// }
// statusCode := c.Writer.Status()
// clientIp := c.ClientIP()
// userAgent := c.Request.UserAgent()
// dataSize := c.Writer.Size()
// if dataSize < 0 {
// dataSize = 0
// }
// method := c.Request.Method
// path := c.Request.RequestURI
//
// //c.Request.Body.Read()
// //body := c.Request.Body
// //para := c.Params
//
// entry := log.WithFields(log.Fields{
// "HostName": hostName,
// "Status": statusCode,
// "SpendNanoS": spendTime,
// "Ip": clientIp,
// "Method": method,
// "Path": path,
// "DataSize": dataSize,
// "Agent": userAgent,
// })
//
// if len(c.Errors) > 0 {
// entry.Error(c.Errors.ByType(gin.ErrorTypePrivate).String())
// }
// if statusCode >= 500 {
// entry.Error()
// } else if statusCode >= 400 {
// entry.Warn()
// } else {
// entry.Info()
// }
// }
//}
main.go 0 → 100644
package main
import (
"dc_golang_server_1/api"
"dc_golang_server_1/cache"
"dc_golang_server_1/config"
"dc_golang_server_1/dbmodel"
"dc_golang_server_1/devproduct/dcphone20"
"dc_golang_server_1/logger"
"os"
"runtime"
"syscall"
)
//windows
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
procSetStdHandle = kernel32.MustFindProc("SetStdHandle")
)
func setStdHandle(stdhandle int32, handle syscall.Handle) error {
r0, _, e1 := syscall.Syscall(procSetStdHandle.Addr(), 2, uintptr(stdhandle), uintptr(handle), 0)
if r0 == 0 {
if e1 != 0 {
return error(e1)
}
return syscall.EINVAL
}
return nil
}
// redirectStderr to the file passed in
func redirectStderrWindows(f *os.File) {
err := setStdHandle(syscall.STD_ERROR_HANDLE, syscall.Handle(f.Fd()))
if err != nil {
logger.Log.Panic(err.Error())
}
// SetStdHandle does not affect prior references to stderr
os.Stderr = f
}
//windows end
//func redirectStderrLinux(f *os.File) {
// err := syscall.Dup2(int(f.Fd()), int(os.Stderr.Fd()))
// if err != nil {
// logger.Log.Panic(err.Error())
// }
//}
//func init() {
//
//}
func initConfigAndLogger() {
config.ConfigInit()
logger.InitLogger()
f, err := os.OpenFile(config.LogPath+"panic.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0755)
if err != nil {
logger.Log.Panic(err.Error())
}
redirectStderrWindows(f)
//redirectStderrLinux(f)
}
func main() { //
runtime.GOMAXPROCS(runtime.NumCPU())
initConfigAndLogger()
dbmodel.InitDb()
defer dbmodel.CloseDb()
cache.Init()
dcphone20.NewDCPhone20()
//dcdrinking60.NewDCDrinking60()
api.InitRouter()
}
middleware/cors.go 0 → 100644
package middleware
import (
"github.com/gin-gonic/gin"
"net/http"
"strings"
)
func Cors() gin.HandlerFunc {
return func(context *gin.Context) {
if context.Request.Method == "OPTIONS" {
origin := context.Request.Header.Get("Origin")
var headerKeys []string
for k, _ := range context.Request.Header {
headerKeys = append(headerKeys, k)
}
headerStr := strings.Join(headerKeys, ",")
if headerStr != "" {
headerStr = "access-control-allow-origin, access-control-allow-headers, " + headerStr //fmt.Sprintf("access-control-allow-origin, access-control-allow-headers, %s", headerStr) 测试了下，速度忆氧
} else {
headerStr = "access-control-allow-origin, access-control-allow-headers"
}
if origin != "" {
context.Writer.Header().Set("Access-Control-Allow-Origin", "*")
context.Header("Access-Control-Allow-Origin", "*") // 设置允许访问所有域
context.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE,UPDATE")
context.Header("Access-Control-Allow-Headers", "Authorization, Content-Length, X-CSRF-Token, Token,session,X_Requested_With,Accept, Origin, Host, Connection, Accept-Encoding, Accept-Language,DNT, X-CustomHeader, Keep-Alive, User-Agent, X-Requested-With, If-Modified-Since, Cache-Control, Content-Type, Pragma")
context.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers,Cache-Control,Content-Language,Content-Type,Expires,Last-Modified,Pragma,FooBar")
context.Header("Access-Control-Max-Age", "172800")
context.Header("Access-Control-Allow-Credentials", "false")
context.Set("content-type", "application/json") //// 设置返回格式是json
}
context.JSON(http.StatusOK, "Options Request!")
}
context.Next()
}
}
//func Cors() gin.HandlerFunc {
// return func(context *gin.Context) {
// method := context.Request.Method
// origin := context.Request.Header.Get("Origin")
// var headerKeys []string
// for k, _ := range context.Request.Header {
// headerKeys = append(headerKeys, k)
// }
// headerStr := strings.Join(headerKeys, ",")
// if headerStr != "" {
// headerStr = fmt.Sprintf("access-control-allow-origin, access-control-allow-headers, %s", headerStr)
// } else {
// headerStr = "access-control-allow-origin, access-control-allow-headers"
// }
//
// if origin != "" {
// context.Writer.Header().Set("Access-Control-Allow-Origin", "*")
// context.Header("Access-Control-Allow-Origin", "*") // 设置允许访问所有域
// context.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE,UPDATE")
// context.Header("Access-Control-Allow-Headers", "Authorization, Content-Length, X-CSRF-Token, Token,session,X_Requested_With,Accept, Origin, Host, Connection, Accept-Encoding, Accept-Language,DNT, X-CustomHeader, Keep-Alive, User-Agent, X-Requested-With, If-Modified-Since, Cache-Control, Content-Type, Pragma")
// context.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers,Cache-Control,Content-Language,Content-Type,Expires,Last-Modified,Pragma,FooBar")
// context.Header("Access-Control-Max-Age", "172800")
// context.Header("Access-Control-Allow-Credentials", "false")
// context.Set("content-type", "application/json") //// 设置返回格式是json
// }
//
// if method == "OPTIONS" {
// context.JSON(http.StatusOK, "Options Request!")
// }
//
// context.Next()
// }
//}
middleware/jeffwt.go 0 → 100644
package middleware
import (
"dc_golang_server_1/util"
"fmt"
"github.com/gin-gonic/gin"
"math/rand"
"time"
)
const jeffWTKey = "jeffWT@666%b;'~+"
const jeffWTTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
type JeffWTInfo struct {
UID int32
UserName string // 最长32字节
CreatTime uint64
ExpireTime uint64
}
// 定义错误
//var (
// TokenExpired error = errors.New("Token已过期,请重新登录")
// TokenNotValidYet error = errors.New("Token无效,请重新登录")
// TokenMalformed error = errors.New("Token不正确,请重新登录")
// TokenInvalid error = errors.New("这不是一个token,请重新登录")
//)
// CreateToken 生成token
func CreateToken(info JeffWTInfo) string {
info.UID = ^info.UID
info.CreatTime = ^info.CreatTime
info.ExpireTime = ^info.ExpireTime
var clear [52]byte //= make([]byte, 20)
var str [30]byte
for i := 0; i < len(info.UserName); i++ {
str[i] = info.UserName[i] + (uint8(i) << 2)
}
r := rand.New(rand.NewSource(time.Now().UnixNano()))
clear[0] = str[18] + 76
clear[1] = byte(info.CreatTime >> 16)
clear[2] = byte(info.ExpireTime >> 8)
clear[3] = byte(info.UID >> 24)
clear[4] = str[29] + 60
clear[5] = byte(r.Intn(256))
clear[6] = byte(info.UID >> 8)
clear[7] = byte(info.ExpireTime)
clear[8] = byte(r.Intn(256))
clear[9] = str[9]
clear[10] = byte(r.Intn(256))
clear[11] = byte(info.CreatTime >> 24)
clear[12] = byte(info.CreatTime)
clear[13] = byte(info.ExpireTime >> 24)
clear[14] = 0x16 + clear[2] - clear[0] + clear[11] - clear[7] - clear[12] + clear[10]
clear[15] = byte(r.Intn(256))
clear[16] = byte(info.UID >> 16)
clear[17] = byte(info.CreatTime >> 8)
clear[18] = byte(info.ExpireTime >> 16)
clear[19] = str[0] + 90
clear[29] = str[28] + clear[10] + clear[8]
clear[29] = str[25]
clear[29] = str[22]
clear[29] = str[13]
clear[29] = str[12]
clear[29] = byte(info.UID)
clear[29] = str[0]
clear[29] = str[1]
clear[29] = str[2]
clear[29] = str[3]
clear[29] = str[4]
clear[29] = str[5]
clear[29] = str[6]
clear[29] = str[7]
clear[29] = str[8]
clear[29] = str[9]
clear[29] = str[10]
clear[29] = str[11]
clear[29] = str[12]
clear[29] = str[13]
clear[29] = str[14]
// todo 根据缓存来，记得CRC
fmt.Println(clear[:19])
util.GetCRC(clear[:19], 19)
s := util.EncryptBytesToBase64URL(clear[:], jeffWTKey)
//fmt.Println(s)
result := make([]byte, 32)
copy(result[:8], s[20:])
copy(result[11:], s[:20])
result[8] = jeffWTTable[r.Intn(64)]
result[9] = jeffWTTable[r.Intn(64)]
result[10] = jeffWTTable[r.Intn(64)]
result[31] = jeffWTTable[r.Intn(64)]
return string(result)
}
// ParserToken 解析token
//func (j *JWT) ParserToken(tokenString string) (*MyClaims, error) {
// token, err := jwt.ParseWithClaims(tokenString, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {
// return j.JwtKey, nil
// })
//
// if err != nil {
// if ve, ok := err.(*jwt.ValidationError); ok {
// if ve.Errors&jwt.ValidationErrorMalformed != 0 {
// return nil, errors.New("Token不正确,请重新登录")
// } else if ve.Errors&jwt.ValidationErrorExpired != 0 {
// // Token is expired
// return nil, errors.New("Token已过期,请重新登录")
// } else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
// return nil, errors.New("Token无效,请重新登录")
// } else {
// return nil, errors.New("这不是一个token,请重新登录")
// }
// }
// }
//
// if token != nil {
// if claims, ok := token.Claims.(*MyClaims); ok && token.Valid {
// return claims, nil
// }
// return nil, errors.New("这不是一个token,请重新登录")
// }
//
// return nil, errors.New("这不是一个token,请重新登录")
//}
// JwtToken jwt中间件
func JwtToken() gin.HandlerFunc {
return func(c *gin.Context) {
//tokenHeader := c.Request.Header.Get("Authorization")
//if tokenHeader == "" {
// c.JSON(http.StatusOK, gin.H{
// "status": 1004,
// "message": "TOKEN不存在",
// })
// c.Abort()
// return
//}
//
//checkToken := strings.Split(tokenHeader, " ")
//if len(checkToken) == 0 {
// c.JSON(http.StatusOK, gin.H{
// "status": 1007,
// "message": "TOKEN格式错误",
// })
// c.Abort()
// return
//}
//
//if len(checkToken) != 2 || checkToken[0] != "Bearer" {
// c.JSON(http.StatusOK, gin.H{
// "status": 1007,
// "message": "TOKEN格式错误",
// })
// c.Abort()
// return
//}
//
//j := NewJWT()
//// 解析token
//claims, err := j.ParserToken(checkToken[1])
//if err != nil {
// //if err == TokenExpired {
// // c.JSON(http.StatusOK, gin.H{
// // "status": 500,
// // "message": "token授权已过期,请重新登录",
// // "data": nil,
// // })
// // c.Abort()
// // return
// //}
//
// c.JSON(http.StatusOK, gin.H{
// "status": 500,
// "message": err.Error(),
// "data": nil,
// })
// c.Abort()
// return
//}
//
//c.Set("username", claims)
c.Next()
}
}
//var JwtKey = []byte(utils.JwtKey)
//
//type MyClaims struct {
// Username string `json:"username"`
// jwt.StandardClaims
//}
//
//// 生成token
//func SetToken(username string) (string,int){
// setClaims := MyClaims{
// username,
// jwt.StandardClaims{
// ExpiresAt: time.Now().Add(10*time.Hour).Unix(),
// Issuer: "ginblog",
// },
// }
//
// reqClaim := jwt.NewWithClaims(jwt.SigningMethodHS256, setClaims)
// token,err := reqClaim.SignedString(JwtKey)
// if err != nil {
// return "",errmsg.ERROR
// }
// return token,errmsg.SUCCSE
//}
//
//// 验证token
//func CheckToken(token string) (*MyClaims, int){
// if token == "" || token == "null"{
// return nil,errmsg.ERROR
// }
// setToken,_ := jwt.ParseWithClaims(token, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {
// return JwtKey, nil
// })
// if key,_ := setToken.Claims.(*MyClaims); setToken.Valid{
// return key,errmsg.SUCCSE
// }
// return nil,errmsg.ERROR
//}
//
//// jwt中间件
//func JwtToken() gin.HandlerFunc{
// var code int
// return func(c *gin.Context) {
// tokenHeader := c.Request.Header.Get("Authorization")
//
// if tokenHeader == "" {
// code = errmsg.ERROR_TOKEN_EXIST
// c.JSON(http.StatusOK,gin.H{
// "code":code,
// "message":errmsg.GetErrMsg(code),
// })
// c.Abort()
// return
// }
// checkToken := strings.SplitN(tokenHeader, " ", 2)
// if len(checkToken) != 2 && checkToken[0] != "Bearer" {
// code = errmsg.ERROR_TOKEN_TYPE_WRONG
// c.JSON(http.StatusOK,gin.H{
// "code":code,
// "message":errmsg.GetErrMsg(code),
// })
// c.Abort()
// return
// }
// key,tCode := CheckToken(checkToken[1])
// if tCode == errmsg.ERROR {
// code = errmsg.ERROR_TOKEN_WRONG
// c.JSON(http.StatusOK,gin.H{
// "code":code,
// "message":errmsg.GetErrMsg(code),
// })
// c.Abort()
// return
// }
// if time.Now().Unix() > key.ExpiresAt {
// code = errmsg.ERROR_TOKEN_RUNTIME
// c.JSON(http.StatusOK,gin.H{
// "code":code,
// "message":errmsg.GetErrMsg(code),
// })
// c.Abort()
// return
// }
//
// c.Set("username",key.Username)
// c.Next()
// }
//}
util/dbcsbc.go 0 → 100644
package util
// 全角转换半角
func DBCtoSBC(s string) string {
retstr := ""
for _, i := range s {
inside_code := i
if inside_code == 12288 {
inside_code = 32
} else {
inside_code -= 65248
}
if inside_code < 32 || inside_code > 126 {
retstr += string(i)
} else {
retstr += string(inside_code)
}
}
return retstr
}
//import (
// "sort"
// "strings"
//)
//
//type dict struct {
// x, y rune
//}
//
//var toSBC = []dict{
// {0x00A2, 0xFFE0},
// {0x00A3, 0xFFE1},
// {0x00A5, 0xFFE5},
// {0x00A6, 0xFFE4},
// {0x00AC, 0xFFE2},
// {0x00AF, 0xFFE3},
// {0xFF61, 0x3002},
// {0xFF62, 0x300C},
// {0xFF63, 0x300D},
// {0xFF64, 0x3001},
// {0xFF65, 0x30FB},
// {0xFF66, 0x30F2},
// {0xFF67, 0x30A1},
// {0xFF68, 0x30A3},
// {0xFF69, 0x30A5},
// {0xFF6A, 0x30A7},
// {0xFF6B, 0x30A9},
// {0xFF6C, 0x30E3},
// {0xFF6D, 0x30E5},
// {0xFF6E, 0x30E7},
// {0xFF6F, 0x30C3},
// {0xFF70, 0x30FC},
// {0xFF71, 0x30A2},
// {0xFF72, 0x30A4},
// {0xFF73, 0x30A6},
// {0xFF74, 0x30A8},
// {0xFF75, 0x30AA},
// {0xFF76, 0x30AB},
// {0xFF77, 0x30AD},
// {0xFF78, 0x30AF},
// {0xFF79, 0x30B1},
// {0xFF7A, 0x30B3},
// {0xFF7B, 0x30B5},
// {0xFF7C, 0x30B7},
// {0xFF7D, 0x30B9},
// {0xFF7E, 0x30BB},
// {0xFF7F, 0x30BD},
// {0xFF80, 0x30BF},
// {0xFF81, 0x30C1},
// {0xFF82, 0x30C4},
// {0xFF83, 0x30C6},
// {0xFF84, 0x30C8},
// {0xFF85, 0x30CA},
// {0xFF86, 0x30CB},
// {0xFF87, 0x30CC},
// {0xFF88, 0x30CD},
// {0xFF89, 0x30CE},
// {0xFF8A, 0x30CF},
// {0xFF8B, 0x30D2},
// {0xFF8C, 0x30D5},
// {0xFF8D, 0x30D8},
// {0xFF8E, 0x30DB},
// {0xFF8F, 0x30DE},
// {0xFF90, 0x30DF},
// {0xFF91, 0x30E0},
// {0xFF92, 0x30E1},
// {0xFF93, 0x30E2},
// {0xFF94, 0x30E4},
// {0xFF95, 0x30E6},
// {0xFF96, 0x30E8},
// {0xFF97, 0x30E9},
// {0xFF98, 0x30EA},
// {0xFF99, 0x30EB},
// {0xFF9A, 0x30EC},
// {0xFF9B, 0x30ED},
// {0xFF9C, 0x30EF},
// {0xFF9D, 0x30F3},
// {0xFF9E, 0x309B},
// {0xFF9F, 0x309C},
// {0xFFA0, 0x3164},
// {0xFFC2, 0x314F},
// {0xFFC3, 0x3150},
// {0xFFC4, 0x3151},
// {0xFFC5, 0x3152},
// {0xFFC6, 0x3153},
// {0xFFC7, 0x3154},
// {0xFFCA, 0x3155},
// {0xFFCB, 0x3156},
// {0xFFCC, 0x3157},
// {0xFFCD, 0x3158},
// {0xFFCE, 0x3159},
// {0xFFCF, 0x315A},
// {0xFFD2, 0x315B},
// {0xFFD3, 0x315C},
// {0xFFD4, 0x315D},
// {0xFFD5, 0x315E},
// {0xFFD6, 0x315F},
// {0xFFD7, 0x3160},
// {0xFFDA, 0x3161},
// {0xFFDB, 0x3162},
// {0xFFDC, 0x3163},
// {0xFFE8, 0x2502},
// {0xFFE9, 0x2190},
// {0xFFEA, 0x2191},
// {0xFFEB, 0x2192},
// {0xFFEC, 0x2193},
// {0xFFED, 0x25A0},
// {0xFFEE, 0x25CB},
//}
//
//var toDBC = []dict{
// {0x2190, 0xFFE9},
// {0x2191, 0xFFEA},
// {0x2192, 0xFFEB},
// {0x2193, 0xFFEC},
// {0x3000, 0x0020},
// {0x3001, 0xFF64},
// {0x3002, 0xFF61},
// {0x300C, 0xFF62},
// {0x300D, 0xFF63},
// {0x309B, 0xFF9E},
// {0x309C, 0xFF9F},
// {0x30A1, 0xFF67},
// {0x30A2, 0xFF71},
// {0x30A3, 0xFF68},
// {0x30A4, 0xFF72},
// {0x30A5, 0xFF69},
// {0x30A6, 0xFF73},
// {0x30A7, 0xFF6A},
// {0x30A8, 0xFF74},
// {0x30A9, 0xFF6B},
// {0x30AA, 0xFF75},
// {0x30AB, 0xFF76},
// {0x30AD, 0xFF77},
// {0x30AF, 0xFF78},
// {0x30B1, 0xFF79},
// {0x30B3, 0xFF7A},
// {0x30B5, 0xFF7B},
// {0x30B7, 0xFF7C},
// {0x30B9, 0xFF7D},
// {0x30BB, 0xFF7E},
// {0x30BD, 0xFF7F},
// {0x30BF, 0xFF80},
// {0x30C1, 0xFF81},
// {0x30C3, 0xFF6F},
// {0x30C4, 0xFF82},
// {0x30C6, 0xFF83},
// {0x30C8, 0xFF84},
// {0x30CA, 0xFF85},
// {0x30CB, 0xFF86},
// {0x30CC, 0xFF87},
// {0x30CD, 0xFF88},
// {0x30CE, 0xFF89},
// {0x30CF, 0xFF8A},
// {0x30D2, 0xFF8B},
// {0x30D5, 0xFF8C},
// {0x30D8, 0xFF8D},
// {0x30DB, 0xFF8E},
// {0x30DE, 0xFF8F},
// {0x30DF, 0xFF90},
// {0x30E0, 0xFF91},
// {0x30E1, 0xFF92},
// {0x30E2, 0xFF93},
// {0x30E3, 0xFF6C},
// {0x30E4, 0xFF94},
// {0x30E5, 0xFF6D},
// {0x30E6, 0xFF95},
// {0x30E7, 0xFF6E},
// {0x30E8, 0xFF96},
// {0x30E9, 0xFF97},
// {0x30EA, 0xFF98},
// {0x30EB, 0xFF99},
// {0x30EC, 0xFF9A},
// {0x30ED, 0xFF9B},
// {0x30EF, 0xFF9C},
// {0x30F2, 0xFF66},
// {0x30F3, 0xFF9D},
// {0x30FB, 0xFF65},
// {0x30FC, 0xFF70},
// {0x314F, 0xFFC2},
// {0x3150, 0xFFC3},
// {0x3151, 0xFFC4},
// {0x3152, 0xFFC5},
// {0x3153, 0xFFC6},
// {0x3154, 0xFFC7},
// {0x3155, 0xFFCA},
// {0x3156, 0xFFCB},
// {0x3157, 0xFFCC},
// {0x3158, 0xFFCD},
// {0x3159, 0xFFCE},
// {0x315A, 0xFFCF},
// {0x315B, 0xFFD2},
// {0x315C, 0xFFD3},
// {0x315D, 0xFFD4},
// {0x315E, 0xFFD5},
// {0x315F, 0xFFD6},
// {0x3160, 0xFFD7},
// {0x3161, 0xFFDA},
// {0x3162, 0xFFDB},
// {0x3163, 0xFFDC},
// {0x3164, 0xFFA0},
// {0xFF5F, 0x2985},
// {0xFF60, 0x2986},
// {0xFFE0, 0x00A2},
// {0xFFE1, 0x00A3},
// {0xFFE2, 0x00AC},
// {0xFFE3, 0x00AF},
// {0xFFE4, 0x00A6},
// {0xFFE5, 0x00A5},
// {0xFFE6, 0x20A9},
//}
//
//// 从strings包拷贝，因此不必导入strings包即可使用本函数。
//var Map = strings.Map
//
//// 判断一个字符是否是半角字符
//func IsSBC(c rune) bool {
// switch {
// case c <= 0x007E:
// case c == 0x00A2 || c == 0x00A3:
// case c == 0x00A5 || c == 0x00A6:
// case c == 0x00AC || c == 0x00AF:
// case c == 0x20A9:
// case c == 0x2985 || c == 0x2986:
// case c >= 0xFF61 && c <= 0xFF9F:
// case c >= 0xFFA0 && c <= 0xFFBE:
// case c >= 0xFFC2 && c <= 0xFFC7:
// case c >= 0xFFCA && c <= 0xFFCF:
// case c >= 0xFFD2 && c <= 0xFFD7:
// case c >= 0xFFDA && c <= 0xFFDC:
// case c >= 0xFFE8 && c <= 0xFFEE:
// default:
// return false
// }
// return true
//}
//
//// 如果字符c为全角字符，返回对应半角字符（如有）；否则返回c。
//func ToDBC(c rune) rune {
// switch {
// case c <= 0x218F:
// return c
// case c <= 0x2193:
// case c == 0x2502:
// return 0xFFE8
// case c == 0x25A0:
// return 0xFFED
// case c == 0x25CB:
// return 0xFFEE
// case c <= 0x2FFF:
// return c
// case c <= 0x30FC:
// case c <= 0x3130:
// return c
// case c <= 0x314E:
// return c + 0xCE70
// case c <= 0x3164:
// case c <= 0xFF00:
// return c
// case c <= 0xFF5E:
// return c - 0xFEE0
// case c >= 0xFFE7:
// return c
// }
// i := sort.Search(len(toDBC), func(i int) bool { return toDBC[i].x >= c })
// if toDBC[i].x == c {
// return toDBC[i].y
// } else {
// return c
// }
//}
//
//// 如果字符c为半角字符，返回对应全角字符（如有）；否则返回c。
//func ToSBC(c rune) rune {
// switch {
// case c <= 0x001F:
// return c
// case c == 0x0020:
// return 0x3000
// case c <= 0x007E:
// return c + 0xFEE0
// case c <= 0x00AF:
// case c == 0x20A9:
// return 0xFFE6
// case c == 0x2985:
// return 0xFF5F
// case c == 0x2986:
// return 0xFF60
// case c <= 0xFF60:
// return c
// case c <= 0xFFA0:
// case c <= 0xFFBE:
// return c - 0xCE70
// case c >= 0xFFEF:
// return c
// }
// i := sort.Search(len(toSBC), func(i int) bool { return toSBC[i].x >= c })
// if toSBC[i].x == c {
// return toSBC[i].y
// } else {
// return c
// }
//}
//
//// 如果字符c为全角ASCII字符，返回对应的半角字符；否则返回c。
//func ToASCIIDBC(r rune) rune {
// if r == 0x3000 {
// return 0x3000
// }
// if r >= 0xFF01 && r <= 0xFF5E {
// return r - 0xFEE0
// }
// return r
//}
//
//// 如果字符c为半角ASCII字符，返回对应的全角字符；否则返回c。
//func ToASCIISBC(r rune) rune {
// if r == 0x0020 {
// return 0x3000
// }
// if r >= 0x0021 && r <= 0x007E {
// return r + 0xFEE0
// }
// return r
//}
util/jeff_crc16.go 0 → 100644
package util
func CheckCRC(buf []byte) bool {
var wCrcData uint16 = 0xffff
for _, v := range buf {
wCrcData ^= uint16(v)
for j := 0; j < 8; j++ {
if wCrcData&1 != 0 {
wCrcData >>= 1
wCrcData ^= 0xa001
} else {
wCrcData >>= 1
}
}
}
return wCrcData == 0
}
// GetCRC 获取2个字节的CRC16
func GetCRC(buf []byte, len int) { //传入的切片必须装得下
var wCrcData uint16 = 0xffff
for i := 0; i < len; i++ {
wCrcData ^= uint16(buf[i])
for j := 0; j < 8; j++ {
if wCrcData&1 != 0 {
wCrcData >>= 1
wCrcData ^= 0xa001
} else {
wCrcData >>= 1
}
}
}
buf[len] = byte(wCrcData)
buf[len+1] = byte(wCrcData >> 8)
}
util/jeff_secret.go 0 → 100644
package util
import (
"encoding/base64"
"errors"
)
func EncryptBytesToBase64(cleartext []byte, pswd string, iv string) (base64Result []byte) { //看base64库，返回切片更快，本来tcp发送也是切片,不过这里面string也是切片
var pswdIv [16]byte
var pswdSum byte
var i int
cleartextLen := len(cleartext)
var result = make([]byte, cleartextLen+1)
for i = 0; i < 16; i++ {
pswdIv[i] = ((pswd[i] & 0xaa) | (pswd[15-i] & 0x55)) + iv[15-i] + byte(i)
if i%2 == 0 {
pswdSum += pswd[i] + iv[i]
} else {
pswdSum -= pswd[i] - iv[i]
}
}
for i = 0; i < 16; i++ {
if i%2 == 0 {
pswdIv[i] = ^pswdIv[i] + pswdSum
} else {
pswdIv[i] = pswdIv[i] - ^pswdSum
}
}
result[cleartextLen] = ^pswdSum
for i = 0; i < cleartextLen; i++ {
result[cleartextLen] += cleartext[i]
}
for i = 0; i < cleartextLen; i++ {
result[i] = ^((cleartext[i] & 0x72) | (cleartext[cleartextLen-1-i] & 0x8d))
if i%2 == 0 {
result[i] += pswdIv[i%16] - result[cleartextLen]
} else {
result[i] -= pswdIv[i%16] + result[cleartextLen]
}
}
base64Result = make([]byte, base64.StdEncoding.EncodedLen(cleartextLen+1)+2) //多出两个用来装起始结束符
base64.StdEncoding.Encode(base64Result[1:], result)
return
//return base64.StdEncoding.EncodeToString(result)
}
// DecryptBase64ToBytes 解密并转换为bytes
func DecryptBase64ToBytes(ciphertext []byte, pswd string, iv string) ([]byte, error) { //看base64库，传入切片更快，本来tcp接收也是切片,不过这里面string也是切片
var pswdIv [16]byte
var pswdSum byte
var i int
cipherBytes := make([]byte, base64.StdEncoding.DecodedLen(len(ciphertext)))
hexLen, err := base64.StdEncoding.Decode(cipherBytes, ciphertext)
//cipherBytes, err := base64.StdEncoding.DecodeString(ciphertext)
if err != nil {
return nil, err
}
clearLen := hexLen - 1
var resultBytes = make([]byte, clearLen)
var resultBytesTemp = make([]byte, clearLen)
for i = 0; i < 16; i++ {
pswdIv[i] = ((pswd[i] & 0xaa) | (pswd[15-i] & 0x55)) + iv[15-i] + byte(i)
if i%2 == 0 {
pswdSum += pswd[i] + iv[i]
} else {
pswdSum -= pswd[i] - iv[i]
}
}
for i = 0; i < 16; i++ {
if i%2 == 0 {
pswdIv[i] = ^pswdIv[i] + pswdSum
} else {
pswdIv[i] = pswdIv[i] - ^pswdSum
}
}
for i = 0; i < clearLen; i++ {
if i%2 == 0 {
resultBytesTemp[i] = ^(cipherBytes[i] - (pswdIv[i%16] - cipherBytes[clearLen]))
} else {
resultBytesTemp[i] = ^(cipherBytes[i] + (pswdIv[i%16] + cipherBytes[clearLen]))
}
}
var sum byte
for i = 0; i < clearLen; i++ {
resultBytes[i] = (resultBytesTemp[i] & 0x72) | (resultBytesTemp[clearLen-1-i] & 0x8d)
sum += resultBytes[i]
}
sum += ^pswdSum
if sum != cipherBytes[clearLen] {
return nil, errors.New("密文校验错误")
}
return resultBytes, nil
}
func EncryptBytesToBase64URL(cleartext []byte, pswd string) string {
var i int
cleartextLen := len(cleartext)
var result = make([]byte, cleartextLen+1)
result[cleartextLen] = 0x11
for i = 0; i < cleartextLen; i++ {
if i%2 == 0 {
result[cleartextLen] -= cleartext[i] | 0x23
} else {
result[cleartextLen] += cleartext[i] & 0x36
}
result[cleartextLen] += ^((cleartext[i] >> 3) | (cleartext[i] << 5))
}
for i = 0; i < cleartextLen; i++ {
result[i] = ^((cleartext[i] & 0x72) | (cleartext[cleartextLen-1-i] & 0x8d))
if i%2 == 0 {
result[i] += pswd[i%16] - result[cleartextLen]
} else {
result[i] -= pswd[i%16] + result[cleartextLen]
}
}
return base64.URLEncoding.EncodeToString(result)
}
func DecryptBase64URLToBytes(ciphertext string, pswd string) ([]byte, error) { //
var i int
hex, err := base64.URLEncoding.DecodeString(ciphertext)
if err != nil {
return nil, err
}
clearLen := len(hex) - 1
var resultBytes = make([]byte, clearLen)
var resultBytesTemp = make([]byte, clearLen)
for i = 0; i < clearLen; i++ {
if i%2 == 0 {
resultBytesTemp[i] = ^(hex[i] - (pswd[i%16] - hex[clearLen]))
} else {
resultBytesTemp[i] = ^(hex[i] + (pswd[i%16] + hex[clearLen]))
}
}
var sum byte
for i = 0; i < clearLen; i++ {
resultBytes[i] = (resultBytesTemp[i] & 0x72) | (resultBytesTemp[clearLen-1-i] & 0x8d)
//sum += resultBytes[i]
if i%2 == 0 {
sum -= resultBytes[i] | 0x23
} else {
sum += resultBytes[i] & 0x36
}
sum += ^((resultBytes[i] >> 3) | (resultBytes[i] << 5))
}
sum += 0x11
if sum != hex[clearLen] {
return nil, errors.New("密文校验错误")
}
return resultBytes, nil
}
util/jeffutil_test.go 0 → 100644
package util
import (
"fmt"
"testing"
)
//测试用例文件使用 go test 指令来执行，没有也不需要 main() 作为函数入口
//所有在以_test结尾的源码内以Test开头的函数会自动被执行。
func TestHex2Cipher(t *testing.T) {
//test := []byte{0x22, 0x64, 0x65, 0x76, 0x2E, 0x6C, 0x65, 0x7A, 0x68, 0x69, 0x78, 0x79, 0x2E, 0x63, 0x6F, 0x6D, 0x22, 0x2C, 0x34, 0x39, 0x39, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x0A, 0x64, 0x31, 0x31, 0x30, 0x2F, 0x31, 0x32, 0x30, 0x2F, 0x31, 0x31, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x09, 0x09, 0x7F, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x02, 0x38, 0x35, 0x34, 0x30, 0x35, 0x35, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x57, 0x41, 0x59, 0x32, 0x31,0,0}
//GetCRC(test, 254)
//for j:=0;j< len(test);{
// for i:=0;i<16;i++{
// fmt.Printf("%02X",test[j])
// j++
// }
// fmt.Println()
//}
var b [3]byte
for i := 10002; i <= 11001; i++ {
b[0] = byte(i)
b[1] = byte(i >> 8)
b[2] = byte(i >> 16)
fmt.Printf("3D%02X%02X%02X,", b[0], b[1], b[2])
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment