init

client/authorization.go

@@ -0,0 +1,179 @@
+package client
+
+import (
+    "errors"
+    "fmt"
+    "time"
+)
+
+var ErrNotSupportedAuthorizationState = errors.New("not supported state")
+
+type AuthorizationStateHandler interface {
+    Handle(client *Client, state AuthorizationState) error
+}
+
+func Authorize(client *Client, authorizationStateHandler AuthorizationStateHandler) error {
+    for {
+        state, err := client.GetAuthorizationState()
+        if err != nil {
+            return err
+        }
+
+        err = authorizationStateHandler.Handle(client, state)
+        if err != nil {
+            return err
+        }
+
+        if state.AuthorizationStateType() == TypeAuthorizationStateReady {
+            // dirty hack for db flush after authorization
+            time.Sleep(1 * time.Second)
+            return nil
+        }
+    }
+}
+
+type clientAuthorizer struct {
+    TdlibParameters chan *TdlibParameters
+    PhoneNumber     chan string
+    Code            chan string
+    State           chan AuthorizationState
+}
+
+func ClientAuthorizer() *clientAuthorizer {
+    return &clientAuthorizer{
+        TdlibParameters: make(chan *TdlibParameters, 1),
+        PhoneNumber:     make(chan string, 1),
+        Code:            make(chan string, 1),
+        State:           make(chan AuthorizationState, 10),
+    }
+}
+
+func (stateHandler *clientAuthorizer) Handle(client *Client, state AuthorizationState) error {
+    stateHandler.State <- state
+
+    switch state.AuthorizationStateType() {
+    case TypeAuthorizationStateWaitTdlibParameters:
+        _, err := client.SetTdlibParameters(<-stateHandler.TdlibParameters)
+        return err
+
+    case TypeAuthorizationStateWaitEncryptionKey:
+        _, err := client.CheckDatabaseEncryptionKey(nil)
+        return err
+
+    case TypeAuthorizationStateWaitPhoneNumber:
+        _, err := client.SetAuthenticationPhoneNumber(<-stateHandler.PhoneNumber, false, false)
+        return err
+
+    case TypeAuthorizationStateWaitCode:
+        _, err := client.CheckAuthenticationCode(<-stateHandler.Code, "", "")
+        return err
+
+    case TypeAuthorizationStateWaitPassword:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateReady:
+        close(stateHandler.TdlibParameters)
+        close(stateHandler.PhoneNumber)
+        close(stateHandler.Code)
+        close(stateHandler.State)
+
+        return nil
+
+    case TypeAuthorizationStateLoggingOut:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateClosing:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateClosed:
+        return ErrNotSupportedAuthorizationState
+    }
+
+    return ErrNotSupportedAuthorizationState
+}
+
+func CliInteractor(clientAuthorizer *clientAuthorizer) {
+    for {
+        select {
+        case state := <-clientAuthorizer.State:
+            switch state.AuthorizationStateType() {
+            case TypeAuthorizationStateWaitPhoneNumber:
+                fmt.Println("Enter phone number: ")
+                var phoneNumber string
+                fmt.Scanln(&phoneNumber)
+
+                clientAuthorizer.PhoneNumber <- phoneNumber
+
+            case TypeAuthorizationStateWaitCode:
+                fmt.Println("Enter code: ")
+                var code string
+                fmt.Scanln(&code)
+
+                clientAuthorizer.Code <- code
+
+            case TypeAuthorizationStateReady:
+                return
+            }
+        }
+    }
+}
+
+type botAuthorizer struct {
+    TdlibParameters chan *TdlibParameters
+    Token           chan string
+    State           chan AuthorizationState
+}
+
+func BotAuthorizer(token string) *botAuthorizer {
+    botAuthorizer := &botAuthorizer{
+        TdlibParameters: make(chan *TdlibParameters, 1),
+        Token:           make(chan string, 1),
+        State:           make(chan AuthorizationState, 10),
+    }
+
+    botAuthorizer.Token <- token
+
+    return botAuthorizer
+}
+
+func (stateHandler *botAuthorizer) Handle(client *Client, state AuthorizationState) error {
+    stateHandler.State <- state
+
+    switch state.AuthorizationStateType() {
+    case TypeAuthorizationStateWaitTdlibParameters:
+        _, err := client.SetTdlibParameters(<-stateHandler.TdlibParameters)
+        return err
+
+    case TypeAuthorizationStateWaitEncryptionKey:
+        _, err := client.CheckDatabaseEncryptionKey(nil)
+        return err
+
+    case TypeAuthorizationStateWaitPhoneNumber:
+        _, err := client.CheckAuthenticationBotToken(<-stateHandler.Token)
+        return err
+
+    case TypeAuthorizationStateWaitCode:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateWaitPassword:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateReady:
+        close(stateHandler.TdlibParameters)
+        close(stateHandler.Token)
+        close(stateHandler.State)
+
+        return nil
+
+    case TypeAuthorizationStateLoggingOut:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateClosing:
+        return ErrNotSupportedAuthorizationState
+
+    case TypeAuthorizationStateClosed:
+        return ErrNotSupportedAuthorizationState
+    }
+
+    return ErrNotSupportedAuthorizationState
+}

