add golang sdk

sdk/api/channel.go

@@ -0,0 +1,186 @@
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type Channel struct {
+	ID                 int           `json:"id"`
+	Type               int           `json:"type"`
+	Key                string        `json:"key"`
+	Status             int           `json:"status"`
+	Name               string        `json:"name"`
+	Weight             int           `json:"weight"`
+	CreatedTime        int           `json:"created_time"`
+	TestTime           int           `json:"test_time"`
+	ResponseTime       int           `json:"response_time"`
+	BaseUrl            string        `json:"base_url"`
+	Other              string        `json:"other"`
+	Balance            int           `json:"balance"`
+	BalanceUpdatedTime int           `json:"balance_updated_time"`
+	Models             string        `json:"models"`
+	Group              string        `json:"group"`
+	UsedQuota          int           `json:"used_quota"`
+	ModelMapping       string        `json:"model_mapping"`
+	Priority           int           `json:"priority"`
+	Config             string        `json:"config"`
+	SystemPrompt       string        `json:"system_prompt"`
+	ChannelConfig      ChannelConfig `json:"channel_confi"`
+}
+
+type ChannelConfig struct {
+	Region            string `json:"region"`
+	Sk                string `json:"sk"`
+	Ak                string `json:"ak"`
+	UserId            string `json:"user_id"`
+	VertexAiProjectId string `json:"vertex_ai_project_id"`
+	VertexAiAdc       string `json:"vertex_ai_adc"`
+}
+type NewChannel struct {
+	BaseUrl      string   `json:"base_url"`
+	Config       string   `json:"config"`
+	Group        string   `json:"group"`
+	Groups       []string `json:"groups"`
+	Key          string   `json:"key"`
+	ModelMapping string   `json:"model_mapping"`
+	Models       string   `json:"models"`
+	Name         string   `json:"name"`
+	Other        string   `json:"other"`
+	SystemPrompt string   `json:"system_prompt"`
+	Type         int      `json:"type"`
+}
+
+type Channels struct {
+	Channels []*Channel
+	Query    map[string]string
+}
+
+type ChannelRespData struct {
+	Data    interface{} `json:"data"`
+	Message string      `json:"message"`
+	Success bool        `json:"success"`
+}
+
+type ChannelResp struct {
+	Message   string  `json:"message"`
+	ModelName string  `json:"modelName"`
+	Success   bool    `json:"success"`
+	Time      float64 `json:"time"`
+}
+
+type ChannelImpl interface {
+	Add(channel *Channel) error
+	Get(id int) error
+	Update(channel *Channel) error
+	Delete(id int) error
+	Test() error
+}
+
+// list channel
+func (channels *Channels) List(client *OneClient) error {
+	if channels.Query != nil {
+		client.Url = "/api/channel/search?"
+		for k, v := range channels.Query {
+			client.Url += k + "=" + v + "&"
+		}
+		client.Url += "p=0&order="
+	} else {
+		client.Url = "/api/channel/?p=0&order="
+	}
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := ChannelRespData{Data: []*Channel{}, Message: "", Success: false}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	for _, v := range data.Data.([]interface{}) {
+		channel := &Channel{}
+		channelData, _ := json.Marshal(v)
+		err = json.Unmarshal(channelData, channel)
+		if err != nil {
+			return err
+		}
+		channels.Channels = append(channels.Channels, channel)
+	}
+	return nil
+}
+
+// add channel
+func (channel *Channel) Add(client *OneClient) error {
+	client.Url = "/api/channel/"
+	channelConfigData, err := json.Marshal(channel.ChannelConfig)
+	newChannel := NewChannel{
+		BaseUrl:      channel.BaseUrl,
+		Config:       string(channelConfigData),
+		Group:        channel.Group,
+		Groups:       []string{channel.Group},
+		Key:          channel.Key,
+		ModelMapping: channel.ModelMapping,
+		Models:       channel.Models,
+		Name:         channel.Name,
+		Other:        channel.Other,
+		SystemPrompt: channel.SystemPrompt,
+		Type:         channel.Type,
+	}
+	data, err := json.Marshal(newChannel)
+	if err != nil {
+		return err
+	}
+	return client.post(data)
+}
+
+// update channel
+func (channel *Channel) Update(client *OneClient) error {
+	client.Url = "/api/channel/"
+	data, err := json.Marshal(channel)
+	if err != nil {
+		return err
+	}
+	return client.put(data)
+}
+
+// delete channel
+func (channel *Channel) Delete(client *OneClient) error {
+	client.Url = "/api/channel/" + fmt.Sprintf("%d", channel.ID)
+	return client.delete(nil)
+}
+
+// get channel
+func (channel *Channel) Get(client *OneClient) error {
+	client.Url = "/api/channel/" + fmt.Sprintf("%d", channel.ID) + "/"
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := ChannelRespData{Data: channel, Message: "", Success: false}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	channel = data.Data.(*Channel)
+	return nil
+}
+
+// test channel
+func (channel *Channel) Test(client *OneClient) error {
+	client.Url = "/api/channel/test/" + fmt.Sprintf("%d", channel.ID) + "/?model=" + strings.Split(channel.Models, ",")[0]
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := ChannelResp{Message: "", ModelName: "", Success: false, Time: 0}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	if data.Success {
+		return nil
+	} else {
+		return fmt.Errorf("test channel failed: %s", data.Message)
+	}
+}

