-
Notifications
You must be signed in to change notification settings - Fork 27
/
offline.go
203 lines (182 loc) · 4.57 KB
/
offline.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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
package elevengo
import (
"context"
"github.com/deadblue/elevengo/lowlevel/api"
"github.com/deadblue/elevengo/lowlevel/errors"
"github.com/deadblue/elevengo/lowlevel/types"
"github.com/deadblue/elevengo/option"
)
type OfflineClearFlag int
const (
OfflineClearDone OfflineClearFlag = iota
OfflineClearAll
OfflineClearFailed
OfflineClearRunning
OfflineClearDoneAndDelete
OfflineClearAllAndDelete
offlineClearFlagMin = OfflineClearDone
offlineClearFlagMax = OfflineClearAllAndDelete
)
// OfflineTask describe an offline downloading task.
type OfflineTask struct {
InfoHash string
Name string
Size int64
Status int
Percent float64
Url string
FileId string
}
func (t *OfflineTask) IsRunning() bool {
return t.Status == 1
}
func (t *OfflineTask) IsDone() bool {
return t.Status == 2
}
func (t *OfflineTask) IsFailed() bool {
return t.Status == -1
}
type offlineIterator struct {
// Total task count
count int
// Page index
pi int
// Page count
pc int
// Page size
ps int
// Cached tasks
tasks []*types.OfflineTask
// Task index
index int
// Task size
size int
// Update function
uf func(*offlineIterator) error
}
func (i *offlineIterator) Next() (err error) {
if i.index += 1; i.index < i.size {
return nil
}
if i.pi >= i.pc {
return errors.ErrReachEnd
}
// Fetch next page
i.pi += 1
return i.uf(i)
}
func (i *offlineIterator) Index() int {
return (i.pi-1)*i.ps + i.index
}
func (i *offlineIterator) Get(task *OfflineTask) (err error) {
if i.index >= i.size {
return errors.ErrReachEnd
}
t := i.tasks[i.index]
task.InfoHash = t.InfoHash
task.Name = t.Name
task.Size = t.Size
task.Url = t.Url
task.Status = t.Status
task.Percent = t.Percent
task.FileId = t.FileId
return nil
}
func (i *offlineIterator) Count() int {
return i.count
}
// OfflineIterate returns an iterator for travelling offline tasks, it will
// return an error if there are no tasks.
func (a *Agent) OfflineIterate() (it Iterator[OfflineTask], err error) {
oi := &offlineIterator{
pi: 1,
uf: a.offlineIterateInternal,
}
if err = a.offlineIterateInternal(oi); err == nil {
it = oi
}
return
}
func (a *Agent) offlineIterateInternal(oi *offlineIterator) (err error) {
spec := (&api.OfflineListSpec{}).Init(oi.pi)
if err = a.llc.CallApi(spec, context.Background()); err != nil {
return
}
result := spec.Result
oi.pi = result.PageIndex
oi.pc = result.PageCount
oi.ps = result.PageSize
oi.index, oi.size = 0, len(result.Tasks)
if oi.size == 0 {
err = errors.ErrReachEnd
} else {
oi.tasks = make([]*types.OfflineTask, 0, oi.size)
oi.tasks = append(oi.tasks, result.Tasks...)
}
oi.count = result.TaskCount
return
}
// OfflineDelete deletes tasks.
func (a *Agent) OfflineDelete(hashes []string, opts ...option.OfflineDeleteOption) (err error) {
if len(hashes) == 0 {
return
}
// Apply options
deleteFiles := false
for _, opt := range opts {
switch opt := opt.(type) {
case option.OfflineDeleteFilesOfTasks:
deleteFiles = bool(opt)
}
}
// Call API
spec := (&api.OfflineDeleteSpec{}).Init(hashes, deleteFiles)
return a.llc.CallApi(spec, context.Background())
}
// OfflineClear clears tasks which is in specific status.
func (a *Agent) OfflineClear(flag OfflineClearFlag) (err error) {
if flag < offlineClearFlagMin || flag > offlineClearFlagMax {
flag = OfflineClearDone
}
spec := (&api.OfflineClearSpec{}).Init(int(flag))
return a.llc.CallApi(spec, context.Background())
}
// OfflineAddUrl adds offline tasks by download URLs.
// It returns an info hash list related to the given urls, the info hash will
// be empty if the related URL is invalid.
//
// You can use options to change the download directory:
//
// agent := Default()
// agent.CredentialImport(&Credential{UID: "", CID: "", SEID: ""})
// hashes, err := agent.OfflineAddUrl([]string{
// "https://foo.bar/file.zip",
// "magent:?xt=urn:btih:111222",
// "ed2k://|file|name|size|md4|",
// }, option.OfflineSaveDownloadedFileTo("dirId"))
func (a *Agent) OfflineAddUrl(urls []string, opts ...option.OfflineAddOption) (hashes []string, err error) {
// Prepare results buffer
if urlCount := len(urls); urlCount == 0 {
return
} else {
hashes = make([]string, urlCount)
}
// Apply options
saveDirId := ""
for _, opt := range opts {
switch opt := opt.(type) {
case option.OfflineSaveDownloadedFileTo:
saveDirId = string(opt)
}
}
// Call API
spec := (&api.OfflineAddUrlsSpec{}).Init(urls, saveDirId, &a.common)
if err = a.llc.CallApi(spec, context.Background()); err == nil {
for i, task := range spec.Result {
if task != nil {
hashes[i] = task.InfoHash
}
}
}
return
}