client/client.go

@@ -0,0 +1,111 @@
+package client
+
+import (
+    "errors"
+    "sync"
+    "time"
+)
+
+type Client struct {
+    jsonClient     *JsonClient
+    extraGenerator ExtraGenerator
+    catcher        chan *Response
+    listeners      []chan Type
+    catchersStore  *sync.Map
+}
+
+type Option func(*Client)
+
+func WithExtraGenerator(extraGenerator ExtraGenerator) Option {
+    return func(client *Client) {
+        client.extraGenerator = extraGenerator
+    }
+}
+
+func WithListener(listener chan Type) Option {
+    return func(client *Client) {
+        client.listeners = append(client.listeners, listener)
+    }
+}
+
+func NewClient(authorizationStateHandler AuthorizationStateHandler, options ...Option) (*Client, error) {
+    catchersListener := make(chan *Response, 1000)
+
+    client := &Client{
+        jsonClient:    NewJsonClient(),
+        catcher:       catchersListener,
+        listeners:     []chan Type{},
+        catchersStore: &sync.Map{},
+    }
+
+    for _, option := range options {
+        option(client)
+    }
+
+    if client.extraGenerator == nil {
+        client.extraGenerator = UuidV4Generator()
+    }
+
+    go client.receive()
+    go client.catch(catchersListener)
+
+    err := Authorize(client, authorizationStateHandler)
+    if err != nil {
+        return nil, err
+    }
+
+    return client, nil
+}
+
+func (client *Client) receive() {
+    for {
+        resp, err := client.jsonClient.Receive(10)
+        if err != nil {
+            continue
+        }
+        client.catcher <- resp
+
+        typ, err := UnmarshalType(resp.Data)
+        if err != nil {
+            continue
+        }
+
+        for _, listener := range client.listeners {
+            listener <- typ
+        }
+    }
+}
+
+func (client *Client) catch(updates chan *Response) {
+    for update := range updates {
+        if update.Extra != "" {
+            value, ok := client.catchersStore.Load(update.Extra)
+            if ok {
+                value.(chan *Response) <- update
+            }
+        }
+    }
+}
+
+func (client *Client) Send(req Request) (*Response, error) {
+    req.Extra = client.extraGenerator()
+
+    catcher := make(chan *Response, 1)
+
+    client.catchersStore.Store(req.Extra, catcher)
+
+    defer func() {
+        close(catcher)
+        client.catchersStore.Delete(req.Extra)
+    }()
+
+    client.jsonClient.Send(req)
+
+    select {
+    case response := <-catcher:
+        return response, nil
+
+    case <-time.After(10 * time.Second):
+        return nil, errors.New("timeout")
+    }
+}

client/extra.go

@@ -0,0 +1,20 @@
+package client
+
+import (
+    "fmt"
+    "math/rand"
+)
+
+type ExtraGenerator func() string
+
+func UuidV4Generator() ExtraGenerator {
+    return func() string {
+        var uuid [16]byte
+        rand.Read(uuid[:])
+
+        uuid[6] = (uuid[6] & 0x0f) | 0x40
+        uuid[8] = (uuid[8] & 0x3f) | 0x80
+
+        return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", uuid[:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:])
+    }
+}

client/tdlib.go