sdk/api/client.go

@@ -0,0 +1,116 @@
+package sdk
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+)
+
+type Config struct {
+	Host string `json:"host"`
+	Port int    `json:"port"`
+	Key  string `json:"key"`
+}
+
+type OneClient struct {
+	Client *http.Client
+	Config *Config
+	Url    string
+}
+
+type RespMessage struct {
+	Message string `json:"message"`
+	Success bool   `json:"success"`
+}
+
+// get
+func (OneClient *OneClient) get() (*http.Response, error) {
+	OneClient.Client = &http.Client{}
+	port := strconv.Itoa(OneClient.Config.Port)
+	url := OneClient.Config.Host + ":" + port + OneClient.Url
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+OneClient.Config.Key)
+	resp, err := OneClient.Client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// post
+func (OneClient *OneClient) post(data []byte) error {
+	OneClient.Client = &http.Client{}
+	port := strconv.Itoa(OneClient.Config.Port)
+	url := OneClient.Config.Host + ":" + port + OneClient.Url
+	payload := bytes.NewBuffer(data)
+	req, err := http.NewRequest("POST", url, payload)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+OneClient.Config.Key)
+	resp, err := OneClient.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	message := RespMessage{}
+	if err := json.NewDecoder(resp.Body).Decode(&message); err != nil {
+		return err
+	}
+	if message.Success {
+		return nil
+	}
+	return fmt.Errorf("create user failed: %s", message.Message)
+}
+
+// put
+func (OneClient *OneClient) put(data []byte) error {
+	OneClient.Client = &http.Client{}
+	port := strconv.Itoa(OneClient.Config.Port)
+	url := OneClient.Config.Host + ":" + port + OneClient.Url
+	payload := bytes.NewBuffer(data)
+	req, err := http.NewRequest("PUT", url, payload)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+OneClient.Config.Key)
+	resp, err := OneClient.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	message := RespMessage{}
+	if err := json.NewDecoder(resp.Body).Decode(&message); err != nil {
+		return err
+	}
+	if message.Success {
+		return nil
+	}
+	return fmt.Errorf("update user failed: %s", message.Message)
+}
+
+// delete
+func (OneClient *OneClient) delete(data []byte) error {
+	OneClient.Client = &http.Client{}
+	port := strconv.Itoa(OneClient.Config.Port)
+	url := OneClient.Config.Host + ":" + port + OneClient.Url
+	payload := bytes.NewBuffer(data)
+	req, err := http.NewRequest("DELETE", url, payload)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+OneClient.Config.Key)
+	resp, err := OneClient.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	message := RespMessage{}
+	if err := json.NewDecoder(resp.Body).Decode(&message); err != nil {
+		return err
+	}
+	if message.Success {
+		return nil
+	}
+	return fmt.Errorf("delete user failed: %s", message.Message)
+}

sdk/api/log.go

