/
sessionConstructor.go
159 lines (129 loc) · 3.8 KB
/
sessionConstructor.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
package sessionMaker
import (
"context"
"encoding/json"
"github.com/celestix/gotgproto/functions"
"github.com/celestix/gotgproto/storage"
"github.com/gotd/td/session"
"github.com/gotd/td/session/tdesktop"
"gorm.io/gorm"
)
type sessionName interface {
getType() string
}
type sessionNameString string
func (sessionNameString) getType() string { return "str" }
type sessionNameDialector struct {
dialector gorm.Dialector
}
func (sessionNameDialector) getType() string { return "dialector" }
type SessionConstructor interface {
loadSession() (sessionName, []byte, error)
}
type SimpleSessionConstructor int8
func SimpleSession() *SimpleSessionConstructor {
s := SimpleSessionConstructor(0)
return &s
}
func (*SimpleSessionConstructor) loadSession() (sessionName, []byte, error) {
return sessionNameString("gotgproto_simple"), nil, nil
}
type SqlSessionConstructor struct {
dialector gorm.Dialector
}
func SqlSession(dialector gorm.Dialector) *SqlSessionConstructor {
return &SqlSessionConstructor{dialector: dialector}
}
func (s *SqlSessionConstructor) loadSession() (sessionName, []byte, error) {
return &sessionNameDialector{s.dialector}, nil, nil
}
type PyrogramSessionConstructor struct {
name, value string
}
func PyrogramSession(value string) *PyrogramSessionConstructor {
return &PyrogramSessionConstructor{value: value}
}
func (s *PyrogramSessionConstructor) Name(name string) *PyrogramSessionConstructor {
s.name = name
return s
}
func (s *PyrogramSessionConstructor) loadSession() (sessionName, []byte, error) {
sd, err := DecodePyrogramSession(s.value)
if err != nil {
return sessionNameString(s.name), nil, err
}
data, err := json.Marshal(jsonData{
Version: storage.LatestVersion,
Data: *sd,
})
return sessionNameString(s.name), data, err
}
type TelethonSessionConstructor struct {
name, value string
}
func TelethonSession(value string) *TelethonSessionConstructor {
return &TelethonSessionConstructor{value: value}
}
func (s *TelethonSessionConstructor) Name(name string) *TelethonSessionConstructor {
s.name = name
return s
}
func (s *TelethonSessionConstructor) loadSession() (sessionName, []byte, error) {
sd, err := session.TelethonSession(s.value)
if err != nil {
return sessionNameString(s.name), nil, err
}
data, err := json.Marshal(jsonData{
Version: storage.LatestVersion,
Data: *sd,
})
return sessionNameString(s.name), data, err
}
type StringSessionConstructor struct {
name, value string
}
func StringSession(value string) *StringSessionConstructor {
return &StringSessionConstructor{value: value}
}
func (s *StringSessionConstructor) Name(name string) *StringSessionConstructor {
s.name = name
return s
}
func (s *StringSessionConstructor) loadSession() (sessionName, []byte, error) {
sd, err := functions.DecodeStringToSession(s.value)
if err != nil {
return sessionNameString(s.name), nil, err
}
return sessionNameString(s.name), sd.Data, err
}
type TdataSessionConstructor struct {
Account tdesktop.Account
name string
}
func TdataSession(account tdesktop.Account) *TdataSessionConstructor {
return &TdataSessionConstructor{Account: account}
}
func (s *TdataSessionConstructor) Name(name string) *TdataSessionConstructor {
s.name = name
return s
}
func (s *TdataSessionConstructor) loadSession() (sessionName, []byte, error) {
sd, err := session.TDesktopSession(s.Account)
if err != nil {
return sessionNameString(s.name), nil, err
}
ctx := context.Background()
var (
gotdstorage = new(session.StorageMemory)
loader = session.Loader{Storage: gotdstorage}
)
// Save decoded Telegram Desktop session as gotd session.
if err := loader.Save(ctx, sd); err != nil {
return sessionNameString(s.name), nil, err
}
data, err := json.Marshal(jsonData{
Version: storage.LatestVersion,
Data: *sd,
})
return sessionNameString(s.name), data, err
}