@@ -0,0 +1,188 @@
+package client
+
+// #cgo linux CFLAGS: -I/usr/local/include
+// #cgo darwin CFLAGS: -I/usr/local/include
+// #cgo windows CFLAGS: -IC:/src/td -IC:/src/td/build
+// #cgo linux LDFLAGS: -L/usr/local/lib -ltdjson_static -ltdjson_private -ltdclient -ltdcore -ltdactor -ltddb -ltdsqlite -ltdnet -ltdutils -lstdc++ -lssl -lcrypto -ldl -lz -lm
+// #cgo darwin LDFLAGS: -L/usr/local/lib -L/usr/local/opt/openssl/lib -ltdjson_static -ltdjson_private -ltdclient -ltdcore -ltdactor -ltddb -ltdsqlite -ltdnet -ltdutils -lstdc++ -lssl -lcrypto -ldl -lz -lm
+// #cgo windows LDFLAGS: -LC:/src/td/build/Debug -ltdjson
+// #include <stdlib.h>
+// #include <td/telegram/td_json_client.h>
+// #include <td/telegram/td_log.h>
+import "C"
+
+import (
+    "encoding/json"
+    "errors"
+    "fmt"
+    "strconv"
+    "unsafe"
+)
+
+type JsonClient struct {
+    jsonClient unsafe.Pointer
+}
+
+func NewJsonClient() *JsonClient {
+    jsonClient := &JsonClient{
+        jsonClient: C.td_json_client_create(),
+    }
+
+    return jsonClient
+}
+
+// Sends request to the TDLib client. May be called from any thread.
+func (jsonClient *JsonClient) Send(req Request) {
+    data, _ := json.Marshal(req)
+
+    query := C.CString(string(data))
+    defer C.free(unsafe.Pointer(query))
+
+    C.td_json_client_send(jsonClient.jsonClient, query)
+}
+
+// Receives incoming updates and request responses from the TDLib client. May be called from any thread, but
+// shouldn't be called simultaneously from two different threads.
+// Returned pointer will be deallocated by TDLib during next call to td_json_client_receive or td_json_client_execute
+// in the same thread, so it can't be used after that.
+func (jsonClient *JsonClient) Receive(timeout float64) (*Response, error) {
+    result := C.td_json_client_receive(jsonClient.jsonClient, C.double(timeout))
+    if result == nil {
+        return nil, errors.New("timeout")
+    }
+
+    data := []byte(C.GoString(result))
+
+    var resp Response
+
+    err := json.Unmarshal(data, &resp)
+    if err != nil {
+        return nil, err
+    }
+
+    resp.Data = data
+
+    return &resp, nil
+}
+
+// Synchronously executes TDLib request. May be called from any thread.
+// Only a few requests can be executed synchronously.
+// Returned pointer will be deallocated by TDLib during next call to td_json_client_receive or td_json_client_execute
+// in the same thread, so it can't be used after that.
+func (jsonClient *JsonClient) Execute(req Request) (*Response, error) {
+    data, _ := json.Marshal(req)
+
+    query := C.CString(string(data))
+    defer C.free(unsafe.Pointer(query))
+
+    result := C.td_json_client_execute(jsonClient.jsonClient, query)
+    if result == nil {
+        return nil, errors.New("request can't be parsed")
+    }
+
+    data = []byte(C.GoString(result))
+
+    var resp Response
+
+    err := json.Unmarshal(data, &resp)
+    if err != nil {
+        return nil, err
+    }
+
+    resp.Data = data
+
+    return &resp, nil
+}
+
+// Destroys the TDLib client instance. After this is called the client instance shouldn't be used anymore.
+func (jsonClient *JsonClient) DestroyInstance() {
+    C.td_json_client_destroy(jsonClient.jsonClient)
+}
+
+// Sets the path to the file where the internal TDLib log will be written.
+// By default TDLib writes logs to stderr or an OS specific log.
+// Use this method to write the log to a file instead.
+func SetLogFilePath(filePath string) {
+    query := C.CString(filePath)
+    defer C.free(unsafe.Pointer(query))
+
+    C.td_set_log_file_path(query)
+}
+
+// Sets maximum size of the file to where the internal TDLib log is written before the file will be auto-rotated.
+// Unused if log is not written to a file. Defaults to 10 MB.
+func SetLogMaxFileSize(maxFileSize int64) {
+    C.td_set_log_max_file_size(C.longlong(maxFileSize))
+}
+
+// Sets the verbosity level of the internal logging of TDLib.
+// By default the TDLib uses a log verbosity level of 5
+func SetLogVerbosityLevel(newVerbosityLevel int) {
+    C.td_set_log_verbosity_level(C.int(newVerbosityLevel))
+}
+
+type meta struct {
+    Type  string `json:"@type"`
+    Extra string `json:"@extra"`
+}
+
+type Request struct {
+    meta
+    Data map[string]interface{}
+}
+
+func (req Request) MarshalJSON() ([]byte, error) {
+    req.Data["@type"] = req.Type
+    req.Data["@extra"] = req.Extra
+
+    return json.Marshal(req.Data)
+}
+
+type Response struct {
+    meta
+    Data json.RawMessage
+}
+
+type ResponseError struct {
+    Err *Error
+}
+
+func (responseError ResponseError) Error() string {
+    return fmt.Sprintf("Code: %d. Message: %s", responseError.Err.Code, responseError.Err.Message)
+}
+
+func buildResponseError(data json.RawMessage) error {
+    respErr, err := UnmarshalError(data)
+    if err != nil {
+        return err
+    }
+
+    return ResponseError{
+        Err: respErr,
+    }
+}
+
+// JsonInt64 alias for int64, in order to deal with json big number problem
+type JsonInt64 int64
+
+// MarshalJSON marshals to json
+func (jsonInt64 *JsonInt64) MarshalJSON() ([]byte, error) {
+    return []byte(strconv.FormatInt(int64(*jsonInt64), 10)), nil
+}
+
+// UnmarshalJSON unmarshals from json
+func (jsonInt64 *JsonInt64) UnmarshalJSON(data []byte) error {
+    jsonBigInt, err := strconv.ParseInt(string(data[1:len(data)-1]), 10, 64)
+    if err != nil {
+        return err
+    }
+
+    *jsonInt64 = JsonInt64(jsonBigInt)
+
+    return nil
+}
+
+type Type interface {
+    GetType() string
+    GetClass() string
+}