tangping/goProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Apply .gitignore rules

Browse Source
This commit is contained in:
皮蛋13361098506
2025-01-06 16:21:36 +08:00
parent 1b77f62820
commit ccd2c530cf
580 changed files with 69806 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
.svn/pristine/77/77392d5c171ac5c4b573ca5862f14d15b0b6e1dd.svn-base Normal file
View File

@@ -0,0 +1,196 @@
package user
import (
"common/remark"
"common/resultStatus"
"common/webServer"
"goutil/intUtil"
"goutil/securityUtil"
"strconv"
"time"
)
func init() {
//注册接口
webServer.RegisterFunction(new(UserApi))
}
func init() {
moduleName := "UserApi"
desc := "用户接口"
author := "tangping"
mendor := ""
date := "2024-12-25"
remark.RegisterModuleRemark(moduleName, desc, author, mendor, date)
}
// UserApi 用户接口
type UserApi struct {
}
// ---------------------------------------- 接口 --------------------------------------------------
func init() {
moduleName := "UserApi"
methodName := "Register"
methodDesc := "注册用户"
methodAuthor := "tangping"
methodMendor := ""
methodDate := "2024-12-25 15:55:00"
methodInParam := []string{"string 账号,string:用户名称,string:用户密码,string:用户性别,string:用户生日,int64:用户手机号,string:用户邮箱,string:用户微信群,string:用户备注"}
methodOutParam := `
{
"Code '类型:int'": "响应结果的状态值",
"Message '类型:string'": "响应结果的状态值所对应的描述信息",
"Data '类型:interface{}'": "响应结果的数据"
{
"id '类型:int'": "用户id",
}
}`
remark.RegisterMethodRemark(moduleName, methodName, methodDesc, methodAuthor, methodMendor, methodDate, methodInParam, methodOutParam)
}
func (a *UserApi) Register(account string, name string, password string, sex int32, birthday string, phone int64, email string, wechatGroup string, describe string) (responseObj *webServer.ResponseObject) {
responseObj = webServer.GetInitResponseObj()
//校验参数
if account == "" || name == "" || password == "" || sex == 0 || birthday == "" || phone == 0 || email == "" || wechatGroup == "" {
responseObj.SetResultStatus(resultStatus.APIDataError)
return
}
//密码md5加密
password = securityUtil.Md5String(password, true)
//处理数据
UserModel := &User{
Account: account,
Name: name,
Password: password,
Sex: sex,
Birthday: birthday,
Phone: phone,
Email: email,
Describe: describe,
}
//添加到数据库
AddUser(UserModel)
resultMap := make(map[string]any)
resultMap["id"] = UserModel.ID
responseObj.SetData(resultMap)
return
}
func init() {
moduleName := "UserApi"
methodName := "Get"
methodDesc := "获取用户用户"
methodAuthor := "tangping"
methodMendor := ""
methodDate := "2024-12-25 15:55:00"
methodInParam := []string{"int64:用户id"}
methodOutParam := `
{
"Code '类型:int'": "响应结果的状态值",
"Message '类型:string'": "响应结果的状态值所对应的描述信息",
"Data '类型:interface{}'": "响应结果的数据"
{
"account '类型:string'": "用户账号",
"name '类型:string'": "用户名称",
"sex '类型:int32'": "用户性别",
"birthday '类型:string'": "用户生日",
"phone '类型:int64'": "用户手机号",
"email '类型:string'": "用户邮箱",
"wechatGroup '类型:string'": "用户微信群",
"describe '类型:string'": "用户备注",
}
}`
remark.RegisterMethodRemark(moduleName, methodName, methodDesc, methodAuthor, methodMendor, methodDate, methodInParam, methodOutParam)
}
func (a *UserApi) Get(UserId int64) (responseObj *webServer.ResponseObject) {
responseObj = webServer.GetInitResponseObj()
//验证参数
if UserId == 0 {
responseObj.SetResultStatus(resultStatus.APIDataError)
return
}
UserData, err := GetUserByID(UserId)
if err != nil {
responseObj.SetResultStatus(resultStatus.DataError)
return
}
//UserData映射成map
resultMap := make(map[string]any)
resultMap["account"] = UserData.Account
resultMap["name"] = UserData.Name
resultMap["sex"] = UserData.Sex
resultMap["birthday"] = UserData.Birthday
resultMap["phone"] = UserData.Phone
resultMap["email"] = UserData.Email
resultMap["describe"] = UserData.Describe
responseObj.SetData(resultMap)
return
}
// 用户登录
func init() {
moduleName := "UserApi"
methodName := "Login"
methodDesc := "用户登录"
methodAuthor := "tangping"
methodMendor := ""
methodDate := "2024-12-26 15:55:00"
methodInParam := []string{"string:账号,string:密码"}
methodOutParam := `
{
"Code '类型:int'": "响应结果的状态值",
"Message '类型:string'": "响应结果的状态值所对应的描述信息",
"Data '类型:interface{}'": "响应结果的数据"
{
"Token '类型:string'": "登录令牌",
}
}`
remark.RegisterMethodRemark(moduleName, methodName, methodDesc, methodAuthor, methodMendor, methodDate, methodInParam, methodOutParam)
}
func (a *UserApi) Login(account string, password string) (responseObj *webServer.ResponseObject) {
responseObj = webServer.GetInitResponseObj()
//验证参数
if account == "" || password == "" {
responseObj.SetResultStatus(resultStatus.APIDataError)
return
}
UserData, err := Login(account, securityUtil.Md5String(password, true))
if err != nil {
responseObj.SetResultStatus(resultStatus.DataError)
return
}
//生成一个随机token
token, err := intUtil.ShuffleIntDigits(time.Now().UnixNano())
if err != nil {
responseObj.SetResultStatus(resultStatus.DataError)
return
}
//添加登录用户
webServer.AddLoginUserToken(token, &webServer.TokenInfo{Id: UserData.ID, Account: account})
//UserData映射成map
resultMap := make(map[string]any)
resultMap["Token"] = strconv.FormatInt(token, 10)
responseObj.SetData(resultMap)
return
}