@@ -0,0 +1,91 @@
+package sdk
+
+import (
+	"encoding/json"
+	"time"
+)
+
+// get log url like http://172.18.2.63:8300/api/log/?p=0&type=0&username=&token_name=&model_name=&start_timestamp=0&end_timestamp=1745237472&channel=
+// define log struct :{
+//            "id": 349,
+//            "user_id": 21,
+//            "created_at": 1745206602,
+//            "type": 3,
+//            "content": "管理员将用户额度从 ＄0.000000 额度修改为 ＄1000.000000 额度",
+//            "username": "test1",
+//            "token_name": "",
+//            "model_name": "",
+//            "quota": 0,
+//            "prompt_tokens": 0,
+//            "completion_tokens": 0,
+//            "channel": 0,
+//            "request_id": "2025042111364245599153931550114",
+//            "elapsed_time": 0,
+//            "is_stream": false,
+//            "system_prompt_reset": false
+//        },
+
+type Log struct {
+	ID                int    `json:"id"`
+	UserID            int    `json:"user_id"`
+	CreatedAt         int    `json:"created_at"`
+	Type              int    `json:"type"`
+	Content           string `json:"content"`
+	Username          string `json:"username"`
+	TokenName         string `json:"token_name"`
+	ModelName         string `json:"model_name"`
+	Quota             int    `json:"quota"`
+	PromptTokens      int    `json:"prompt_tokens"`
+	CompletionTokens  int    `json:"completion_tokens"`
+	Channel           int    `json:"channel"`
+	RequestID         string `json:"request_id"`
+	ElapsedTime       int    `json:"elapsed_time"`
+	IsStream          bool   `json:"is_stream"`
+	SystemPromptReset bool   `json:"system_prompt_reset"`
+}
+
+type Logs struct {
+	Logs  []*Log
+	Query map[string]string
+}
+
+type Logsimpl interface {
+	Get(client *OneClient) error
+}
+
+type LogRespData struct {
+	Data    interface{} `json:"data"`
+	Message string      `json:"message"`
+	Success bool        `json:"success"`
+}
+
+// get log
+func (logs *Logs) Get(client *OneClient) error {
+	client.Url = "/api/log/?"
+	if logs.Query != nil {
+		for k, v := range logs.Query {
+			client.Url += k + "=" + v + "&"
+		}
+	} else {
+		client.Url = "/api/log/?p=0&type=0&username=&token_name=&model_name=&start_timestamp=0&end_timestamp=" + time.Now().String() + "&channel="
+	}
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := LogRespData{Data: []*Log{}, Message: "", Success: false}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	for _, v := range data.Data.([]interface{}) {
+		log := &Log{}
+		logData, _ := json.Marshal(v)
+		err = json.Unmarshal(logData, log)
+		if err != nil {
+			return err
+		}
+		logs.Logs = append(logs.Logs, log)
+	}
+	return nil
+}

sdk/api/token.go

@@ -0,0 +1,131 @@
+package sdk
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+type Token struct {
+	ID             int    `json:"id"`
+	UserID         int    `json:"user_id"`
+	Key            string `json:"key"`
+	Status         int    `json:"status"`
+	Name           string `json:"name"`
+	CreatedTime    int    `json:"created_time"`
+	AccessedTime   int    `json:"accessed_time"`
+	ExpiredTime    int    `json:"expired_time"`
+	RemainQuota    int    `json:"remain_quota"`
+	UnlimitedQuota bool   `json:"unlimited_quota"`
+	UsedQuota      int    `json:"used_quota"`
+	Models         string `json:"models"`
+	Subnet         string `json:"subnet"`
+}
+
+// define add token function
+type Tokenimpl interface {
+	Add(token *Token) error
+	List(id int) error
+	Update(token *Token) error
+	Delete(id int) error
+}
+
+type Tokens struct {
+	Tokens []*Token
+	UserID int
+	Query  map[string]string
+}
+
+type TokensImpl interface {
+	List(token *Token) error
+}
+
+type TokenRespData struct {
+	Data interface{} `json:"data"`
+}
+
+// add token
+func (token *Token) Add(client *OneClient) error {
+	client.Url = "/api/token/"
+	data, err := json.Marshal(token)
+	if err != nil {
+		return err
+	}
+	return client.post(data)
+}
+
+// update token
+func (token *Token) Update(client *OneClient) error {
+	client.Url = "/api/token/"
+	data, err := json.Marshal(token)
+	if err != nil {
+		return err
+	}
+	return client.put(data)
+}
+
+// list token
+func (tokens *Tokens) List(client *OneClient) error {
+	if tokens.UserID != 0 {
+		if tokens.Query != nil {
+			client.Url = "/api/token/search?user_id=" + strconv.Itoa(tokens.UserID)
+			for k, v := range tokens.Query {
+				client.Url += "&" + k + "=" + v
+			}
+			client.Url += "&p=0&order="
+		} else {
+			client.Url = "/api/token/?user_id=" + strconv.Itoa(tokens.UserID) + "&p=0&order="
+		}
+	} else {
+		if tokens.Query != nil {
+			client.Url = "/api/token/search?p=0"
+			for k, v := range tokens.Query {
+				client.Url += "&" + k + "=" + v
+			}
+		} else {
+			client.Url = "/api/token/?p=0"
+		}
+		client.Url += "&order="
+	}
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := TokenRespData{Data: []*Token{}}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	for _, v := range data.Data.([]interface{}) {
+		token := &Token{}
+		tokenData, _ := json.Marshal(v)
+		err = json.Unmarshal(tokenData, token)
+		if err != nil {
+			return err
+		}
+		tokens.Tokens = append(tokens.Tokens, token)
+	}
+	return nil
+}
+
+// delete token
+func (token *Token) Delete(client *OneClient) error {
+	client.Url = "/api/token/" + strconv.Itoa(token.ID) + "/" + "?user_id=" + strconv.Itoa(token.UserID)
+	return client.delete(nil)
+}
+
+// get token
+func (token *Token) Get(client *OneClient) error {
+	client.Url = "/api/token/" + strconv.Itoa(token.ID) + "/" + "?user_id=" + strconv.Itoa(token.UserID)
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := TokenRespData{Data: token}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	tokenData, _ := json.Marshal(data.Data)
+	err = json.Unmarshal(tokenData, token)
+	return nil
+}

