Skip to content

S
SLG
Commit d04eb576 authored by shajiaiming's avatar shajiaiming
Browse files
Options

slg init

parent 6f3b01fe
Hide whitespace changes
Inline Side-by-side
Showing with 3045 additions and 0 deletions
conf/config.go 0 → 100644
View file @ d04eb576
package config
var (
ApiAuthConfig = map[string]map[string]string{
"STREAMER": {
"md5": "1dBQmx2BPjXRUaMm",
"aes": "fFjhWCkzfLGhFVv2",
"rsa": "rsa/public.pem",
},
}
)
const (
// 签名超时时间
AppSignExpiry = "120"
// RSA Private File
AppRsaPrivateFile = "rsa/private.pem"
PASSWORD_DEFAULT = 13
)
go.mod 0 → 100644
View file @ d04eb576
module slg
go 1.16
require (
github.com/astaxie/beego v1.12.3
github.com/dgrijalva/jwt-go v3.2.0+incompatible
github.com/gin-gonic/gin v1.7.7
github.com/go-ini/ini v1.66.4
github.com/go-sql-driver/mysql v1.6.0
github.com/gomodule/redigo v2.0.0+incompatible
github.com/jinzhu/gorm v1.9.16
github.com/robfig/cron v1.2.0
github.com/stretchr/testify v1.7.0 // indirect
github.com/xinliangnote/go-util v0.0.0-20210703052933-7f9f6d961276
golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
gopkg.in/go-playground/validator.v9 v9.31.0
)
go.sum 0 → 100644
View file @ d04eb576
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
github.com/PuerkitoBio/goquery v1.5.1/go.mod h1:GsLWisAFVj4WgDibEWF4pvYnkVQBpKBKeU+7zCJoLcc=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alicebob/gopher-json v0.0.0-20180125190556-5a6b3ba71ee6/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
github.com/alicebob/miniredis v2.5.0+incompatible/go.mod h1:8HZjEj4yU0dwhYHky+DxYx+6BMjkBbe5ONFIF1MXffk=
github.com/andybalholm/cascadia v1.1.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
github.com/astaxie/beego v1.12.3 h1:SAQkdD2ePye+v8Gn1r4X6IKZM1wd28EyUOVQ3PDSOOQ=
github.com/astaxie/beego v1.12.3/go.mod h1:p3qIm0Ryx7zeBHLljmd7omloyca1s4yu1a8kM1FkpIA=
github.com/beego/goyaml2 v0.0.0-20130207012346-5545475820dd/go.mod h1:1b+Y/CofkYwXMUU0OhQqGvsY2Bvgr4j6jfT699wyZKQ=
github.com/beego/x2j v0.0.0-20131220205130-a0352aadc542/go.mod h1:kSeGC/p1AbBiEp5kat81+DSQrZenVBZXklMLaELspWU=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
github.com/casbin/casbin v1.7.0/go.mod h1:c67qKN6Oum3UF5Q1+BByfFxkwKvhwW57ITjqwtzR1KE=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/cloudflare/golz4 v0.0.0-20150217214814-ef862a3cdc58/go.mod h1:EOBUe0h4xcZ5GoxqC5SDxFQ8gwyZPKQoEzownBlhI80=
github.com/couchbase/go-couchbase v0.0.0-20200519150804-63f3cdb75e0d/go.mod h1:TWI8EKQMs5u5jLKW/tsb9VwauIrMIxQG1r5fMsswK5U=
github.com/couchbase/gomemcached v0.0.0-20200526233749-ec430f949808/go.mod h1:srVSlQLB8iXBVXHgnqemxUXqN6FCvClgCMPCsjBDR7c=
github.com/couchbase/goutils v0.0.0-20180530154633-e865a1461c8a/go.mod h1:BQwMFlJzDjFDG3DJUdU0KORxn88UlsOULuxLExMh3Hs=
github.com/cupcake/rdb v0.0.0-20161107195141-43ba34106c76/go.mod h1:vYwsqCOLxGiisLwp9rITslkFNpZD5rz43tf41QFkTWY=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd h1:83Wprp6ROGeiHFAP8WJdI2RoxALQYgdllERc3N5N2DM=
github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
github.com/elastic/go-elasticsearch/v6 v6.8.5/go.mod h1:UwaDJsD3rWLM5rKNFzv9hgox93HoX8utj1kxD9aFUcI=
github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y=
github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
github.com/gin-gonic/gin v1.7.7 h1:3DoBmSbJbZAWqXJC3SLjAPfutPJJRN1U5pALB7EeTTs=
github.com/gin-gonic/gin v1.7.7/go.mod h1:axIBovoeJpVj8S3BwE0uPMTeReE4+AfFtqpqaZ1qq1U=
github.com/glendc/gopher-json v0.0.0-20170414221815-dc4743023d0c/go.mod h1:Gja1A+xZ9BoviGJNA2E9vFkPjjsl+CoJxSXiQM1UXtw=
github.com/go-ini/ini v1.66.4 h1:dKjMqkcbkzfddhIhyglTPgMoJnkvmG+bSLrU9cTHc5M=
github.com/go-ini/ini v1.66.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
github.com/go-redis/redis v6.14.2+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/jinzhu/gorm v1.9.16 h1:+IyIjPEABKRpsu/F8OvDPy9fyQlgsg2luMV2ZIH5i5o=
github.com/jinzhu/gorm v1.9.16/go.mod h1:G3LB3wezTOWM2ITLzPxEXgSkOXAntiLHS7UdBefADcs=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.0.1 h1:HjfetcXq097iXP0uoPCdnM4Efp5/9MsM0/M+XOTeR3M=
github.com/jinzhu/now v1.0.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/ledisdb/ledisdb v0.0.0-20200510135210-d35789ec47e6/go.mod h1:n931TsDuKuq+uX4v1fulaMbA/7ZLLhjc85h7chZGBCQ=
github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4=
github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-sqlite3 v1.14.0/go.mod h1:JIl7NbARA7phWnGvh0LKTyg7S9BA+6gx71ShQilpsus=
github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U=
github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg=
github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
github.com/pelletier/go-toml v1.0.1/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/peterh/liner v1.0.1-0.20171122030339-3681c2a91233/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
github.com/prometheus/client_golang v1.7.0/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
github.com/robfig/cron v1.2.0 h1:ZjScXvvxeQ63Dbyxy76Fj3AT3Ut0aKsyd2/tl3DTMuQ=
github.com/robfig/cron v1.2.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k=
github.com/shiena/ansicolor v0.0.0-20151119151921-a422bbe96644 h1:X+yvsM2yrEktyI+b2qND5gpH8YhURn0k8OCaeRnkINo=
github.com/shiena/ansicolor v0.0.0-20151119151921-a422bbe96644/go.mod h1:nkxAfR/5quYxwPZhyDxgasBMnRtBZd0FCEpawpjMUFg=
github.com/siddontang/go v0.0.0-20170517070808-cb568a3e5cc0/go.mod h1:3yhqj7WBBfRhbBlzyOC3gUxftwsU0u8gqevxwIHQpMw=
github.com/siddontang/goredis v0.0.0-20150324035039-760763f78400/go.mod h1:DDcKzU3qCuvj/tPnimWSsZZzvk9qvkvrIL5naVBPh5s=
github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d/go.mod h1:AMEsy7v5z92TR1JKMkLLoaOQk++LVnOKL3ScbJ8GNGA=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec/go.mod h1:QBvMkMya+gXctz3kmljlUCu/yB3GZ6oee+dUozsezQE=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/syndtr/goleveldb v0.0.0-20160425020131-cfa635847112/go.mod h1:Z4AUp2Km+PwemOoO/VB5AOx9XSsIItzFjoJlOSiYmn0=
github.com/syndtr/goleveldb v0.0.0-20181127023241-353a9fca669c/go.mod h1:Z4AUp2Km+PwemOoO/VB5AOx9XSsIItzFjoJlOSiYmn0=
github.com/ugorji/go v0.0.0-20171122102828-84cb69a8af83/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b/go.mod h1:Q12BUT7DqIlHRmgv3RskH+UCM/4eqVMgI0EMmlSpAXc=
github.com/xinliangnote/go-util v0.0.0-20210703052933-7f9f6d961276 h1:nF89kuTQE2eFcKcQorzi3JQUY44LrQ6R58bS1m2owjo=
github.com/xinliangnote/go-util v0.0.0-20210703052933-7f9f6d961276/go.mod h1:3ZornrplU9tYj9ar9jchik1XPQ10ZbSXkbgxXR5PVaU=
github.com/yuin/gopher-lua v0.0.0-20171031051903-609c9cd26973/go.mod h1:aEV29XrmTYFr3CiRxZeGHpkvbwq+prZduBqMaascyCU=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191205180655-e7c4368fe9dd/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 h1:kUhD7nTDoI3fVd9G4ORWrbV5NY0liEs/Jg2pv5f+bBA=
golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
gopkg.in/go-playground/validator.v9 v9.31.0 h1:bmXmP2RSNtFES+bn4uYuHT7iJFJv7Vj+an+ZQdDaD1M=
gopkg.in/go-playground/validator.v9 v9.31.0/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ=
gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
main.go 0 → 100644
View file @ d04eb576
package main
import (
"fmt"
"log"
"net/http"
"github.com/gin-gonic/gin"
"slg/models"
"slg/pkg/cron"
"slg/pkg/gredis"
"slg/pkg/setting"
"slg/pkg/util"
"slg/routers"
)
func init() {
setting.Setup()
models.Setup()
gredis.Setup()
util.Setup()
cron.Setup()
}
func main() {
gin.SetMode(setting.ServerSetting.RunMode)
routersInit := routers.InitRouter()
readTimeout := setting.ServerSetting.ReadTimeout
writeTimeout := setting.ServerSetting.WriteTimeout
endPoint := fmt.Sprintf(":%d", setting.ServerSetting.HttpPort)
maxHeaderBytes := 1 << 20
server := &http.Server{
Addr: endPoint,
Handler: routersInit,
ReadTimeout: readTimeout,
WriteTimeout: writeTimeout,
MaxHeaderBytes: maxHeaderBytes,
}
log.Printf("[info] start http server listening %s", endPoint)
server.ListenAndServe()
}
middleware/auth/auth.go 0 → 100644
View file @ d04eb576
package auth
import (
"slg/pkg/errno"
"slg/pkg/handler"
"slg/pkg/util"
"github.com/gin-gonic/gin"
"strings"
)
func AUTH() gin.HandlerFunc {
return func(ctx *gin.Context) {
token := ctx.Request.Header.Get("Token")
user, _ := util.ParseToken(token)
if !strings.Contains(strings.ToLower(user.UserInfo.Username), "kefu") {
return
}
handlerName := strings.Split(ctx.HandlerName(), ".")[1]
handleAlowed := []string{"GetCoinChains", "GetUserChains", "AddOperationLog"}
_, handle := util.Contains(handleAlowed, handlerName)
if !handle {
handler.SendResponse(ctx, errno.PermissionDenied, nil)
ctx.Abort()
return
}
ctx.Next()
}
}
middleware/jwt/jwt.go 0 → 100644
View file @ d04eb576
package jwt
import (
"slg/pkg/e"
"slg/pkg/util"
"github.com/dgrijalva/jwt-go"
"github.com/gin-gonic/gin"
"net/http"
)
func JWT() gin.HandlerFunc {
return func(c *gin.Context) {
var code int
var data interface{}
code = e.SUCCESS
token := c.Request.Header.Get("Token")
if token == "" {
code = e.INVALID_PARAMS
} else {
_, err := util.ParseToken(token)
if err != nil {
switch err.(*jwt.ValidationError).Errors {
case jwt.ValidationErrorExpired:
code = e.ERROR_AUTH_CHECK_TOKEN_TIMEOUT
default:
code = e.ERROR_AUTH_CHECK_TOKEN_FAIL
}
}
}
if code != e.SUCCESS {
c.JSON(http.StatusUnauthorized, gin.H{
"code": code,
"msg": e.GetMsg(code),
"data": data,
})
c.Abort()
return
}
c.Next()
}
}
middleware/log/log.go 0 → 100644
View file @ d04eb576
package log
import (
"slg/pkg/util"
"slg/service/operation_log_service"
"fmt"
"github.com/gin-gonic/gin"
"strconv"
"strings"
)
func LogMiddleware(handlerTableName map[string]string) gin.HandlerFunc {
return func(ctx *gin.Context) {
var operation string
// 获取当前用户信息
token := ctx.Request.Header.Get("Token")
user, err := util.ParseToken(token)
if err != nil {
ctx.Abort()
return
}
user_id := user.UserInfo.Uid
user_name := user.UserInfo.Username
platform_id := user.UserInfo.PlatformId
// 获取表名 这里会把前面 "加载的包名.HandlerName"
handlerName := strings.Split(ctx.HandlerName(), ".")[1]
if _, ok := handlerTableName[handlerName]; !ok {
ctx.Next()
}
tableDesc := strings.Split(handlerTableName[handlerName], ",")
if len(tableDesc) != 2 {
return // 存在映射，但是不完全则返回
}
tableName := tableDesc[0] // 0表名
desc := tableDesc[1] // 1业务描述
switch ctx.Request.Method {
case "POST":
operation = "增加"
case "GET":
operation = "查询"
case "PUT":
operation = "更新"
case "DELETE":
operation = "删除"
default:
operation = "未知"
}
operationLogService := operation_log_service.OperationLog{
UserId: user_id,
UserName: user_name,
PlatformId: platform_id,
Ip: ctx.ClientIP(),
Operation: operation,
Business: desc,
Table: tableName,
}
if err := operationLogService.Add(); err != nil {
ctx.Abort()
return
}
return
}
}
func FirstMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
fmt.Println(c.Request.Method, c.ClientIP(), c.Request.Header.Get("Token"))
fmt.Println("first middleware before next()")
isAbort := c.Query("isAbort")
bAbort, err := strconv.ParseBool(isAbort)
if err != nil {
fmt.Printf("is abort value err, value %s\n", isAbort)
c.Next() // (2)
}
if bAbort {
fmt.Println("first middleware abort") //(3)
c.Abort()
//c.AbortWithStatusJSON(http.StatusOK, "abort is true")
return
} else {
fmt.Println("first middleware doesnot abort") //(4)
return
}
fmt.Println("first middleware after next()")
}
}
func SecondMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
fmt.Println("current inside of second middleware")
}
}
middleware/sign/aes/aes.go 0 → 100644
View file @ d04eb576
package aes
import (
config "slg/conf"
"slg/pkg/errno"
"slg/pkg/handler"
"slg/pkg/util"
"errors"
"fmt"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"github.com/xinliangnote/go-util/aes"
"net/url"
"sort"
"strconv"
"strings"
"time"
)
var AppSecret string
// MD5 组合加密
func Aes() gin.HandlerFunc {
return func(c *gin.Context) {
sign, err := verifySign(c)
if sign != nil {
handler.SendResponse(c, nil, sign)
c.Abort()
return
}
if err != nil {
handler.SendResponse(c, err, nil)
c.Abort()
return
}
c.Next()
}
}
type Proof struct {
Ak string `json:"ak"`
Sn string `json:"sn"`
Ts string `json:"ts"`
Debug string `json:"debug"`
}
// 验证签名
func verifySign(c *gin.Context) (map[string]string, error) {
var params = make(map[string]interface{})
if c.Request.Method == "POST" || c.Request.Method == "PUT" {
c.ShouldBindBodyWith(&params, binding.JSON)
//var bodyBytes []byte
//if c.Request.Body != nil {
// bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
//}
//// 把刚刚读出来的再写进去
//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
//json.Unmarshal(bodyBytes, &params)
//fmt.Println(params)
}
if "GET" == c.Request.Method {
keys := c.Request.URL.Query()
for k, v := range keys {
params[k] = v[0]
}
}
_ = c.Request.ParseForm()
req := c.Request.Form
for key, value := range params {
req.Set(key, util.ToString(value))
}
debug := strings.Join(req["debug"], "")
ak := strings.Join(req["ak"], "")
sn := strings.Join(req["sn"], "")
ts := strings.Join(req["ts"], "")
// 验证来源
value, ok := config.ApiAuthConfig[ak]
if ok {
AppSecret = value["aes"]
} else {
return nil, errno.ErrAk
}
if debug == "1" {
currentUnix := util.GetCurrentUnix()
req.Set("ts", strconv.FormatInt(currentUnix, 10))
sn, err := createSign(req)
if err != nil {
return nil, errno.ErrSn
}
res := map[string]string{
"ts": strconv.FormatInt(currentUnix, 10),
"sn": sn,
}
return res, nil
}
// 验证过期时间
timestamp := time.Now().Unix()
exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
tsInt, _ := strconv.ParseInt(ts, 10, 64)
if tsInt > timestamp || timestamp-tsInt >= exp {
return nil, errno.ErrTs
}
// 验证签名
if sn == "" {
return nil, errno.ErrSn
}
decryptStr, decryptErr := aes.Decrypt(sn, []byte(AppSecret), AppSecret)
if decryptErr != nil {
return nil, errors.New(decryptErr.Error())
}
if decryptStr != createEncryptStr(req) {
return nil, errno.ErrSn
}
return nil, nil
}
// 创建签名
func createSign(params url.Values) (string, error) {
return aes.Encrypt(createEncryptStr(params), []byte(AppSecret), AppSecret)
}
func createEncryptStr(params url.Values) string {
var key []string
var str = ""
for k := range params {
if k != "sn" && k != "debug" {
key = append(key, k)
}
}
sort.Strings(key)
for i := 0; i < len(key); i++ {
if i == 0 {
str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
} else {
str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
}
}
return str
}
middleware/sign/md5/md5.go 0 → 100644
View file @ d04eb576
package md5
import (
config "slg/conf"
"slg/pkg/handler"
"slg/pkg/util"
"errors"
"fmt"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"net/url"
"sort"
"strconv"
"strings"
"time"
)
var AppSecret string
// MD5 组合加密
func Md5() gin.HandlerFunc {
return func(c *gin.Context) {
sign, err := verifySign(c)
if sign != nil {
handler.SendResponse(c, nil, sign)
c.Abort()
return
}
if err != nil {
handler.SendResponse(c, err, nil)
c.Abort()
return
}
c.Next()
}
}
// 验证签名
func verifySign(c *gin.Context) (map[string]string, error) {
var params = make(map[string]interface{})
if c.Request.Method == "POST" || c.Request.Method == "PUT" {
c.ShouldBindBodyWith(&params, binding.JSON)
//var bodyBytes []byte
//if c.Request.Body != nil {
// bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
//}
//// 把刚刚读出来的再写进去
//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
//json.Unmarshal(bodyBytes, &params)
//fmt.Println(params)
}
if "GET" == c.Request.Method {
keys := c.Request.URL.Query()
for k, v := range keys {
params[k] = v[0]
}
}
_ = c.Request.ParseForm()
req := c.Request.Form
for key, value := range params {
req.Set(key, util.ToString(value))
}
debug := strings.Join(req["debug"], "")
ak := strings.Join(req["ak"], "")
sn := strings.Join(req["sn"], "")
ts := strings.Join(req["ts"], "")
// 验证来源
value, ok := config.ApiAuthConfig[ak]
if ok {
AppSecret = value["md5"]
} else {
return nil, errors.New("ak Error")
}
if debug == "1" {
currentUnix := util.GetCurrentUnix()
req.Set("ts", strconv.FormatInt(currentUnix, 10))
res := map[string]string{
"ts": strconv.FormatInt(currentUnix, 10),
"sn": createSign(req),
}
return res, nil
}
// 验证过期时间
timestamp := time.Now().Unix()
exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
tsInt, _ := strconv.ParseInt(ts, 10, 64)
if tsInt > timestamp || timestamp-tsInt >= exp {
return nil, errors.New("ts Error")
}
// 验证签名
if sn == "" || sn != createSign(req) {
return nil, errors.New("sn Error")
}
return nil, nil
}
// 创建签名
func createSign(params url.Values) string {
// 自定义 MD5 组合
return util.EncodeMD5(AppSecret + createEncryptStr(params) + AppSecret)
}
func createEncryptStr(params url.Values) string {
var key []string
var str = ""
for k := range params {
if k != "sn" && k != "debug" {
key = append(key, k)
}
}
sort.Strings(key)
for i := 0; i < len(key); i++ {
if i == 0 {
str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
} else {
str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
}
}
return str
}
middleware/sign/rsa/rsa.go 0 → 100644
View file @ d04eb576
package rsa
import (
config "slg/conf"
"slg/pkg/errno"
"slg/pkg/handler"
"slg/pkg/util"
"errors"
"fmt"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"github.com/xinliangnote/go-util/rsa"
"net/url"
"sort"
"strconv"
"strings"
"time"
)
var AppSecret string
// RSA 非对称加密
func Rsa() gin.HandlerFunc {
return func(c *gin.Context) {
sign, err := verifySign(c)
if sign != nil {
handler.SendResponse(c, nil, sign)
c.Abort()
return
}
if err != nil {
handler.SendResponse(c, err, nil)
c.Abort()
return
}
c.Next()
}
}
// 验证签名
func verifySign(c *gin.Context) (map[string]string, error) {
var params = make(map[string]interface{})
if c.Request.Method == "POST" || c.Request.Method == "PUT" {
c.ShouldBindBodyWith(&params, binding.JSON)
//var bodyBytes []byte
//if c.Request.Body != nil {
// bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
//}
//// 把刚刚读出来的再写进去
//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
//json.Unmarshal(bodyBytes, &params)
//fmt.Println(params)
}
if "GET" == c.Request.Method {
keys := c.Request.URL.Query()
for k, v := range keys {
params[k] = v[0]
}
}
_ = c.Request.ParseForm()
req := c.Request.Form
for key, value := range params {
req.Set(key, util.ToString(value))
}
debug := strings.Join(req["debug"], "")
ak := strings.Join(req["ak"], "")
sn := strings.Join(req["sn"], "")
ts := strings.Join(req["ts"], "")
// 验证来源
value, ok := config.ApiAuthConfig[ak]
if ok {
AppSecret = value["rsa"]
} else {
return nil, errno.ErrAk
}
if debug == "1" {
currentUnix := util.GetCurrentUnix()
req.Set("ts", strconv.FormatInt(currentUnix, 10))
sn, err := createSign(req)
if err != nil {
return nil, errno.ErrSn
}
res := map[string]string{
"ts": strconv.FormatInt(currentUnix, 10),
"sn": sn,
}
return res, nil
}
// 验证过期时间
timestamp := time.Now().Unix()
exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
tsInt, _ := strconv.ParseInt(ts, 10, 64)
if tsInt > timestamp || timestamp-tsInt >= exp {
return nil, errno.ErrTs
}
// 验证签名
if sn == "" {
return nil, errno.ErrSn
}
decryptStr, decryptErr := rsa.PrivateDecrypt(sn, config.AppRsaPrivateFile)
if decryptErr != nil {
return nil, errors.New(decryptErr.Error())
}
if decryptStr != createEncryptStr(req) {
return nil, errno.ErrSn
}
return nil, nil
}
// 创建签名
func createSign(params url.Values) (string, error) {
return rsa.PublicEncrypt(createEncryptStr(params), AppSecret)
}
func createEncryptStr(params url.Values) string {
var key []string
var str = ""
for k := range params {
if k != "sn" && k != "debug" {
key = append(key, k)
}
}
sort.Strings(key)
for i := 0; i < len(key); i++ {
if i == 0 {
str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
} else {
str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
}
}
return str
}
models/bank.go 0 → 100644
View file @ d04eb576
package models
import (
"slg/pkg/setting"
)
type Bank struct {
id uint32 `gorm:"type:int(11);primary key"`
BankName string `gorm:"type:varchar(64);not null"`
}
func (b Bank) TableName() string {
return setting.DatabaseSetting.Name + ".bank"
}
func AddBank(data map[string]interface{}) (error) {
bank := Bank{
BankName: data["bankname"].(string),
}
if err := db.Create(&bank).Error; err != nil {
return err
}
return nil
}
\ No newline at end of file
models/model.go 0 → 100644
View file @ d04eb576
package models
import (
"time"
)
type BaseModel struct {
ID uint `gorm:"primary_key"`
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
DeletedAt *time.Time `json:"deletedAt"`
}
models/models.go 0 → 100644
View file @ d04eb576
package models
import (
"fmt"
"log"
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/mysql"
"slg/pkg/setting"
"time"
)
var db *gorm.DB
type Model struct {
ID int `gorm:"primary_key" json:"id"`
//CreatedOn int `json:"created_on"`
//ModifiedOn int `json:"modified_on"`
//DeletedOn int `json:"deleted_on"`
}
// Setup initializes the database instance
func Setup() {
var err error
db, err = gorm.Open(setting.DatabaseSetting.Type, fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local",
setting.DatabaseSetting.User,
setting.DatabaseSetting.Password,
setting.DatabaseSetting.Host,
setting.DatabaseSetting.Name))
if err != nil {
log.Fatalf("models.Setup err: %v", err)
}
gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
//return setting.DatabaseSetting.TablePrefix + defaultTableName
return defaultTableName
}
db.SingularTable(true)
//db.Callback().Create().Replace("gorm:update_time_stamp", updateTimeStampForCreateCallback)
//db.Callback().Update().Replace("gorm:update_time_stamp", updateTimeStampForUpdateCallback)
//db.Callback().Delete().Replace("gorm:delete", deleteCallback)
db.DB().SetMaxIdleConns(10)
db.DB().SetMaxOpenConns(100)
}
// CloseDB closes database connection (unnecessary)
func CloseDB() {
defer db.Close()
}
// updateTimeStampForCreateCallback will set `CreatedOn`, `ModifiedOn` when creating
func updateTimeStampForCreateCallback(scope *gorm.Scope) {
if !scope.HasError() {
nowTime := time.Now().Unix()
if createTimeField, ok := scope.FieldByName("CreatedOn"); ok {
if createTimeField.IsBlank {
createTimeField.Set(nowTime)
}
}
if modifyTimeField, ok := scope.FieldByName("ModifiedOn"); ok {
if modifyTimeField.IsBlank {
modifyTimeField.Set(nowTime)
}
}
}
}
// updateTimeStampForUpdateCallback will set `ModifiedOn` when updating
func updateTimeStampForUpdateCallback(scope *gorm.Scope) {
if _, ok := scope.Get("gorm:update_column"); !ok {
scope.SetColumn("ModifiedOn", time.Now().Unix())
}
}
// deleteCallback will set `DeletedOn` where deleting
func deleteCallback(scope *gorm.Scope) {
if !scope.HasError() {
var extraOption string
if str, ok := scope.Get("gorm:delete_option"); ok {
extraOption = fmt.Sprint(str)
}
deletedOnField, hasDeletedOnField := scope.FieldByName("DeletedOn")
if !scope.Search.Unscoped && hasDeletedOnField {
scope.Raw(fmt.Sprintf(
"UPDATE %v SET %v=%v%v%v",
scope.QuotedTableName(),
scope.Quote(deletedOnField.DBName),
scope.AddToVars(time.Now().Unix()),
addExtraSpaceIfExist(scope.CombinedConditionSql()),
addExtraSpaceIfExist(extraOption),
)).Exec()
} else {
scope.Raw(fmt.Sprintf(
"DELETE FROM %v%v%v",
scope.QuotedTableName(),
addExtraSpaceIfExist(scope.CombinedConditionSql()),
addExtraSpaceIfExist(extraOption),
)).Exec()
}
}
}
// addExtraSpaceIfExist adds a separator
func addExtraSpaceIfExist(str string) string {
if str != "" {
return " " + str
}
return ""
}
pkg/cron/cron.go 0 → 100644
View file @ d04eb576
package cron
import (
"github.com/robfig/cron"
)
var c *cron.Cron
func Setup() {
c = cron.New()
c.AddFunc("* * * * * *", func() {
})
c.Start()
}
pkg/e/code.go 0 → 100644
View file @ d04eb576
package e
const (
SUCCESS = 200
ERROR = 500
INVALID_PARAMS = 400
ERROR_AUTH_CHECK_TOKEN_FAIL = 40001
ERROR_AUTH_CHECK_TOKEN_TIMEOUT = 40002
ERROR_AUTH_TOKEN = 40003
ERROR_AUTH = 40004
)
pkg/e/msg.go 0 → 100644
View file @ d04eb576
package e
var MsgFlags = map[int]string{
SUCCESS: "ok",
ERROR: "fail",
INVALID_PARAMS: "请求参数错误",
}
// GetMsg get error information based on Code
func GetMsg(code int) string {
msg, ok := MsgFlags[code]
if ok {
return msg
}
return MsgFlags[ERROR]
}
pkg/encrypt/encrypt.go 0 → 100644
View file @ d04eb576
package encrypt
import (
config "slg/conf"
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"golang.org/x/crypto/bcrypt"
)
// 加密 aes_128_cbc
func AesEncrypt(encryptStr string, key []byte, iv string) (string, error) {
encryptBytes := []byte(encryptStr)
block, err := aes.NewCipher(key)
if err != nil {
return "", err
}
blockSize := block.BlockSize()
encryptBytes = pkcs5Padding(encryptBytes, blockSize)
blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
encrypted := make([]byte, len(encryptBytes))
blockMode.CryptBlocks(encrypted, encryptBytes)
return base64.URLEncoding.EncodeToString(encrypted), nil
}
// 解密
func AesDecrypt(decryptStr string, key []byte, iv string) (string, error) {
decryptBytes, err := base64.URLEncoding.DecodeString(decryptStr)
if err != nil {
return "", err
}
block, err := aes.NewCipher(key)
if err != nil {
return "", err
}
blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
decrypted := make([]byte, len(decryptBytes))
blockMode.CryptBlocks(decrypted, decryptBytes)
decrypted = pkcs5UnPadding(decrypted)
return string(decrypted), nil
}
func pkcs5Padding(cipherText []byte, blockSize int) []byte {
padding := blockSize - len(cipherText)%blockSize
padText := bytes.Repeat([]byte{byte(padding)}, padding)
return append(cipherText, padText...)
}
func pkcs5UnPadding(decrypted []byte) []byte {
length := len(decrypted)
unPadding := int(decrypted[length-1])
return decrypted[:(length - unPadding)]
}
func HashPassword(password string) (string, error) {
bytes, err := bcrypt.GenerateFromPassword([]byte(password), config.PASSWORD_DEFAULT)
return string(bytes), err
}
func CheckPasswordHash(password, hash string) bool {
err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
return err == nil
}
pkg/errno/errno.go 0 → 100644
View file @ d04eb576
package errno
import "fmt"
type Errno struct {
Code int
Message string
}
func (err Errno) Error() string {
return err.Message
}
// Err represents an error
type Err struct {
Code int
Message string
Err error
}
func New(errno *Errno, err error) *Err {
return &Err{Code: errno.Code, Message: errno.Message, Err: err}
}
func (err *Err) Add(message string) error {
err.Message += " " + message
return err
}
func (err *Err) Addf(format string, args ...interface{}) error {
err.Message += " " + fmt.Sprintf(format, args...)
return err
}
func (err *Err) Error() string {
return fmt.Sprintf("Err - code: %d, message: %s, error: %s", err.Code, err.Message, err.Err)
}
func DecodeErr(err error) (int, string) {
if err == nil {
return OK.Code, OK.Message
}
switch typed := err.(type) {
case *Err:
return typed.Code, typed.Message
case *Errno:
return typed.Code, typed.Message
default:
}
return InternalServerError.Code, err.Error()
}
var (
// Common errors
OK = &Errno{Code: 0, Message: "OK"}
InternalServerError = &Errno{Code: 10001, Message: "Internal server error"}
ErrBind = &Errno{Code: 10002, Message: "Error occurred while binding the request body to the struct."}
ErrValidation = &Errno{Code: 20001, Message: "Validation failed."}
ErrDatabase = &Errno{Code: 20002, Message: "Database error."}
ErrTs = &Errno{Code: 20003, Message: "Ts error."}
ErrSn = &Errno{Code: 20004, Message: "Sn error."}
ErrAk = &Errno{Code: 20005, Message: "Ak error."}
PermissionDenied = &Errno{Code: 403, Message: "Permission Denied"}
// bank errors
ErrBankNotFound = &Errno{Code: 20101, Message: "银行账号绑定未找到."}
ErrAddBank = &Errno{Code: 20102, Message: "银行账号绑定失败."}
ErrUpdateBank = &Errno{Code: 20103, Message: "银行账号更新失败."}
ErrDeleteBank = &Errno{Code: 20104, Message: "银行账号删除失败."}
)
pkg/file/file.go 0 → 100644
View file @ d04eb576
package file
import (
"fmt"
"io/ioutil"
"mime/multipart"
"os"
"path"
)
// GetSize get the file size
func GetSize(f multipart.File) (int, error) {
content, err := ioutil.ReadAll(f)
return len(content), err
}
// GetExt get the file ext
func GetExt(fileName string) string {
return path.Ext(fileName)
}
// CheckNotExist check if the file exists
func CheckNotExist(src string) bool {
_, err := os.Stat(src)
return os.IsNotExist(err)
}
// CheckPermission check if the file has permission
func CheckPermission(src string) bool {
_, err := os.Stat(src)
return os.IsPermission(err)
}
// IsNotExistMkDir create a directory if it does not exist
func IsNotExistMkDir(src string) error {
if notExist := CheckNotExist(src); notExist == true {
if err := MkDir(src); err != nil {
return err
}
}
return nil
}
// MkDir create a directory
func MkDir(src string) error {
err := os.MkdirAll(src, os.ModePerm)
if err != nil {
return err
}
return nil
}
// Open a file according to a specific mode
func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
f, err := os.OpenFile(name, flag, perm)
if err != nil {
return nil, err
}
return f, nil
}
// MustOpen maximize trying to open the file
func MustOpen(fileName, filePath string) (*os.File, error) {
dir, err := os.Getwd()
if err != nil {
return nil, fmt.Errorf("os.Getwd err: %v", err)
}
src := dir + "/" + filePath
perm := CheckPermission(src)
if perm == true {
return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
}
err = IsNotExistMkDir(src)
if err != nil {
return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
}
f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
if err != nil {
return nil, fmt.Errorf("Fail to OpenFile :%v", err)
}
return f, nil
}
pkg/gredis/cache.go 0 → 100644
View file @ d04eb576
package gredis
import (
"slg/pkg/util"
"github.com/gomodule/redigo/redis"
"time"
)
var (
DEFAULT = time.Duration(0) // 过期时间 不设置
FOREVER = time.Duration(-1) // 过期时间不设置
)
type Cache struct {
pool *redis.Pool
defaultExpiration time.Duration
}
// 返回cache 对象, 在多个工具之间建立一个 中间初始化的时候使用
func NewRedisCache(db int, host string, defaultExpiration time.Duration) Cache {
pool := &redis.Pool{
MaxActive: 100, // 最大连接数，即最多的tcp连接数，一般建议往大的配置，但不要超过操作系统文件句柄个数（centos下可以ulimit -n查看）
MaxIdle: 100, // 最大空闲连接数，即会有这么多个连接提前等待着，但过了超时时间也会关闭。
IdleTimeout: time.Duration(100) * time.Second, // 空闲连接超时时间，但应该设置比redis服务器超时时间短。否则服务端超时了，客户端保持着连接也没用
Wait: true, // 当超过最大连接数 是报错还是等待， true 等待 false 报错
Dial: func() (redis.Conn, error) {
conn, err := redis.Dial("tcp", host, redis.DialDatabase(db))
if err != nil {
return nil, err
}
return conn, nil
},
}
return Cache{pool: pool, defaultExpiration: defaultExpiration}
}
// string 类型 添加, v 可以是任意类型
func (c Cache) StringSet(name string, v interface{}) error {
conn := c.pool.Get()
s, _ := util.Serialization(v) // 序列化
defer conn.Close()
_, err := conn.Do("SET", name, s)
return err
}
// 获取 字符串类型的值
func (c Cache) StringGet(name string, v interface{}) error {
conn := c.pool.Get()
defer conn.Close()
temp, _ := redis.Bytes(conn.Do("Get", "yang"))
err := util.Deserialization(temp, &v) // 反序列化
return err
}
func (c Cache) stringGetTest() {
//var need []string
//var need int32
var need int64
//Deserialization(aa, &need)
c.StringGet("yang", &need)
}
// 判断所在的 key 是否存在
func (c Cache) Exist(name string) (bool, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Bool(conn.Do("EXISTS", name))
return v, err
}
// 自增
func (c Cache) StringIncr(name string) (int, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Int(conn.Do("INCR", name))
return v, err
}
// 设置过期时间 （单位 秒）
func (c Cache) Expire(name string, newSecondsLifeTime int64) error {
// 设置key 的过期时间
conn := c.pool.Get()
defer conn.Close()
_, err := conn.Do("EXPIRE", name, newSecondsLifeTime)
return err
}
// 删除指定的键
func (c Cache) Delete(keys ...interface{}) (bool, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Bool(conn.Do("DEL", keys...))
return v, err
}
// 查看指定的长度
func (c Cache) StrLen(name string) (int, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Int(conn.Do("STRLEN", name))
return v, err
}
// ////////////////// hash ///////////
// 删除指定的 hash 键
func (c Cache) Hdel(name, key string) (bool, error) {
conn := c.pool.Get()
defer conn.Close()
var err error
v, err := redis.Bool(conn.Do("HDEL", name, key))
return v, err
}
// 查看hash 中指定是否存在
func (c Cache) HExists(name, field string) (bool, error) {
conn := c.pool.Get()
defer conn.Close()
var err error
v, err := redis.Bool(conn.Do("HEXISTS", name, field))
return v, err
}
// 获取hash 的键的个数
func (c Cache) HLen(name string) (int, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Int(conn.Do("HLEN", name))
return v, err
}
// 传入的 字段列表获得对应的值
func (c Cache) HMget(name string, fields ...string) ([]interface{}, error) {
conn := c.pool.Get()
defer conn.Close()
args := []interface{}{name}
for _, field := range fields {
args = append(args, field)
}
value, err := redis.Values(conn.Do("HMGET", args...))
return value, err
}
// 设置单个值, value 还可以是一个 map slice 等
func (c Cache) HSet(name string, key string, value interface{}) (err error) {
conn := c.pool.Get()
defer conn.Close()
v, _ := util.Serialization(value)
_, err = conn.Do("HSET", name, key, v)
return
}
// 设置多个值 , obj 可以是指针 slice map struct
func (c Cache) HMSet(name string, obj interface{}) (err error) {
conn := c.pool.Get()
defer conn.Close()
_, err = conn.Do("HSET", redis.Args{}.Add(name).AddFlat(&obj)...)
return
}
// 获取单个hash 中的值
func (c Cache) HGet(name, field string, v interface{}) (err error) {
conn := c.pool.Get()
defer conn.Close()
temp, _ := redis.Bytes(conn.Do("Get", name, field))
err = util.Deserialization(temp, &v) // 反序列化
return
}
// set 集合
// 获取 set 集合中所有的元素, 想要什么类型的自己指定
func (c Cache) Smembers(name string, v interface{}) (err error) {
conn := c.pool.Get()
defer conn.Close()
temp, _ := redis.Bytes(conn.Do("smembers", name))
err = util.Deserialization(temp, &v)
return err
}
// 获取集合中元素的个数
func (c Cache) ScardInt64s(name string) (int64, error) {
conn := c.pool.Get()
defer conn.Close()
v, err := redis.Int64(conn.Do("SCARD", name))
return v, err
}
pkg/gredis/redis.go 0 → 100644
View file @ d04eb576
package gredis
import (
"slg/pkg/setting"
"encoding/json"
"github.com/gomodule/redigo/redis"
"time"
)
var RedisConn *redis.Pool
func Setup() error {
RedisConn = &redis.Pool{
MaxIdle: setting.RedisSetting.MaxIdle,
MaxActive: setting.RedisSetting.MaxActive,
IdleTimeout: setting.RedisSetting.IdleTimeout,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", setting.RedisSetting.Host)
if err != nil {
return nil, err
}
if setting.RedisSetting.Password != "" {
if _, err := c.Do("AUTH", setting.RedisSetting.Password); err != nil {
c.Close()
return nil, err
}
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
return nil
}
//设置指定 key 的值
func Set(key string, data interface{}, time int, db int) error {
conn := RedisConn.Get()
defer conn.Close()
value, err := json.Marshal(data)
if err != nil {
return err
}
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return err
}
_, err = conn.Do("SET", key, value)
if err != nil {
return err
}
_, err = conn.Do("EXPIRE", key, time)
if err != nil {
return err
}
return nil
}
//获取指定 key 的值
func Get(key string, db int) ([]byte, error) {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return nil, err
}
reply, err := redis.Bytes(conn.Do("GET", key))
if err != nil {
return nil, err
}
return reply, nil
}
func Exists(key string, db int) bool {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return false
}
exists, err := redis.Bool(conn.Do("EXISTS", key))
if err != nil {
return false
}
return exists
}
//向有序集合添加一个或多个成员，或者更新已存在成员的分数
func ZAdd(key string, score int, data interface{}, db int) error {
conn := RedisConn.Get()
defer conn.Close()
value, err := json.Marshal(data)
if err != nil {
return err
}
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return err
}
_, err = conn.Do("ZADD", key, score, value)
if err != nil {
return err
}
return nil
}
func HashSet(key, field string, data interface{}, db int) error {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return err
}
_, err := conn.Do("HSet", key, field, data)
if err != nil {
return err
}
return nil
}
func HashGet(key, field string, db int) ([]byte, error) {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return nil, err
}
val, err := redis.Bytes(conn.Do("hget", key, field))
if err != nil {
return nil, err
}
return val, nil
}
//通过索引区间返回有序集合指定区间内的成员
func ZRange(key string, start, stop int, db int) ([]string, error) {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return nil, err
}
rep, err := redis.Strings(conn.Do("ZRANGE", key, start, stop))
if err != nil {
return nil, err
}
return rep, nil
}
func Delete(key string, db int) (bool, error) {
conn := RedisConn.Get()
defer conn.Close()
if _, err := conn.Do("SELECT", db); err != nil {
conn.Close()
return false, err
}
return redis.Bool(conn.Do("DEL", key))
}
pkg/handler/handler.go 0 → 100644
View file @ d04eb576
package handler
import (
"github.com/gin-gonic/gin"
"net/http"
"slg/pkg/errno"
)
//返回数据的结构体
type Response struct {
Code int `json:"code"`
Msg string `json:"msg"`
Data interface{} `json:"data"`
}
func SendResponse(c *gin.Context, err error, data interface{}) {
if errno.ErrBind == err {
code, _ := errno.DecodeErr(err)
msg := data.(string)
c.JSON(http.StatusOK, Response{
Code: code,
Msg: msg,
Data: nil,
})
} else {
code, msg := errno.DecodeErr(err)
c.JSON(http.StatusOK, Response{
Code: code,
Msg: msg,
Data: data,
})
}
}
pkg/setting/setting.go 0 → 100644
View file @ d04eb576
package setting
import (
"log"
"time"
"github.com/go-ini/ini"
)
type App struct {
JwtSecret string
Audience string
Issuer string
PageSize int
Timeout int
PrefixUrl string
RuntimeRootPath string
ImageSavePath string
ImageMaxSize int
ImageAllowExts []string
FileSavePath string
FileMaxSize int
FileAllowExts []string
ExportSavePath string
QrCodeSavePath string
FontSavePath string
LogSavePath string
LogSaveName string
LogFileExt string
TimeFormat string
}
var AppSetting = &App{}
type Server struct {
RunMode string
HttpPort int
ReadTimeout time.Duration
WriteTimeout time.Duration
}
var ServerSetting = &Server{}
type Database struct {
Type string
User string
Password string
Host string
Name string
TablePrefix string
}
var DatabaseSetting = &Database{}
type Redis struct {
Host string
Password string
MaxIdle int
MaxActive int
IdleTimeout time.Duration
}
var RedisSetting = &Redis{}
type Oss struct {
AccessKeyId string
AccessKeySecret string
Endpoint string
Bucket string
}
var OssSetting = &Oss{}
var cfg *ini.File
// Setup initialize the configuration instance
func Setup() {
var err error
cfg, err = ini.Load("conf/app.ini")
if err != nil {
log.Fatalf("setting.Setup, fail to parse 'conf/h5.ini': %v", err)
}
mapTo("h5", AppSetting)
mapTo("server", ServerSetting)
mapTo("database", DatabaseSetting)
mapTo("redis", RedisSetting)
mapTo("oss", OssSetting)
AppSetting.ImageMaxSize = AppSetting.ImageMaxSize * 1024 * 1024
AppSetting.FileMaxSize = AppSetting.FileMaxSize * 1024 * 1024
ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
ServerSetting.WriteTimeout = ServerSetting.ReadTimeout * time.Second
RedisSetting.IdleTimeout = RedisSetting.IdleTimeout * time.Second
}
// mapTo map section
func mapTo(section string, v interface{}) {
err := cfg.Section(section).MapTo(v)
if err != nil {
log.Fatalf("Cfg.MapTo RedisSetting err: %v", err)
}
}
pkg/snowflake/snowflake.go 0 → 100644
View file @ d04eb576
// Package snowflake provides a very simple Twitter snowflake generator and parser.
package snowflake
import (
"encoding/base64"
"encoding/binary"
"errors"
"fmt"
"strconv"
"sync"
"time"
)
var (
// Epoch is set to the twitter snowflake epoch of Nov 04 2010 01:42:54 UTC in milliseconds
// You may customize this to set a different epoch for your application.
Epoch int64 = 1288834974657
// NodeBits holds the number of bits to use for Node
// Remember, you have a total 22 bits to share between Node/Step
NodeBits uint8 = 10
// StepBits holds the number of bits to use for Step
// Remember, you have a total 22 bits to share between Node/Step
StepBits uint8 = 12
// DEPRECATED: the below four variables will be removed in a future release.
mu sync.Mutex
nodeMax int64 = -1 ^ (-1 << NodeBits)
nodeMask = nodeMax << StepBits
stepMask int64 = -1 ^ (-1 << StepBits)
timeShift = NodeBits + StepBits
nodeShift = StepBits
)
const encodeBase32Map = "ybndrfg8ejkmcpqxot1uwisza345h769"
var decodeBase32Map [256]byte
const encodeBase58Map = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
var decodeBase58Map [256]byte
// A JSONSyntaxError is returned from UnmarshalJSON if an invalid ID is provided.
type JSONSyntaxError struct{ original []byte }
func (j JSONSyntaxError) Error() string {
return fmt.Sprintf("invalid snowflake ID %q", string(j.original))
}
// ErrInvalidBase58 is returned by ParseBase58 when given an invalid []byte
var ErrInvalidBase58 = errors.New("invalid base58")
// ErrInvalidBase32 is returned by ParseBase32 when given an invalid []byte
var ErrInvalidBase32 = errors.New("invalid base32")
// Create maps for decoding Base58/Base32.
// This speeds up the process tremendously.
func init() {
for i := 0; i < len(encodeBase58Map); i++ {
decodeBase58Map[i] = 0xFF
}
for i := 0; i < len(encodeBase58Map); i++ {
decodeBase58Map[encodeBase58Map[i]] = byte(i)
}
for i := 0; i < len(encodeBase32Map); i++ {
decodeBase32Map[i] = 0xFF
}
for i := 0; i < len(encodeBase32Map); i++ {
decodeBase32Map[encodeBase32Map[i]] = byte(i)
}
}
// A Node struct holds the basic information needed for a snowflake generator
// node
type Node struct {
mu sync.Mutex
epoch time.Time
time int64
node int64
step int64
nodeMax int64
nodeMask int64
stepMask int64
timeShift uint8
nodeShift uint8
}
// An ID is a custom type used for a snowflake ID. This is used so we can
// attach methods onto the ID.
type ID int64
// NewNode returns a new snowflake node that can be used to generate snowflake
// IDs
func NewNode(node int64) (*Node, error) {
// re-calc in case custom NodeBits or StepBits were set
// DEPRECATED: the below block will be removed in a future release.
mu.Lock()
nodeMax = -1 ^ (-1 << NodeBits)
nodeMask = nodeMax << StepBits
stepMask = -1 ^ (-1 << StepBits)
timeShift = NodeBits + StepBits
nodeShift = StepBits
mu.Unlock()
n := Node{}
n.node = node
n.nodeMax = -1 ^ (-1 << NodeBits)
n.nodeMask = n.nodeMax << StepBits
n.stepMask = -1 ^ (-1 << StepBits)
n.timeShift = NodeBits + StepBits
n.nodeShift = StepBits
if n.node < 0 || n.node > n.nodeMax {
return nil, errors.New("Node number must be between 0 and " + strconv.FormatInt(n.nodeMax, 10))
}
var curTime = time.Now()
// add time.Duration to curTime to make sure we use the monotonic clock if available
n.epoch = curTime.Add(time.Unix(Epoch/1000, (Epoch%1000)*1000000).Sub(curTime))
return &n, nil
}
// Generate creates and returns a unique snowflake ID
// To help guarantee uniqueness
// - Make sure your system is keeping accurate system time
// - Make sure you never have multiple nodes running with the same node ID
func (n *Node) Generate() ID {
n.mu.Lock()
now := time.Since(n.epoch).Nanoseconds() / 1000000
if now == n.time {
n.step = (n.step + 1) & n.stepMask
if n.step == 0 {
for now <= n.time {
now = time.Since(n.epoch).Nanoseconds() / 1000000
}
}
} else {
n.step = 0
}
n.time = now
r := ID((now)<<n.timeShift |
(n.node << n.nodeShift) |
(n.step),
)
n.mu.Unlock()
return r
}
// Int64 returns an int64 of the snowflake ID
func (f ID) Int64() int64 {
return int64(f)
}
// ParseInt64 converts an int64 into a snowflake ID
func ParseInt64(id int64) ID {
return ID(id)
}
// String returns a string of the snowflake ID
func (f ID) String() string {
return strconv.FormatInt(int64(f), 10)
}
// ParseString converts a string into a snowflake ID
func ParseString(id string) (ID, error) {
i, err := strconv.ParseInt(id, 10, 64)
return ID(i), err
}
// Base2 returns a string base2 of the snowflake ID
func (f ID) Base2() string {
return strconv.FormatInt(int64(f), 2)
}
// ParseBase2 converts a Base2 string into a snowflake ID
func ParseBase2(id string) (ID, error) {
i, err := strconv.ParseInt(id, 2, 64)
return ID(i), err
}
// Base32 uses the z-base-32 character set but encodes and decodes similar
// to base58, allowing it to create an even smaller result string.
// NOTE: There are many different base32 implementations so becareful when
// doing any interoperation.
func (f ID) Base32() string {
if f < 32 {
return string(encodeBase32Map[f])
}
b := make([]byte, 0, 12)
for f >= 32 {
b = append(b, encodeBase32Map[f%32])
f /= 32
}
b = append(b, encodeBase32Map[f])
for x, y := 0, len(b)-1; x < y; x, y = x+1, y-1 {
b[x], b[y] = b[y], b[x]
}
return string(b)
}
// ParseBase32 parses a base32 []byte into a snowflake ID
// NOTE: There are many different base32 implementations so becareful when
// doing any interoperation.
func ParseBase32(b []byte) (ID, error) {
var id int64
for i := range b {
if decodeBase32Map[b[i]] == 0xFF {
return -1, ErrInvalidBase32
}
id = id*32 + int64(decodeBase32Map[b[i]])
}
return ID(id), nil
}
// Base36 returns a base36 string of the snowflake ID
func (f ID) Base36() string {
return strconv.FormatInt(int64(f), 36)
}
// ParseBase36 converts a Base36 string into a snowflake ID
func ParseBase36(id string) (ID, error) {
i, err := strconv.ParseInt(id, 36, 64)
return ID(i), err
}
// Base58 returns a base58 string of the snowflake ID
func (f ID) Base58() string {
if f < 58 {
return string(encodeBase58Map[f])
}
b := make([]byte, 0, 11)
for f >= 58 {
b = append(b, encodeBase58Map[f%58])
f /= 58
}
b = append(b, encodeBase58Map[f])
for x, y := 0, len(b)-1; x < y; x, y = x+1, y-1 {
b[x], b[y] = b[y], b[x]
}
return string(b)
}
// ParseBase58 parses a base58 []byte into a snowflake ID
func ParseBase58(b []byte) (ID, error) {
var id int64
for i := range b {
if decodeBase58Map[b[i]] == 0xFF {
return -1, ErrInvalidBase58
}
id = id*58 + int64(decodeBase58Map[b[i]])
}
return ID(id), nil
}
// Base64 returns a base64 string of the snowflake ID
func (f ID) Base64() string {
return base64.StdEncoding.EncodeToString(f.Bytes())
}
// ParseBase64 converts a base64 string into a snowflake ID
func ParseBase64(id string) (ID, error) {
b, err := base64.StdEncoding.DecodeString(id)
if err != nil {
return -1, err
}
return ParseBytes(b)
}
// Bytes returns a byte slice of the snowflake ID
func (f ID) Bytes() []byte {
return []byte(f.String())
}
// ParseBytes converts a byte slice into a snowflake ID
func ParseBytes(id []byte) (ID, error) {
i, err := strconv.ParseInt(string(id), 10, 64)
return ID(i), err
}
// IntBytes returns an array of bytes of the snowflake ID, encoded as a
// big endian integer.
func (f ID) IntBytes() [8]byte {
var b [8]byte
binary.BigEndian.PutUint64(b[:], uint64(f))
return b
}
// ParseIntBytes converts an array of bytes encoded as big endian integer as
// a snowflake ID
func ParseIntBytes(id [8]byte) ID {
return ID(int64(binary.BigEndian.Uint64(id[:])))
}
// Time returns an int64 unix timestamp in milliseconds of the snowflake ID time
// DEPRECATED: the below function will be removed in a future release.
func (f ID) Time() int64 {
return (int64(f) >> timeShift) + Epoch
}
// Node returns an int64 of the snowflake ID node number
// DEPRECATED: the below function will be removed in a future release.
func (f ID) Node() int64 {
return int64(f) & nodeMask >> nodeShift
}
// Step returns an int64 of the snowflake step (or sequence) number
// DEPRECATED: the below function will be removed in a future release.
func (f ID) Step() int64 {
return int64(f) & stepMask
}
// MarshalJSON returns a json byte array string of the snowflake ID.
func (f ID) MarshalJSON() ([]byte, error) {
buff := make([]byte, 0, 22)
buff = append(buff, '"')
buff = strconv.AppendInt(buff, int64(f), 10)
buff = append(buff, '"')
return buff, nil
}
// UnmarshalJSON converts a json byte array of a snowflake ID into an ID type.
func (f *ID) UnmarshalJSON(b []byte) error {
if len(b) < 3 || b[0] != '"' || b[len(b)-1] != '"' {
return JSONSyntaxError{b}
}
i, err := strconv.ParseInt(string(b[1:len(b)-1]), 10, 64)
if err != nil {
return err
}
*f = ID(i)
return nil
}
pkg/util/convert.go 0 → 100644
View file @ d04eb576
package util
import (
"encoding/binary"
"encoding/json"
"fmt"
"math"
"reflect"
"strconv"
"strings"
)
// ToString returns the string result converted by src.
func ToString(src interface{}) string {
switch v := src.(type) {
case int, int8, int16, int32, int64:
return strconv.FormatInt(ToInt64(v), 10)
case uint, uint8, uint16, uint32, uint64, uintptr:
return strconv.FormatUint(ToUint64(v), 10)
case float32, float64, complex64, complex128:
return strconv.FormatFloat(ToFloat64(v), 'f', -1, 64)
case string:
return v
case []byte:
return string(v)
case []rune:
return string(v)
case bool:
return strconv.FormatBool(v)
default:
return fmt.Sprint(v)
}
}
// ToBool returns the bool result converted by src.
func ToBool(src interface{}) bool {
switch v := src.(type) {
case int, int8, int16, int32, int64:
return ToInt64(v) > 0
case uint, uint8, uint16, uint32, uint64, uintptr:
return ToUint64(v) > 0
case float32, float64, complex64, complex128:
return ToFloat64(v) > 0
case bool:
return v
case string, []byte, []rune:
result, _ := strconv.ParseBool(ToString(v))
return result
default:
return false
}
}
// ToInt returns the int result converted by src.
func ToInt(src interface{}) int {
return int(ToInt64(src))
}
// ToInt32 returns the int32 result converted by src.
func ToInt32(src interface{}) int32 {
return int32(ToInt64(src))
}
// ToInt64 returns the int64 result converted by src.
func ToInt64(src interface{}) int64 {
switch v := src.(type) {
case int:
return int64(v)
case int8:
return int64(v)
case int16:
return int64(v)
case int32:
return int64(v)
case int64:
return v
case uint:
return int64(v)
case uint8:
return int64(v)
case uint16:
return int64(v)
case uint32:
return int64(v)
case uint64:
return int64(v)
case uintptr:
return int64(v)
case float32:
return int64(v)
case float64:
return int64(v)
case complex64:
return int64(real(v))
case complex128:
return int64(real(v))
case bool:
if v {
return 1
}
return 0
case string:
v = strings.TrimSpace(v)
index := strings.Index(v, ".")
if index != -1 {
v = v[:index]
}
result, _ := strconv.ParseInt(v, 10, 64)
return result
case []byte:
return BytesToInt64(v)
default:
return 0
}
}
// ToUint returns the uint result converted by src.
func ToUint(src interface{}) uint {
return uint(ToUint64(src))
}
// ToUint32 returns the uint32 result converted by src.
func ToUint32(src interface{}) uint32 {
return uint32(ToUint64(src))
}
// ToUint64 returns the uint64 result converted by src.
func ToUint64(src interface{}) uint64 {
switch v := src.(type) {
case int:
return uint64(v)
case int8:
return uint64(v)
case int16:
return uint64(v)
case int32:
return uint64(v)
case int64:
return uint64(v)
case uint:
return uint64(v)
case uint8:
return uint64(v)
case uint16:
return uint64(v)
case uint32:
return uint64(v)
case uint64:
return v
case uintptr:
return uint64(v)
case float32:
return uint64(v)
case float64:
return uint64(v)
case complex64:
return uint64(real(v))
case complex128:
return uint64(real(v))
case bool:
if v {
return 1
}
return 0
case string:
v = strings.TrimSpace(v)
index := strings.Index(v, ".")
if index != -1 {
v = v[:index]
}
result, _ := strconv.ParseUint(v, 10, 64)
return result
case []byte:
return BytesToUint64(v)
default:
return 0
}
}
// ToFloat returns the float64 result converted by src.
func ToFloat(src interface{}) float64 {
return ToFloat64(src)
}
// ToFloat32 returns the float32 result converted by src.
func ToFloat32(src interface{}) float32 {
return float32(ToFloat64(src))
}
// ToFloat64 returns the float64 result converted by src.
func ToFloat64(src interface{}) float64 {
switch v := src.(type) {
case int, int8, int16, int32, int64:
return float64(ToInt64(v))
case uint, uint8, uint16, uint32, uint64, uintptr:
return float64(ToUint64(v))
case float32:
return float64(v)
case float64:
return v
case complex64:
return float64(real(v))
case complex128:
return real(v)
case bool:
if v {
return 1
}
return 0
case string:
v = strings.TrimSpace(v)
result, _ := strconv.ParseFloat(v, 64)
return result
case []byte:
return BytesToFloat64(v)
default:
return 0
}
}
// BytesToInt64 returns the int64 result converted by byte slice bytes.
func BytesToInt64(bytes []byte) int64 {
return int64(BytesToUint64(bytes))
}
// Int64ToBytes returns the byte slice result converted by int64 i.
func Int64ToBytes(i int64) []byte {
return Uint64ToBytes(uint64(i))
}
// BytesToUint64 returns the uint64 result converted by byte slice bytes.
func BytesToUint64(bytes []byte) uint64 {
return binary.BigEndian.Uint64(bytes)
}
// Uint64ToBytes returns the byte slice result converted by uint64 i.
func Uint64ToBytes(i uint64) []byte {
bytes := make([]byte, 8)
binary.BigEndian.PutUint64(bytes, i)
return bytes
}
// BytesToFloat64 returns the float64 result converted by byte slice bytes.
func BytesToFloat64(bytes []byte) float64 {
bits := binary.BigEndian.Uint64(bytes)
return math.Float64frombits(bits)
}
// Float64ToBytes returns the byte slice result converted by float64 f.
func Float64ToBytes(f float64) []byte {
bits := math.Float64bits(f)
bytes := make([]byte, 8)
binary.BigEndian.PutUint64(bytes, bits)
return bytes
}
// isStruct reports whether i is struct.
func isStruct(i interface{}) (reflect.Value, bool) {
v := reflect.ValueOf(i)
if v.Kind() == reflect.Ptr {
if v.IsNil() {
return reflect.Value{}, false
}
v = v.Elem()
}
if v.Kind() != reflect.Struct {
return reflect.Value{}, false
}
return v, true
}
// getStructFieldName returns the struct field name.
func getStructFieldName(sf reflect.StructField) string {
name := strings.SplitN(sf.Tag.Get("json"), ",", 2)[0]
if name == "-" {
return ""
} else if name == "" {
return sf.Name
}
return name
}
// StructToInterfaceMap returns the map[string]interface{} result converted by struct s.
func StructToInterfaceMap(s interface{}, ignoreZeroValue ...bool) map[string]interface{} {
m := make(map[string]interface{})
v, flag := isStruct(s)
if !flag {
return m
}
ignore := false
if len(ignoreZeroValue) != 0 {
ignore = ignoreZeroValue[0]
}
t := v.Type()
for i := 0; i < t.NumField(); i++ {
f := v.Field(i)
name := getStructFieldName(t.Field(i))
if name == "" || (ignore && f.IsZero()) {
continue
}
if f.Kind() == reflect.Ptr && !f.IsNil() {
f = f.Elem()
}
m[name] = f.Interface()
}
return m
}
// StructToStringMap returns the map[string]string result converted by struct s.
func StructToStringMap(s interface{}, ignoreZeroValue ...bool) map[string]string {
m := make(map[string]string)
v, flag := isStruct(s)
if !flag {
return m
}
ignore := false
if len(ignoreZeroValue) != 0 {
ignore = ignoreZeroValue[0]
}
t := v.Type()
for i := 0; i < t.NumField(); i++ {
f := v.Field(i)
name := getStructFieldName(t.Field(i))
if name == "" || (ignore && f.IsZero()) {
continue
}
if f.Kind() == reflect.Ptr && !f.IsNil() {
f = f.Elem()
}
m[name] = ToString(f.Interface())
}
return m
}
// ObjToMapString 将struct结构体转换成map
func ObjToMapString(obj interface{}) map[string]string {
m := make(map[string]string)
elem := reflect.ValueOf(obj).Elem()
relType := elem.Type()
for i := 0; i < relType.NumField(); i++ {
m[relType.Field(i).Name] = ToString(elem.Field(i).Interface())
}
return m
}
// JsonToMapString 将json结构体转换成map
func JsonToMapString(in interface{}) map[string]string {
m := make(map[string]interface{})
j, _ := json.Marshal(in)
var s string
decoder := json.NewDecoder(strings.NewReader(string(j)))
decoder.UseNumber()
decoder.Decode(&m)
//json.Unmarshal(j, &m)
ret := make(map[string]string)
for k, v := range m {
s = fmt.Sprintf("%v", v)
if s == "" {
continue
}
ret[k] = s
}
return ret
}
pkg/util/jwt.go 0 → 100644
View file @ d04eb576
package util
import (
"slg/pkg/setting"
"github.com/dgrijalva/jwt-go"
"time"
)
var jwtSecret []byte
type Claims struct {
UserInfo UserInfo `json:"user"`
jwt.StandardClaims
}
type UserInfo struct {
Uid int `json:"uid"`
Username string `json:"username"`
}
func GenerateToken(username, password string) (string, error) {
//nowTime := time.Now()
//expireTime := nowTime.Add(3 * time.Hour)
expiresTime := time.Now().Unix() + int64(60*60*24)
claims := jwt.StandardClaims{
Audience: setting.AppSetting.Audience,
Issuer: setting.AppSetting.Issuer,
ExpiresAt: expiresTime,
IssuedAt: time.Now().Unix(),
NotBefore: time.Now().Unix(),
Subject: "login",
}
var jwtSecret = []byte(setting.AppSetting.JwtSecret)
tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
token, err := tokenClaims.SignedString(jwtSecret)
return token, err
}
func ParseToken(token string) (*Claims, error) {
tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
return jwtSecret, nil
})
if tokenClaims != nil {
if claims, ok := tokenClaims.Claims.(*Claims); ok && tokenClaims.Valid {
return claims, nil
}
}
return nil, err
}
pkg/util/md5.go 0 → 100644
View file @ d04eb576
package util
import (
"crypto/md5"
"encoding/hex"
)
func EncodeMD5(value string) string{
m:= md5.New()
m.Write([]byte(value))
return hex.EncodeToString(m.Sum(nil))
}
\ No newline at end of file
pkg/util/pagination.go 0 → 100644
View file @ d04eb576
package util
import (
"github.com/gin-gonic/gin"
"slg/pkg/setting"
)
// GetPage get page parameters
func GetPage(c *gin.Context) int {
result := 0
page := ToInt(c.DefaultQuery("page", "1"))
size := ToInt(c.DefaultQuery("size", "0"))
if size == 0 {
size = setting.AppSetting.PageSize
}
if page > 0 {
result = (page - 1) * size
}
return result
}
// GetLimit get page parameters
func GetLimit(c *gin.Context) int {
result := setting.AppSetting.PageSize
size := ToInt(c.DefaultQuery("size", "0"))
if size > 0 {
result = size
}
return result
}
pkg/util/time.go 0 → 100644
View file @ d04eb576
package util
import "time"
func GetCurrentDate() string {
return time.Now().Format("2006/01/02 15:04:05")
}
func GetCurrentUnix() int64 {
return time.Now().Unix()
}
func GetCurrentMilliUnix() int64 {
return time.Now().UnixNano() / 1000000
}
func GetCurrentNanoUnix() int64 {
return time.Now().UnixNano()
}
func FormatUnix(time_tmp int64) string {
return time.Unix(time_tmp, 0).Format("2006-01-02 15:04:05")
}
pkg/util/util.go 0 → 100644
View file @ d04eb576
package util
import (
"crypto/md5"
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"math"
"net"
"reflect"
"slg/pkg/setting"
"strconv"
)
// Setup Initialize the util
func Setup() {
jwtSecret = []byte(setting.AppSetting.JwtSecret)
}
// IPString2Long 把ip字符串转为数值
func IPString2Long(ip string) (uint, error) {
b := net.ParseIP(ip).To4()
if b == nil {
return 0, errors.New("invalid ipv4 format")
}
return uint(b[3]) | uint(b[2])<<8 | uint(b[1])<<16 | uint(b[0])<<24, nil
}
// Long2IPString 把数值转为ip字符串
func Long2IPString(i uint) (string, error) {
if i > math.MaxUint32 {
return "", errors.New("beyond the scope of ipv4")
}
ip := make(net.IP, net.IPv4len)
ip[0] = byte(i >> 24)
ip[1] = byte(i >> 16)
ip[2] = byte(i >> 8)
ip[3] = byte(i)
return ip.String(), nil
}
func Serialization(value interface{}) ([]byte, error) {
if bytes, ok := value.([]byte); ok {
return bytes, nil
}
switch v := reflect.ValueOf(value); v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return []byte(strconv.FormatInt(v.Int(), 10)), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return []byte(strconv.FormatUint(v.Uint(), 10)), nil
case reflect.Map:
}
k, err := json.Marshal(value)
return k, err
}
func Deserialization(byt []byte, ptr interface{}) (err error) {
if bytes, ok := ptr.(*[]byte); ok {
*bytes = byt
return
}
if v := reflect.ValueOf(ptr); v.Kind() == reflect.Ptr {
switch p := v.Elem(); p.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var i int64
i, err = strconv.ParseInt(string(byt), 10, 64)
if err != nil {
fmt.Printf("Deserialization: failed to parse int '%s': %s", string(byt), err)
} else {
p.SetInt(i)
}
return
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
var i uint64
i, err = strconv.ParseUint(string(byt), 10, 64)
if err != nil {
fmt.Printf("Deserialization: failed to parse uint '%s': %s", string(byt), err)
} else {
p.SetUint(i)
}
return
}
}
err = json.Unmarshal(byt, &ptr)
return
}
func StringToMd5(str string) string {
m5 := md5.New()
_, err := m5.Write([]byte(str))
if err != nil {
panic(err)
}
md5String := hex.EncodeToString(m5.Sum(nil))
return md5String
}
func Contains(slice []string, val string) (int, bool) {
for i, item := range slice {
if item == val {
return i, true
}
}
return -1, false
}
func FormatFloat(num float64, decimal int) string {
// 默认乘1
d := float64(1)
if decimal > 0 {
// 10的N次方
d = math.Pow10(decimal)
}
// math.trunc作用就是返回浮点数的整数部分
// 再除回去，小数点后无效的0也就不存在了
return strconv.FormatFloat(math.Trunc(num*d)/d, 'f', -1, 64)
}
func Float64FromBytes(bytes []byte) float64 {
bits := binary.LittleEndian.Uint64(bytes)
float := math.Float64frombits(bits)
return float
}
func Float64Bytes(float float64) []byte {
bits := math.Float64bits(float)
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, bits)
return bytes
}
routers/api/h5/bank.go 0 → 100644
View file @ d04eb576
package h5
import (
"github.com/gin-gonic/gin"
"slg/pkg/errno"
"slg/pkg/handler"
"slg/service/bank_service"
"slg/validate_service"
"strings"
)
func GetBank(c *gin.Context) {
handler.SendResponse(c, nil, nil)
}
func AddBank(c *gin.Context) {
bank := validate_service.Bank{}
c.ShouldBindJSON(&bank)
if ok, errors := validate_service.ValidateInputs(bank); !ok {
for _, err := range errors {
handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
return
}
}
bank_service := bank_service.Bank{
BankName: bank.BankName,
}
if err := bank_service.Add(); err != nil {
handler.SendResponse(c, errno.ErrAddBank, nil)
return
}
handler.SendResponse(c, nil, nil)
}
func UpdateBank(c *gin.Context) {
handler.SendResponse(c, nil, nil)
}
func DeleteBank(c *gin.Context) {
handler.SendResponse(c, nil, nil)
}
\ No newline at end of file
routers/router.go 0 → 100644
View file @ d04eb576
package routers
import (
"github.com/gin-gonic/gin"
"slg/middleware/jwt"
"slg/routers/api/h5"
)
func InitRouter() *gin.Engine {
r := gin.New()
r.Use(gin.Logger())
r.Use(gin.Recovery())
client := r.Group("/h5")
client.GET("/banks", h5.GetBank)
client.POST("/add-bank", h5.AddBank)
client.PUT("/update-bank", h5.UpdateBank)
client.DELETE("/delete-bank", h5.DeleteBank)
api := r.Group("/api")
api.Use(jwt.JWT())
{
}
return r
}
service/bank_service/bank.go 0 → 100644
View file @ d04eb576
package bank_service
import "slg/models"
type Bank struct {
BankName string
}
func (b *Bank) Add() error {
bank := map[string]interface{}{
"bankname": b.BankName,
}
if err := models.AddBank(bank); err != nil {
return err
}
return nil
}
\ No newline at end of file
validate_service/bank.go 0 → 100644
View file @ d04eb576
package validate_service
type Bank struct {
BankName string `json:"name" validate:"required"`
}
validate_service/validate.go 0 → 100644
View file @ d04eb576
package validate_service
import (
"gopkg.in/go-playground/validator.v9"
"reflect"
"strings"
)
func ValidateInputs(dataSet interface{}) (bool, map[string][]string) {
validate := validator.New()
err := validate.Struct(dataSet)
if err != nil {
//Validation syntax is invalid
if err, ok := err.(*validator.InvalidValidationError); ok {
panic(err)
}
//Validation errors occurred
errors := make(map[string][]string)
//Use reflector to reverse engineer struct
reflected := reflect.ValueOf(dataSet)
for _, err := range err.(validator.ValidationErrors) {
// Attempt to find field by name and get json tag name
field, _ := reflected.Type().FieldByName(err.StructField())
var name string
//If json tag doesn't exist, use lower case of name
if name = field.Tag.Get("json"); name == "" {
name = strings.ToLower(err.StructField())
}
switch err.Tag() {
case "required":
errors[name] = append(errors[name], "The "+name+" is required")
break
case "email":
errors[name] = append(errors[name], "The "+name+" should be a valid email")
break
case "url":
errors[name] = append(errors[name], "The "+name+" should be a valid url")
break
case "eqfield":
errors[name] = append(errors[name], "The "+name+" should be equal to the "+err.Param())
break
default:
errors[name] = append(errors[name], "The "+name+" is invalid")
break
}
}
return false, errors
}
return true, nil
}
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