265
.svn/pristine/77/77d350f9739d0187dc080c10c4a278eb975a9edd.svn-base Normal file
View File

@@ -0,0 +1,265 @@
package app_environment
import (
"encoding/json"
"fmt"
"testing"
)
func Test_Set(t *testing.T) {
var err error
err = Set("a", "a")
if err != nil {
t.Error(err)
}
err = Set("b", "b")
if err != nil {
t.Error(err)
}
err = Set("c", "1")
if err != nil {
t.Error(err)
}
err = Set("d", "2")
if err != nil {
t.Error(err)
}
err = Set("e", "true")
if err != nil {
t.Error(err)
}
err = Set("a", "a")
if err == nil {
t.Error("Set覆盖存在问题")
}
tm := &tempkv{
Name: "byron",
}
str, _ := json.Marshal(tm)
Set("str", string(str))
kvmap := make(map[string]string)
kvmap["a_1"] = "aaa"
err = SetMap(kvmap)
if err != nil {
t.Error(err)
}
err = SetMap(kvmap)
if err == nil {
t.Error("SetMap覆盖存在问题")
}
kvmap = make(map[string]string)
kvmap["b_aa"] = "b_aa"
SetForCoverMap(kvmap)
SetForCoverMap(kvmap)
SetForCover("a", "a")
}
func Test_Get(t *testing.T) {
m := GetAll()
if len(m) != 8 {
t.Error(fmt.Sprintf("getall错误 m=%v", len(m)))
}
v, isok := Get("a")
if isok == false {
t.Error("未获取到a")
}
if v != "a" {
t.Error("get值错误")
}
var i int
var err error
i, isok, err = GetInt("c")
if err != nil {
t.Error("GetInt 出错 err:", err)
}
if isok == false {
t.Error("GetInt 获取失败")
}
if i != 1 {
t.Error("GetInt值失败")
}
var i32 int32
i32, isok, err = GetInt32("c")
if err != nil {
t.Error("GetInt 出错 err:", err)
}
if isok == false {
t.Error("GetInt 获取失败")
}
if i32 != 1 {
t.Error("GetInt值失败")
}
var i64 int64
i64, isok, err = GetInt64("d")
if err != nil {
t.Error("GetInt64 出错 err:", err)
}
if isok == false {
t.Error("GetInt64 获取失败")
}
if i64 != 2 {
t.Error("GetInt64 值失败")
}
var b bool
b, isok, err = GetBool("e")
if err != nil {
t.Error("GetBool 出错 err:", err)
}
if isok == false {
t.Error("GetBool 获取失败")
}
if b == false {
t.Error("GetBool 值失败")
}
tm := &tempkv{}
isok, err = GetModel("str", tm)
if err != nil {
t.Error("GetModel 出错 err:", err)
}
if isok == false {
t.Error("GetModel 获取失败")
}
if tm.Name != "byron" {
t.Error("GetModel 值失败")
}
}
func Test_GetOrDefault(t *testing.T) {
v := GetOrDefault("notExists", "default")
if v != "default" {
t.Error("GetOrDefault 返回默认值不正确")
}
Set("stringTest", "ok")
v = GetOrDefault("stringTest", "default")
if v != "ok" {
t.Error("GetOrDefault 返回值不正确")
}
i, err := GetIntOrDefault("notExists", -99)
if err != nil {
t.Error(err)
}
if i != -99 {
t.Error("GetIntOrDefault 返回默认值不正确")
}
Set("intTest", "99")
i, err = GetIntOrDefault("intTest", -99)
if err != nil {
t.Error(err)
}
if i != 99 {
t.Error("GetIntOrDefault 返回值不正确")
}
Set("intTestError", "a99")
i, err = GetIntOrDefault("intTestError", -99)
if err == nil {
t.Error("GetIntOrDefault 解析时错误未抛出")
}
i32, err := GetInt32OrDefault("notExists", -99)
if err != nil {
t.Error(err)
}
if i32 != -99 {
t.Error("GetInt32OrDefault 返回默认值不正确")
}
Set("int32Test", "99")
i32, err = GetInt32OrDefault("int32Test", -99)
if err != nil {
t.Error(err)
}
if i32 != 99 {
t.Error("GetInt32OrDefault 返回值不正确")
}
Set("int32TestError", "a99")
i32, err = GetInt32OrDefault("int32TestError", -99)
if err == nil {
t.Error("GetInt32OrDefault 解析时错误未抛出")
}
i64, err := GetInt64OrDefault("notExists", -99)
if err != nil {
t.Error(err)
}
if i64 != -99 {
t.Error("GetInt64OrDefault 返回默认值不正确")
}
Set("int64Test", "99")
i64, err = GetInt64OrDefault("int64Test", -99)
if err != nil {
t.Error(err)
}
if i64 != 99 {
t.Error("GetInt64OrDefault 返回值不正确")
}
Set("int64TestError", "a99")
i64, err = GetInt64OrDefault("int64TestError", -99)
if err == nil {
t.Error("GetInt64OrDefault 解析时错误未抛出")
}
b, err := GetBoolOrDefault("notExists", true)
if err != nil {
t.Error(err)
}
if !b {
t.Error("GetBoolOrDefault 返回默认值不正确")
}
Set("boolTest", "true")
b, err = GetBoolOrDefault("boolTest", false)
if err != nil {
t.Error(err)
}
if !b {
t.Error("GetBoolOrDefault 返回值不正确")
}
Set("boolTestError", "sss")
b, err = GetBoolOrDefault("boolTestError", true)
if err == nil {
t.Error("GetBoolOrDefault 解析时错误未抛出")
}
}
func Test_Reset(t *testing.T) {
if err := Reset(nil); err == nil {
t.Error("Reset nil参数错误未抛出")
}
m := make(map[string]string)
if err := Reset(m); err != nil {
t.Error("Reset 错误的抛出错误")
}
}
type tempkv struct {
Name string
}