sdk/api/user.go

@@ -0,0 +1,134 @@
+// 6ca91f95d29749db8a93d5b8903c7949
+
+// description: User API
+// use httprequest to get user list	and user info
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type User struct {
+	ID               int    `json:"id"`
+	Username         string `json:"username"`
+	Password         string `json:"password"`
+	DisplayName      string `json:"display_name"`
+	Role             int    `json:"role"`
+	Status           int    `json:"status"`
+	Email            string `json:"email"`
+	GithubID         string `json:"github_id"`
+	WechatID         string `json:"wechat_id"`
+	LarkID           string `json:"lark_id"`
+	OidcID           string `json:"oidc_id"`
+	VerificationCode string `json:"verification_code"`
+	AccessToken      string `json:"access_token"`
+	Quota            int    `json:"quota"`
+	UsedQuota        int    `json:"used_quota"`
+	RequestCount     int    `json:"request_count"`
+	Group            string `json:"group"`
+	AffCode          string `json:"aff_code"`
+	InviterID        int    `json:"inviter_id"`
+}
+
+type UserRespData struct {
+	Data interface{} `json:"data"`
+}
+
+type UserImpl interface {
+	Add(user *User) error
+	Get(id int) error
+	Updater(user *User) error
+	Delete(id int) error
+}
+
+type Users struct {
+	Users []*User
+	Query map[string]string
+}
+
+// list user
+func (users *Users) List(client *OneClient) error {
+	if users.Query != nil {
+		client.Url = "/api/user/search?"
+		for k, v := range users.Query {
+			client.Url += k + "=" + v + "&"
+		}
+		client.Url += "p=0&order="
+	} else {
+		client.Url = "/api/user/?p=0&order="
+	}
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := UserRespData{Data: []*User{}}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	for _, v := range data.Data.([]interface{}) {
+		user := &User{}
+		userData, _ := json.Marshal(v)
+		err = json.Unmarshal(userData, user)
+		if err != nil {
+			return err
+		}
+		users.Users = append(users.Users, user)
+	}
+	return nil
+}
+
+// add user
+func (user *User) Add(client *OneClient) error {
+	client.Url = "/api/user/"
+	data, err := json.Marshal(user)
+	if err != nil {
+		return err
+	}
+	return client.post(data)
+}
+
+// delete user
+func (user *User) Delete(client *OneClient) error {
+	client.Url = "/api/user/manage"
+	deleteData := map[string]interface{}{
+		"username": user.Username,
+		"action":   "delete",
+	}
+	data, err := json.Marshal(deleteData)
+	if err != nil {
+		return err
+	}
+	return client.post(data)
+}
+
+// update user
+func (user *User) Update(client *OneClient) error {
+	client.Url = "/api/user"
+	data, err := json.Marshal(user)
+	if err != nil {
+		return err
+	}
+	return client.put(data)
+}
+
+// get user
+func (user *User) Get(client *OneClient) error {
+	client.Url = "/api/user/" + fmt.Sprintf("%d", user.ID)
+	resp, err := client.get()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data := UserRespData{Data: user}
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return err
+	}
+	userData, _ := json.Marshal(data.Data)
+	err = json.Unmarshal(userData, user)
+	if err != nil {
+		return err
+	}
+	return nil
+}