\n\n",
40 | }
41 |
42 | type ScriptConfig struct {
43 | ConfigName string `json:"config_name"`
44 | OutputName string `json:"output_name"`
45 | CoverFile string `json:"cover_file"`
46 | DeviceId string `json:"device_id"`
47 | ThreadNum int `json:"thread_num"`
48 | MaxRetry int `json:"max_retry"`
49 | Epub bool `json:"epub"`
50 | }
51 |
52 | type BoluobaoConfig struct {
53 | Cookie string `json:"cookie"`
54 | }
55 |
56 | type HbookerCommonParams struct {
57 | LoginToken string `json:"login_token"`
58 | Account string `json:"account"`
59 | }
60 |
61 | type Hbooker struct {
62 | Client *hbookerLib.Client
63 | BookInfo *hbookermodel.BookInfo
64 | }
65 |
66 | type SFacg struct {
67 | Client *boluobaoLib.Client
68 | BookInfo *boluobaomodel.BookInfoData
69 | }
70 |
71 | var APP = struct {
72 | Hbooker *Hbooker
73 | SFacg *SFacg
74 | }{}
75 |
76 | func UpdateConfig() {
77 | changeVar := false
78 |
79 | if Vars.MaxRetry <= 0 || Vars.MaxRetry >= 10 {
80 | Vars.MaxRetry = 5
81 | changeVar = true
82 | }
83 |
84 | if Vars.DeviceId == "" {
85 | Vars.DeviceId = uuid.New().String()
86 | changeVar = true
87 | }
88 |
89 | if Vars.ConfigName == "" || Vars.OutputName == "" || Vars.CoverFile == "" {
90 | Vars.ConfigName, Vars.OutputName, Vars.CoverFile = "cache", "save", "cover"
91 | changeVar = true
92 | }
93 |
94 | EnsureDirectoriesExist([]string{Vars.ConfigName, Vars.OutputName, path.Join(Vars.ConfigName, Vars.CoverFile)})
95 |
96 | if changeVar {
97 | SaveConfig()
98 | }
99 | }
100 |
101 | func EnsureDirectoriesExist(dirNames []string) {
102 | for _, dir := range dirNames {
103 | if !DirectoryExists(dir) {
104 | tools.Mkdir(dir)
105 | }
106 | }
107 | }
108 |
109 | func DirectoryExists(dirName string) bool {
110 | _, err := os.Stat(dirName)
111 | return !os.IsNotExist(err)
112 | }
113 |
114 | func ReadConfig(fileName string) ([]byte, error) {
115 | if fileName == "" {
116 | fileName = "./config.json"
117 | }
118 | return os.ReadFile(fileName)
119 | }
120 |
121 | func LoadConfig() {
122 |
123 | data, err := ReadConfig("")
124 | if err != nil {
125 | fmt.Println("ReadConfig:", err)
126 | return
127 | }
128 |
129 | if err := json.Unmarshal(data, &Apps); err != nil {
130 | fmt.Println("Load:", err)
131 | }
132 | }
133 |
134 | func SaveConfig() {
135 | FileLock.Lock()
136 | defer FileLock.Unlock()
137 |
138 | data, err := json.MarshalIndent(Apps, "", " ")
139 | if err != nil {
140 | fmt.Println("SaveConfig:", err)
141 | return
142 | }
143 |
144 | if err := os.WriteFile("config.json", data, 0777); err != nil {
145 | fmt.Println("SaveConfig:", err)
146 | }
147 |
148 | LoadConfig()
149 | }
150 |
--------------------------------------------------------------------------------
/pkg/epub/internal/storage/memory/fs.go:
--------------------------------------------------------------------------------
1 | package memory
2 |
3 | import (
4 | "io/fs"
5 | "path"
6 | "strings"
7 | "time"
8 |
9 | "github.com/AlexiaVeronica/pineapple-backups/pkg/epub/internal/storage"
10 | )
11 |
12 | type Memory struct {
13 | fs map[string]*file
14 | }
15 |
16 | func NewMemory() *Memory {
17 | return &Memory{
18 | fs: map[string]*file{
19 | "/": {
20 | name: path.Base("/"),
21 | modTime: time.Now(),
22 | mode: fs.ModeDir | (0666),
23 | },
24 | },
25 | }
26 | }
27 |
28 | // Open opens the named file.
29 | //
30 | // When Open returns an error, it should be of type *PathError
31 | // with the Op field set to "open", the Path field set to name,
32 | // and the Err field describing the problem.
33 | //
34 | // Open should reject attempts to open names that do not satisfy
35 | // ValidPath(name), returning a *PathError with Err set to
36 | // ErrInvalid or ErrNotExist.
37 | func (m *Memory) Open(name string) (fs.File, error) {
38 | var f fs.File
39 | var ok bool
40 | if f, ok = m.fs[name]; !ok {
41 | return nil, fs.ErrNotExist
42 | }
43 | return f, nil
44 | }
45 |
46 | // WriteFile writes data to the named file, creating it if necessary. If the file does not exist, WriteFile creates it with permissions perm (before umask); otherwise WriteFile truncates it before writing, without changing permissions.
47 | func (m *Memory) WriteFile(name string, data []byte, perm fs.FileMode) error {
48 | if !fs.ValidPath(name) {
49 | return fs.ErrInvalid
50 | }
51 | f := &file{
52 | name: path.Base(name),
53 | modTime: time.Now(),
54 | mode: (perm),
55 | content: data,
56 | }
57 | m.fs[name] = f
58 | return nil
59 | }
60 |
61 | // Mkdir creates a new directory with the specified name and permission bits (before umask). If there is an error, it will be of type *PathError.
62 | func (m *Memory) Mkdir(name string, perm fs.FileMode) error {
63 | if !fs.ValidPath(path.Base(name)) {
64 | return fs.ErrInvalid
65 | }
66 | f := &file{
67 | name: path.Base(name),
68 | modTime: time.Now(),
69 | mode: fs.ModeDir | (perm),
70 | }
71 | m.fs[name] = f
72 | return nil
73 | }
74 |
75 | // RemoveAll removes path and any children it contains. It removes everything it can but returns the first error it encounters. If the path does not exist, RemoveAll returns nil (no error). If there is an error, it will be of type *PathError.
76 | func (m *Memory) RemoveAll(name string) error {
77 | for k := range m.fs {
78 | if strings.HasPrefix(k, name) {
79 | delete(m.fs, k)
80 | }
81 | }
82 | return nil
83 | }
84 |
85 | // Create creates or truncates the named file. If the file already exists, it is truncated. If the file does not exist, it is created with mode 0666 (before umask). If successful, methods on the returned File can be used for I/O; the associated file descriptor has mode O_RDWR. If there is an error, it will be of type *PathError.
86 | func (m *Memory) Create(name string) (storage.File, error) {
87 | if !fs.ValidPath(path.Base(name)) {
88 | return nil, fs.ErrInvalid
89 | }
90 | f := &file{
91 | name: path.Base(name),
92 | modTime: time.Now(),
93 | mode: 0666,
94 | }
95 | m.fs[name] = f
96 | return f, nil
97 | }
98 |
99 | // ReadDir reads the named directory
100 | // and returns a list of directory entries sorted by filename.
101 | func (m *Memory) ReadDir(name string) ([]fs.DirEntry, error) {
102 | output := make([]fs.DirEntry, 0)
103 | for k, v := range m.fs {
104 | if path.Dir(k) == name {
105 | output = append(output, v)
106 | }
107 | }
108 | return output, nil
109 | }
110 |
111 | // Stat returns a FileInfo describing the file.
112 | // If there is an error, it should be of type *PathError.
113 | // This makes Memory compatible with the StatFS interface
114 | func (m *Memory) Stat(name string) (fs.FileInfo, error) {
115 | f, ok := m.fs[name]
116 | if !ok {
117 | return nil, &fs.PathError{
118 | Op: "Stat",
119 | Path: name,
120 | Err: fs.ErrNotExist,
121 | }
122 | }
123 | return f.Stat()
124 | }
125 |
--------------------------------------------------------------------------------
/pkg/app/app.go:
--------------------------------------------------------------------------------
1 | package app
2 |
3 | import (
4 | "fmt"
5 | "github.com/AlexiaVeronica/boluobaoLib/boluobaomodel"
6 | "github.com/AlexiaVeronica/hbookerLib/hbookermodel"
7 | "os"
8 | "path"
9 |
10 | "github.com/AlexiaVeronica/boluobaoLib"
11 | "github.com/AlexiaVeronica/hbookerLib"
12 | )
13 |
14 | type APP struct {
15 | CurrentApp string
16 | BookId string
17 | Boluobao *boluobaoLib.Client
18 | Ciweimao *hbookerLib.Client
19 | }
20 |
21 | const (
22 | BoluobaoLibAPP = "boluobao"
23 | CiweimaoLibAPP = "ciweimao"
24 | )
25 |
26 | func NewApp() *APP {
27 | a := &APP{
28 | CurrentApp: BoluobaoLibAPP,
29 | Boluobao: boluobaoLib.NewClient(),
30 | Ciweimao: hbookerLib.NewClient(),
31 | }
32 | a.initDirectories()
33 | return a
34 | }
35 |
36 | func (a *APP) initDirectories() {
37 | directories := []string{
38 | "cache",
39 | "cache/" + CiweimaoLibAPP,
40 | "cache/" + BoluobaoLibAPP,
41 | "save/",
42 | "cover/",
43 | "save/" + CiweimaoLibAPP,
44 | "save/" + BoluobaoLibAPP,
45 | }
46 | for _, dir := range directories {
47 | createCacheDirectory(dir)
48 | }
49 | }
50 | func mergeTextToFile[T any](bookName string) *os.File {
51 | data := new(T)
52 | var savePath string
53 | switch any(data).(type) {
54 | case *boluobaomodel.ChapterList:
55 | savePath = path.Join("save", BoluobaoLibAPP, fmt.Sprintf("%v.txt", bookName))
56 | case *hbookermodel.ChapterList:
57 | savePath = path.Join("save", CiweimaoLibAPP, fmt.Sprintf("%v.txt", bookName))
58 | }
59 | file, err := os.OpenFile(savePath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
60 | if err != nil {
61 | fmt.Printf("Failed to create file %s: %v\n", savePath, err)
62 | return nil
63 | }
64 | return file
65 | }
66 |
67 | func createCacheDirectory(path string) {
68 | if _, err := os.Stat(path); os.IsNotExist(err) {
69 | if err = os.MkdirAll(path, 0777); err != nil {
70 | fmt.Printf("Failed to create directory %s: %v\n", path, err)
71 | }
72 | }
73 | }
74 |
75 | func (a *APP) SetCurrentApp(app string) {
76 | switch app {
77 | case BoluobaoLibAPP, CiweimaoLibAPP:
78 | a.CurrentApp = app
79 | default:
80 | panic("Invalid app type: " + app)
81 | }
82 | }
83 |
84 | func (a *APP) GetCurrentApp() string {
85 | return a.CurrentApp
86 | }
87 |
88 | func (a *APP) SearchDetailed(keyword string) *APP {
89 | switch a.CurrentApp {
90 | case BoluobaoLibAPP:
91 | newApp := a.Boluobao.APP()
92 | newApp.Search(keyword, sfContinueFunction, sfContentFunction).MergeText(
93 | sfMergeText(mergeTextToFile[boluobaomodel.ChapterList](newApp.GetBookInfo().NovelName)))
94 | case CiweimaoLibAPP:
95 | newApp := a.Ciweimao.APP().Search(keyword, hbookerContinueFunction, hbookerContentFunction)
96 | newApp.MergeText(hbookerMergeText(mergeTextToFile[hbookermodel.ChapterList](newApp.GetBookInfo().BookName)))
97 | }
98 | return a
99 | }
100 |
101 | func (a *APP) DownloadBookByBookId(bookId string) *APP {
102 | switch a.CurrentApp {
103 | case BoluobaoLibAPP:
104 | bookInfo, err := a.Boluobao.API().GetBookInfo(bookId)
105 | if err != nil {
106 | fmt.Println("Failed to get book info:", err)
107 | return a
108 | }
109 | a.Boluobao.APP().SetBookInfo(&bookInfo.Data).Download(sfContinueFunction, sfContentFunction).MergeText(
110 | sfMergeText(mergeTextToFile[boluobaomodel.ChapterList](bookInfo.Data.NovelName)))
111 | case CiweimaoLibAPP:
112 | bookInfo, err := a.Ciweimao.API().GetBookInfo(bookId)
113 | if err != nil {
114 | fmt.Println("Failed to get book info:", err)
115 | return a
116 | }
117 | a.Ciweimao.APP().SetBookInfo(&bookInfo.Data.BookInfo).Download(hbookerContinueFunction, hbookerContentFunction).
118 | MergeText(hbookerMergeText(mergeTextToFile[hbookermodel.ChapterList](bookInfo.Data.BookInfo.BookName)))
119 | }
120 | return a
121 | }
122 |
123 | func (a *APP) Bookshelf() *APP {
124 | switch a.CurrentApp {
125 | case BoluobaoLibAPP:
126 | newApp := a.Boluobao.APP().Bookshelf(sfContinueFunction, sfContentFunction)
127 | newApp.MergeText(sfMergeText(mergeTextToFile[boluobaomodel.ChapterList](newApp.GetBookInfo().NovelName)))
128 | case CiweimaoLibAPP:
129 | newApp := a.Ciweimao.APP().Bookshelf(hbookerContinueFunction, hbookerContentFunction)
130 | newApp.MergeText(hbookerMergeText(mergeTextToFile[hbookermodel.ChapterList](newApp.GetBookInfo().BookName)))
131 | }
132 | return a
133 | }
134 |
--------------------------------------------------------------------------------
/pkg/epub/fetchmedia.go:
--------------------------------------------------------------------------------
1 | package epub
2 |
3 | import (
4 | "bytes"
5 | "errors"
6 | "fmt"
7 | "io"
8 | "io/ioutil"
9 | "net/http"
10 | "os"
11 | "path/filepath"
12 |
13 | "github.com/gabriel-vasile/mimetype"
14 | "github.com/vincent-petithory/dataurl"
15 | )
16 |
17 | // grabber is a top level structure that allows a custom http client.
18 | // if onlyChecl is true, the methods will not perform actual grab to spare memory and bandwidth
19 | type grabber struct {
20 | *http.Client
21 | }
22 |
23 | func (g grabber) checkMedia(mediaSource string) error {
24 | fetchErrors := make([]error, 0)
25 | for _, f := range []func(string, bool) (io.ReadCloser, error){
26 | g.localHandler,
27 | g.httpHandler,
28 | g.dataURLHandler,
29 | } {
30 | var err error
31 | source, err := f(mediaSource, true)
32 | if source != nil {
33 | source.Close()
34 | }
35 | if err == nil {
36 | return nil
37 | }
38 | fetchErrors = append(fetchErrors, err)
39 | }
40 | return &FileRetrievalError{Source: mediaSource, Err: fetchError(fetchErrors)}
41 | }
42 |
43 | // fetchMedia from mediaSource into mediaFolderPath as mediaFilename returning its type.
44 | // the mediaSource can be a URL, a local path or an inline dataurl (as specified in RFC 2397)
45 | func (g grabber) fetchMedia(mediaSource, mediaFolderPath, mediaFilename string) (mediaType string, err error) {
46 |
47 | mediaFilePath := filepath.Join(
48 | mediaFolderPath,
49 | mediaFilename,
50 | )
51 | // failfast, create the output file handler at the begining, if we cannot write the file, bail out
52 | w, err := filesystem.Create(mediaFilePath)
53 | if err != nil {
54 | return "", fmt.Errorf("unable to create file %s: %s", mediaFilePath, err)
55 | }
56 | defer w.Close()
57 | var source io.ReadCloser
58 | fetchErrors := make([]error, 0)
59 | for _, f := range []func(string, bool) (io.ReadCloser, error){
60 | g.localHandler,
61 | g.httpHandler,
62 | g.dataURLHandler,
63 | } {
64 | var err error
65 | source, err = f(mediaSource, false)
66 | if err != nil {
67 | fetchErrors = append(fetchErrors, err)
68 | continue
69 | }
70 | break
71 | }
72 | if source == nil {
73 | return "", &FileRetrievalError{Source: mediaSource, Err: fetchError(fetchErrors)}
74 |
75 | }
76 | defer source.Close()
77 |
78 | _, err = io.Copy(w, source)
79 | if err != nil {
80 | // There shouldn't be any problem with the writer, but the reader
81 | // might have an issue
82 | return "", &FileRetrievalError{Source: mediaSource, Err: err}
83 | }
84 |
85 | // Detect the mediaType
86 | r, err := filesystem.Open(mediaFilePath)
87 | if err != nil {
88 | return "", err
89 | }
90 | defer r.Close()
91 | mime, err := mimetype.DetectReader(r)
92 | if err != nil {
93 | panic(err)
94 | }
95 |
96 | // Is it CSS?
97 | mtype := mime.String()
98 | if mime.Is("text/plain") {
99 | if filepath.Ext(mediaSource) == ".css" || filepath.Ext(mediaFilename) == ".css" {
100 | mtype = "text/css"
101 | }
102 | }
103 | return mtype, nil
104 | }
105 |
106 | func (g grabber) httpHandler(mediaSource string, onlyCheck bool) (io.ReadCloser, error) {
107 | var resp *http.Response
108 | var err error
109 | if onlyCheck {
110 | resp, err = g.Head(mediaSource)
111 | } else {
112 | resp, err = g.Get(mediaSource)
113 | }
114 | if err != nil {
115 | return nil, err
116 | }
117 | if resp.StatusCode > 400 {
118 | return nil, errors.New("cannot get file, bad return code")
119 | }
120 | return resp.Body, nil
121 | }
122 |
123 | func (g grabber) localHandler(mediaSource string, onlyCheck bool) (io.ReadCloser, error) {
124 | if onlyCheck {
125 | if _, err := os.Stat(mediaSource); os.IsNotExist(err) {
126 | return nil, err
127 | }
128 | return nil, nil
129 | }
130 | return os.Open(mediaSource)
131 | }
132 |
133 | func (g grabber) dataURLHandler(mediaSource string, onlyCheck bool) (io.ReadCloser, error) {
134 | if onlyCheck {
135 | _, err := dataurl.DecodeString(mediaSource)
136 | return nil, err
137 | }
138 | data, err := dataurl.DecodeString(mediaSource)
139 | if err != nil {
140 | return nil, err
141 | }
142 | return ioutil.NopCloser(bytes.NewReader(data.Data)), nil
143 | }
144 |
145 | type fetchError []error
146 |
147 | func (f fetchError) Error() string {
148 | var message string
149 | for _, err := range f {
150 | message = fmt.Sprintf("%v\n %v", message, err.Error())
151 | }
152 | return message
153 | }
154 |
--------------------------------------------------------------------------------
/pkg/tools/tools.go:
--------------------------------------------------------------------------------
1 | package tools
2 |
3 | import (
4 | "bufio"
5 | "bytes"
6 | "encoding/json"
7 | "fmt"
8 | "log"
9 | "os"
10 | "path"
11 | "regexp"
12 | "sort"
13 | "strconv"
14 | "strings"
15 | )
16 |
17 | func RegexpName(Name string) string {
18 | return regexp.MustCompile(`[\\/:*?"<>|]`).ReplaceAllString(Name, "")
19 | }
20 |
21 | func JsonString(jsonStruct any) string {
22 | if jsonInfo, err := json.MarshalIndent(jsonStruct, "", " "); err == nil {
23 | return string(jsonInfo)
24 | } else {
25 | log.Println(err)
26 | }
27 | return ""
28 | }
29 |
30 | func StandardContent(contentList []string) string {
31 | content := "" // clear content string
32 | for _, s := range contentList {
33 | if s != "" {
34 | content += "\n" + strings.ReplaceAll(s, " ", "")
35 | }
36 | }
37 | return content
38 | }
39 | func TestList(List []string, testString string) bool {
40 | for _, s := range List {
41 | if s == testString {
42 | return true
43 | }
44 | }
45 | return false
46 | }
47 | func TestIntList(List []int, testString string) bool {
48 | for _, s := range List {
49 | if strconv.Itoa(s) == testString {
50 | return true
51 | }
52 | }
53 | return false
54 | }
55 | func GetFileName(dirname string) []string {
56 | var file_list []string
57 | f, err := os.Open(dirname)
58 | if err != nil {
59 | log.Fatal(err)
60 | }
61 | if list, ok := f.Readdir(-1); ok == nil {
62 | _ = f.Close()
63 | sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
64 | for _, v := range list {
65 | file_list = append(file_list, v.Name())
66 | }
67 | return file_list
68 | } else {
69 | log.Fatal(ok)
70 | }
71 | return nil
72 | }
73 | func get_working_directory() string {
74 | dir, err := os.Getwd()
75 | if err != nil {
76 | log.Fatal(err)
77 | } else {
78 | return dir
79 | }
80 | return ""
81 | }
82 |
83 | func Mkdir(filePath string) string {
84 | file_path := path.Join(get_working_directory(), filePath)
85 | if err := os.MkdirAll(file_path, os.ModePerm); err != nil {
86 | fmt.Println(err)
87 | }
88 | return file_path
89 | }
90 |
91 | // InputStr input str
92 | func InputStr(introduction string) string {
93 | var input string
94 | // if search keyword is not empty, search book and download
95 | fmt.Printf(introduction)
96 | if _, err := fmt.Scanln(&input); err == nil {
97 | if input != "" {
98 | return input
99 | }
100 | }
101 | return InputStr(">")
102 | }
103 |
104 | func GET(prompt string) []string {
105 | compile, _ := regexp.Compile(`\s+`)
106 | inputs := compile.Split(strings.TrimSpace(Input(prompt)), -1)
107 | if len(inputs) > 0 && inputs[0] != "" {
108 | return inputs
109 | }
110 | return nil
111 | }
112 |
113 | func Input(prompt string) string {
114 | for {
115 | fmt.Printf(prompt)
116 | input, err := bufio.NewReader(os.Stdin).ReadString('\n')
117 | if err == nil {
118 | return input
119 | }
120 | }
121 | }
122 | func IsNum(s string) bool {
123 | _, err := strconv.ParseFloat(s, 64)
124 | return err == nil
125 | }
126 |
127 | // StrToInt string to int
128 | func StrToInt(str string) int {
129 | if i, err := strconv.Atoi(str); err == nil {
130 | return i
131 | }
132 | return 0
133 | }
134 |
135 | func FormatJson(jsonString []byte) {
136 | var str bytes.Buffer
137 | if err := json.Indent(&str, jsonString, "", " "); err == nil {
138 | fmt.Println(str.String())
139 | } else {
140 | log.Fatalln(err)
141 | }
142 | }
143 |
144 | // InputInt input int
145 | func InputInt(introduction string, max_indexes int) int {
146 | var input int
147 | // if search keyword is not empty, search book and download
148 | fmt.Printf(introduction)
149 | if _, err := fmt.Scanln(&input); err == nil {
150 | for {
151 | if input >= max_indexes {
152 | fmt.Println("you input index is out of range, please input again:")
153 | return InputInt(">", max_indexes)
154 | } else {
155 | return input
156 | }
157 | }
158 | } else {
159 | return InputInt(">", max_indexes)
160 | }
161 | }
162 |
163 | //func TestKeyword(Text string, keyword any) bool {
164 | // switch keyword.(type) {
165 | // case string:
166 | // return strings.Contains(Text, keyword.(string))
167 | // case int:
168 | // return strings.Contains(Text, strconv.Itoa(keyword.(int)))
169 | // default:
170 | // panic("keyword type error")
171 | // }
172 | //}
173 |
174 | // strconv.FormatBool()
175 | //func FormatBool(b bool) string {
176 | // if b {
177 | // return "true"
178 | // }
179 | // return "false"
180 | //}
181 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Noa Himesaka
2 |
3 |
5 |
6 |
7 | Download books from
8 | hbooker to read them.
9 |
10 |
11 | [简中](./docs/README_zh-CN.md) | [繁中](./docs/README_zh-TW.md)
12 |
13 | ---
14 |
15 | ## **Features**
16 |
17 | - The script implements download functions for hbooker Android API.
18 | - You can log in to your account and save your cookies in a `config.json` file.
19 | - Input the book ID or URL to download the book to a local directory.
20 | - Input the URL to download the book text from the URL.
21 | - Supports downloading EPUB files from hbooker.
22 | - Search for books by keyword and download the search results.
23 | - [ Warning ] The new version of book cache is incompatible with older versions of book cache.
24 |
25 | ---
26 |
27 | ## Sign in to your Ciweimao account
28 |
29 | - To use this script, you need to log in with your account and obtain your `token`.
30 | - The new version of hbooker adds GEETEST verification, which will be triggered if you enter incorrect information or
31 | log in multiple times.
32 | - The IP address may need to log in again after a few hours to avoid triggering the verification process. You can try
33 | changing the IP to avoid it.
34 |
35 | ---
36 |
37 | ## Accessing the API using tokens
38 |
39 | - Use tokens to access the API and bypass login.
40 | - Third-party captcha GEETEST has been added to the Ciweimao official server.
41 | - The Ciweimao login is protected by GEETEST, which seems impossible to circumvent.
42 | - You can capture packets of the Ciweimao Android App to obtain the account and login_token for logging in.
43 |
44 | ---
45 |
46 | ## **Example**
47 |
48 | ``` bash
49 | NAME:
50 | pineapple-backups - https://github.com/AlexiaVeronica/pineapple-backups
51 |
52 | USAGE:
53 | main.exe [global options] command [command options] [arguments...]
54 |
55 | VERSION:
56 | V.1.9.7
57 |
58 | COMMANDS:
59 | help, h Shows a list of commands or help for one command
60 |
61 | GLOBAL OPTIONS:
62 | -a value, --appType value cheng app type
63 | -d value, --download value book id
64 | -t, --token input hbooker token
65 | -m value, --maxThread value change max thread number (default: 16)
66 | -u value, --user value input account name
67 | -p value, --password value input password
68 | --update update book
69 | -s value, --search value search book by keyword
70 | -l, --login login local account
71 | -e, --epub start epub
72 | -b, --bookshelf show bookshelf
73 | --help, -h show help
74 | --version, -v print the version
75 | ```
76 |
77 | ## Thank you for JetBrains License
78 |
79 |
80 |
82 |
83 |
84 | - [Goland](https://www.jetbrains.com/go/)
85 |
86 | - I would like to express my sincere gratitude and appreciation to JetBrains for providing me with the license to use and leverage software related to open source tools.
87 |
88 | - Your software has helped me to accomplish my tasks faster and more efficiently in my daily work, while also providing me with appropriate quality assurance. This is important for my personal growth and business development.
89 |
90 | - Thank you for your outstanding contribution to promoting the development of open-source software community. I will continue to use and support your company's software in my work and leisure time, and actively participate in contributing to the open-source community.
91 |
92 | - Once again, thank you JetBrains for your support!
93 |
94 | - Best regards, Alexia
95 |
96 | ## **Disclaimers**
97 |
98 | - This tool is for educational purposes only. Please delete it from your computer within 24 hours after downloading.
99 | - Please respect the copyright and do not distribute the crawled books yourself.
100 | - The authors or copyright holders shall not be liablefor any claim, damages, or other liability, whether in an action
101 | of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings
102 | in the software, including but not limited to the use of the software for illegal purposes. The author is not
103 | responsible for any legal consequences.
104 | - If you have any questions, please contact me via GitHub issues or email.
105 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/AlexiaVeronica/pineapple-backups/pkg/config"
6 | "log"
7 | "os"
8 | "strings"
9 |
10 | "github.com/AlexiaVeronica/input"
11 | "github.com/AlexiaVeronica/pineapple-backups/pkg/app"
12 | "github.com/AlexiaVeronica/pineapple-backups/pkg/tools"
13 | "github.com/urfave/cli"
14 | )
15 |
16 | var (
17 | apps *app.APP
18 | cmd = &commandLines{MaxThread: 32}
19 | )
20 |
21 | type commandLines struct {
22 | BookID, Account, Password, SearchKey string
23 | MaxThread int
24 | Token, Login, ShowInfo, Update, Epub, BookShelf bool
25 | }
26 |
27 | const (
28 | FlagAppType = "appType"
29 | FlagDownload = "download"
30 | FlagToken = "token"
31 | FlagMaxThread = "maxThread"
32 | FlagUser = "user"
33 | FlagPassword = "password"
34 | FlagUpdate = "update"
35 | FlagSearch = "search"
36 | FlagLogin = "login"
37 | FlagEpub = "epub"
38 | FlagBookShelf = "bookshelf"
39 | )
40 |
41 | func init() {
42 |
43 | setupConfig()
44 | apps = app.NewApp()
45 | setupCLI()
46 | setupTokens()
47 | }
48 |
49 | func setupConfig() {
50 | if _, err := os.Stat("./config.json"); os.IsNotExist(err) {
51 | fmt.Println("config.json does not exist, creating a new one!")
52 | } else {
53 | config.LoadConfig()
54 | }
55 | config.UpdateConfig()
56 | }
57 |
58 | func setupCLI() {
59 | newCli := cli.NewApp()
60 | newCli.Name = "pineapple-backups"
61 | newCli.Version = "V.2.2.1"
62 | newCli.Usage = "https://github.com/AlexiaVeronica/pineapple-backups"
63 | newCli.Flags = defineFlags()
64 | newCli.Action = validateAppType
65 |
66 | if err := newCli.Run(os.Args); err != nil {
67 | log.Fatal(err)
68 | }
69 | }
70 |
71 | func defineFlags() []cli.Flag {
72 | return []cli.Flag{
73 | cli.StringFlag{Name: fmt.Sprintf("a, %s", FlagAppType), Value: app.BoluobaoLibAPP, Usage: "change app type", Destination: &apps.CurrentApp},
74 | cli.StringFlag{Name: fmt.Sprintf("d, %s", FlagDownload), Usage: "book id", Destination: &cmd.BookID},
75 | cli.BoolFlag{Name: fmt.Sprintf("t, %s", FlagToken), Usage: "input hbooker token", Destination: &cmd.Token},
76 | cli.IntFlag{Name: fmt.Sprintf("m, %s", FlagMaxThread), Value: 16, Usage: "change max thread number", Destination: &cmd.MaxThread},
77 | cli.StringFlag{Name: fmt.Sprintf("u, %s", FlagUser), Usage: "input account name", Destination: &cmd.Account},
78 | cli.StringFlag{Name: fmt.Sprintf("p, %s", FlagPassword), Usage: "input password", Destination: &cmd.Password},
79 | cli.BoolFlag{Name: FlagUpdate, Usage: "update book", Destination: &cmd.Update},
80 | cli.StringFlag{Name: fmt.Sprintf("s, %s", FlagSearch), Usage: "search book by keyword", Destination: &cmd.SearchKey},
81 | cli.BoolFlag{Name: fmt.Sprintf("l, %s", FlagLogin), Usage: "login local account", Destination: &cmd.Login},
82 | cli.BoolFlag{Name: fmt.Sprintf("e, %s", FlagEpub), Usage: "start epub", Destination: &cmd.Epub},
83 | cli.BoolFlag{Name: fmt.Sprintf("b, %s", FlagBookShelf), Usage: "show bookshelf", Destination: &cmd.BookShelf},
84 | }
85 | }
86 |
87 | func validateAppType(c *cli.Context) {
88 | if !isValidAppType(apps.CurrentApp) {
89 | log.Fatalf("%s app type error", apps.CurrentApp)
90 | }
91 | }
92 |
93 | func isValidAppType(appType string) bool {
94 | return strings.Contains(appType, app.CiweimaoLibAPP) || strings.Contains(appType, app.BoluobaoLibAPP)
95 | }
96 |
97 | func setupTokens() {
98 | apps.Ciweimao.SetToken(config.Apps.Hbooker.Account, config.Apps.Hbooker.LoginToken)
99 | apps.Boluobao.Cookie = config.Apps.Sfacg.Cookie
100 | }
101 |
102 | func shellSwitch(inputs []string) {
103 | if len(inputs) == 0 {
104 | fmt.Println("No command provided.")
105 | return
106 | }
107 |
108 | switch inputs[0] {
109 | case "up", "update":
110 | // Update function placeholder
111 | case "a", "app":
112 | handleAppSwitch(inputs)
113 | case "d", "download":
114 | handleDownload(inputs)
115 | case "bs", "bookshelf":
116 | apps.Bookshelf()
117 | case "s", "search":
118 | apps.SearchDetailed(inputs[1])
119 | case "l", "login":
120 | handleLogin(inputs)
121 | case "t", "token":
122 | apps.Ciweimao.SetToken(inputs[1], inputs[2])
123 | default:
124 | fmt.Println("command not found, please input help to see the command list:", inputs[0])
125 | }
126 | }
127 |
128 | func handleAppSwitch(inputs []string) {
129 | if len(inputs) < 2 {
130 | fmt.Println("app type required. Example: app ")
131 | return
132 | }
133 |
134 | if tools.TestList([]string{app.BoluobaoLibAPP, app.CiweimaoLibAPP}, inputs[1]) {
135 | apps.CurrentApp = inputs[1]
136 | } else {
137 | fmt.Println("app type error, please input again.")
138 | }
139 | }
140 |
141 | func handleDownload(inputs []string) {
142 | if len(inputs) == 2 {
143 | apps.DownloadBookByBookId(inputs[1])
144 | } else {
145 | fmt.Println("input book id or url, like: download ")
146 | }
147 | }
148 |
149 | func handleLogin(inputs []string) {
150 | if len(inputs) < 3 {
151 | fmt.Println("you must input account and password, like: -login account password")
152 | return
153 | }
154 | switch apps.CurrentApp {
155 | case app.CiweimaoLibAPP:
156 | apps.Ciweimao.SetToken(inputs[1], inputs[2])
157 | case app.BoluobaoLibAPP:
158 | loginStatus, err := apps.Boluobao.API().Login(inputs[1], inputs[2])
159 | if err == nil {
160 | apps.Boluobao.Cookie = loginStatus.Cookie
161 | }
162 | }
163 | }
164 |
165 | func shell(messageOpen bool) {
166 | if messageOpen {
167 | for _, message := range config.HelpMessage {
168 | fmt.Println("[info]", message)
169 | }
170 | }
171 | for {
172 | inputRes := input.StringInput(">")
173 | if len(inputRes) > 0 {
174 | shellSwitch(strings.Split(inputRes, " "))
175 | }
176 | }
177 | }
178 |
179 | func main() {
180 | if len(os.Args) > 1 {
181 | handleCommandLine()
182 | } else {
183 | shell(true)
184 | }
185 | }
186 |
187 | func handleCommandLine() {
188 | switch {
189 | case cmd.Login:
190 | loginStatus, err := apps.Boluobao.API().Login(cmd.Account, cmd.Password)
191 | if err == nil {
192 | apps.Boluobao.Cookie = loginStatus.Cookie
193 | }
194 | case cmd.BookID != "":
195 | apps.DownloadBookByBookId(cmd.BookID)
196 | case cmd.SearchKey != "":
197 | apps.SearchDetailed(cmd.SearchKey)
198 | case cmd.Update:
199 | // Update function placeholder
200 | case cmd.Token:
201 | apps.Ciweimao.SetToken(input.StringInput("Please input account:"), input.StringInput("Please input token:"))
202 | case cmd.BookShelf:
203 | apps.Bookshelf()
204 | default:
205 | fmt.Println("command not found, please input help to see the command list:", os.Args[1])
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/pkg/epub/toc.go:
--------------------------------------------------------------------------------
1 | package epub
2 |
3 | import (
4 | "encoding/xml"
5 | "fmt"
6 | "path/filepath"
7 | "strconv"
8 | )
9 |
10 | const (
11 | tocNavBodyTemplate = `
12 |
13 | Table of Contents
14 |
15 |
16 |
17 | `
18 | tocNavFilename = "nav.xhtml"
19 | tocNavItemID = "nav"
20 | tocNavItemProperties = "nav"
21 | tocNavEpubType = "toc"
22 |
23 | tocNcxFilename = "toc.ncx"
24 | tocNcxItemID = "ncx"
25 | tocNcxTemplate = `
26 |
27 |
28 |
32 |
34 |
35 |
37 |
38 |
39 | `
40 |
41 | xmlnsEpub = "http://www.idpf.org/2007/ops"
42 | )
43 |
44 | // toc implements the EPUB table of contents
45 | type toc struct {
46 | // This holds the body XML for the EPUB v3 TOC file (nav.xhtml). Since this is
47 | // an XHTML file, the rest of the structure is handled by the xhtml type
48 | //
49 | // Sample: https://github.com/bmaupin/epub-samples/blob/master/minimal-v3plus2/EPUB/nav.xhtml
50 | // Spec: http://www.idpf.org/epub/301/spec/epub-contentdocs.html#sec-xhtml-nav
51 | navXML *tocNavBody
52 |
53 | // This holds the XML for the EPUB v2 TOC file (toc.ncx). This is added so the
54 | // resulting EPUB v3 file will still work with devices that only support EPUB v2
55 | //
56 | // Sample: https://github.com/bmaupin/epub-samples/blob/master/minimal-v3plus2/EPUB/toc.ncx
57 | // Spec: http://www.idpf.org/epub/20/spec/OPF_2.0.1_draft.htm#Section2.4.1
58 | ncxXML *tocNcxRoot
59 |
60 | title string // EPUB title
61 | author string // EPUB author
62 | }
63 |
64 | type tocNavBody struct {
65 | XMLName xml.Name `xml:"nav"`
66 | EpubType string `xml:"epub:type,attr"`
67 | H1 string `xml:"h1"`
68 | Links []tocNavItem `xml:"ol>li"`
69 | }
70 |
71 | type tocNavItem struct {
72 | A tocNavLink `xml:"a"`
73 | Children *[]tocNavItem `xml:"ol>li,omitempty"`
74 | }
75 |
76 | type tocNavLink struct {
77 | XMLName xml.Name `xml:"a"`
78 | Href string `xml:"href,attr"`
79 | Data string `xml:",chardata"`
80 | }
81 |
82 | type tocNcxRoot struct {
83 | XMLName xml.Name `xml:"http://www.daisy.org/z3986/2005/ncx/ ncx"`
84 | Version string `xml:"version,attr"`
85 | Meta tocNcxMeta `xml:"head>meta"`
86 | Title string `xml:"docTitle>text"`
87 | Author string `xml:"docAuthor>text"`
88 | NavMap []tocNcxNavPoint `xml:"navMap>navPoint"`
89 | }
90 |
91 | type tocNcxContent struct {
92 | Src string `xml:"src,attr"`
93 | }
94 |
95 | type tocNcxMeta struct {
96 | Name string `xml:"name,attr"`
97 | Content string `xml:"content,attr"`
98 | }
99 |
100 | type tocNcxNavPoint struct {
101 | XMLName xml.Name `xml:"navPoint"`
102 | ID string `xml:"id,attr"`
103 | Text string `xml:"navLabel>text"`
104 | Content tocNcxContent `xml:"content"`
105 | Children *[]tocNcxNavPoint `xml:"navPoint,omitempty"`
106 | }
107 |
108 | // Constructor for toc
109 | func newToc() *toc {
110 | t := &toc{}
111 |
112 | t.navXML = newTocNavXML()
113 |
114 | t.ncxXML = newTocNcxXML()
115 |
116 | return t
117 | }
118 |
119 | // Constructor for tocNavBody
120 | func newTocNavXML() *tocNavBody {
121 | b := &tocNavBody{
122 | EpubType: tocNavEpubType,
123 | }
124 | err := xml.Unmarshal([]byte(tocNavBodyTemplate), &b)
125 | if err != nil {
126 | panic(fmt.Sprintf(
127 | "Error unmarshalling tocNavBody: %s\n"+
128 | "\ttocNavBody=%#v\n"+
129 | "\ttocNavBodyTemplate=%s",
130 | err,
131 | *b,
132 | tocNavBodyTemplate))
133 | }
134 |
135 | return b
136 | }
137 |
138 | // Constructor for tocNcxRoot
139 | func newTocNcxXML() *tocNcxRoot {
140 | n := &tocNcxRoot{}
141 |
142 | err := xml.Unmarshal([]byte(tocNcxTemplate), &n)
143 | if err != nil {
144 | panic(fmt.Sprintf(
145 | "Error unmarshalling tocNcxRoot: %s\n"+
146 | "\ttocNcxRoot=%#v\n"+
147 | "\ttocNcxTemplate=%s",
148 | err,
149 | *n,
150 | tocNcxTemplate))
151 | }
152 |
153 | return n
154 | }
155 |
156 | // Add a section to the TOC (navXML as well as ncxXML)
157 | func (t *toc) addSection(index int, title string, relativePath string) {
158 | relativePath = filepath.ToSlash(relativePath)
159 | l := &tocNavItem{
160 | A: tocNavLink{
161 | Href: relativePath,
162 | Data: title,
163 | },
164 | Children: nil,
165 | }
166 | t.navXML.Links = append(t.navXML.Links, *l)
167 |
168 | np := &tocNcxNavPoint{
169 | ID: "navPoint-" + strconv.Itoa(index),
170 | Text: title,
171 | Content: tocNcxContent{
172 | Src: relativePath,
173 | },
174 | Children: nil,
175 | }
176 | t.ncxXML.NavMap = append(t.ncxXML.NavMap, *np)
177 | }
178 |
179 | // Add a sub section to the TOC (navXML as well as ncxXML)
180 | func (t *toc) addSubSection(parent string, index int, title string, relativePath string) {
181 | var parentNcxIndex int
182 | var parentNavIndex int
183 |
184 | relativePath = filepath.ToSlash(relativePath)
185 | parent = filepath.ToSlash(parent)
186 |
187 | for index, nav := range t.navXML.Links {
188 | if nav.A.Href == parent {
189 | parentNavIndex = index
190 | }
191 | }
192 | l := tocNavItem{
193 | A: tocNavLink{
194 | Href: relativePath,
195 | Data: title,
196 | },
197 | }
198 | if len(t.navXML.Links) > parentNavIndex {
199 | // Create a new array if none exists
200 | if t.navXML.Links[parentNavIndex].Children == nil {
201 | n := make([]tocNavItem, 0)
202 | t.navXML.Links[parentNavIndex].Children = &n
203 | }
204 | children := append(*t.navXML.Links[parentNavIndex].Children, l)
205 | t.navXML.Links[parentNavIndex].Children = &children
206 | } else {
207 | t.navXML.Links = append(t.navXML.Links, l)
208 | }
209 |
210 | // Get parent object
211 | for index, ncx := range t.ncxXML.NavMap {
212 | if ncx.Content.Src == parent {
213 | parentNcxIndex = index
214 | }
215 | }
216 | np := tocNcxNavPoint{
217 | ID: "navPoint-" + strconv.Itoa(index),
218 | Text: title,
219 | Content: tocNcxContent{
220 | Src: relativePath,
221 | },
222 | Children: nil,
223 | }
224 | if parentNcxIndex > len(t.ncxXML.NavMap) {
225 | if t.ncxXML.NavMap[parentNcxIndex].Children == nil {
226 | n := make([]tocNcxNavPoint, 0)
227 | t.ncxXML.NavMap[parentNcxIndex].Children = &n
228 | }
229 | children := append(*t.ncxXML.NavMap[parentNcxIndex].Children, np)
230 | t.ncxXML.NavMap[parentNcxIndex].Children = &children
231 | } else {
232 | t.ncxXML.NavMap = append(t.ncxXML.NavMap, np)
233 | }
234 | }
235 |
236 | func (t *toc) setIdentifier(identifier string) {
237 | t.ncxXML.Meta.Content = identifier
238 | }
239 |
240 | func (t *toc) setTitle(title string) {
241 | t.title = title
242 | }
243 |
244 | func (t *toc) setAuthor(author string) {
245 | t.author = author
246 | }
247 |
248 | // Write the TOC files
249 | func (t *toc) write(tempDir string) {
250 | t.writeNavDoc(tempDir)
251 | t.writeNcxDoc(tempDir)
252 | }
253 |
254 | // Write the the EPUB v3 TOC file (nav.xhtml) to the temporary directory
255 | func (t *toc) writeNavDoc(tempDir string) {
256 | navBodyContent, err := xml.MarshalIndent(t.navXML, " ", " ")
257 | if err != nil {
258 | panic(fmt.Sprintf(
259 | "Error marshalling XML for EPUB v3 TOC file: %s\n"+
260 | "\tXML=%#v",
261 | err,
262 | t.navXML))
263 | }
264 |
265 | n := newXhtml(string(navBodyContent))
266 | n.setXmlnsEpub(xmlnsEpub)
267 | n.setTitle(t.title)
268 |
269 | navFilePath := filepath.Join(tempDir, contentFolderName, tocNavFilename)
270 | n.write(navFilePath)
271 | }
272 |
273 | // Write the EPUB v2 TOC file (toc.ncx) to the temporary directory
274 | func (t *toc) writeNcxDoc(tempDir string) {
275 | t.ncxXML.Title = t.title
276 | t.ncxXML.Author = t.author
277 |
278 | ncxFileContent, err := xml.MarshalIndent(t.ncxXML, "", " ")
279 | if err != nil {
280 | panic(fmt.Sprintf(
281 | "Error marshalling XML for EPUB v2 TOC file: %s\n"+
282 | "\tXML=%#v",
283 | err,
284 | t.ncxXML))
285 | }
286 |
287 | // Add the xml header to the output
288 | ncxFileContent = append([]byte(xml.Header), ncxFileContent...)
289 | // It's generally nice to have files end with a newline
290 | ncxFileContent = append(ncxFileContent, "\n"...)
291 |
292 | ncxFilePath := filepath.Join(tempDir, contentFolderName, tocNcxFilename)
293 | if err := filesystem.WriteFile(ncxFilePath, []byte(ncxFileContent), filePermissions); err != nil {
294 | panic(fmt.Sprintf("Error writing EPUB v2 TOC file: %s", err))
295 | }
296 | }
297 |
--------------------------------------------------------------------------------
/pkg/epub/pkg.go:
--------------------------------------------------------------------------------
1 | package epub
2 |
3 | import (
4 | "encoding/xml"
5 | "fmt"
6 | "path/filepath"
7 | "time"
8 | )
9 |
10 | const (
11 | pkgAuthorID = "role"
12 | pkgAuthorData = "aut"
13 | pkgAuthorProperty = "role"
14 | pkgAuthorRefines = "#creator"
15 | pkgAuthorScheme = "marc:relators"
16 | pkgCreatorID = "creator"
17 | pkgFileTemplate = `
18 |
19 |
20 |
25 |
26 |
27 |
28 |
29 |
30 | `
31 | pkgModifiedProperty = "dcterms:modified"
32 | pkgUniqueIdentifier = "pub-id"
33 |
34 | xmlnsDc = "http://purl.org/dc/elements/1.1/"
35 | )
36 |
37 | // pkg implements the package document file (package.opf), which contains
38 | // metadata about the EPUB (title, author, etc) as well as a list of files the
39 | // EPUB contains.
40 | //
41 | // Sample: https://github.com/bmaupin/epub-samples/blob/master/minimal-v3plus2/EPUB/package.opf
42 | // Spec: http://www.idpf.org/epub/301/spec/epub-publications.html
43 | type pkg struct {
44 | xml *pkgRoot
45 | authorMeta *pkgMeta
46 | coverMeta *pkgMeta
47 | modifiedMeta *pkgMeta
48 | }
49 |
50 | // This holds the actual XML for the package file
51 | type pkgRoot struct {
52 | XMLName xml.Name `xml:"http://www.idpf.org/2007/opf package"`
53 | UniqueIdentifier string `xml:"unique-identifier,attr"`
54 | Version string `xml:"version,attr"`
55 | Metadata pkgMetadata `xml:"metadata"`
56 | ManifestItems []pkgItem `xml:"manifest>item"`
57 | Spine pkgSpine `xml:"spine"`
58 | }
59 |
60 | // , e.g. the author
61 | type pkgCreator struct {
62 | XMLName xml.Name `xml:"dc:creator"`
63 | ID string `xml:"id,attr"`
64 | Data string `xml:",chardata"`
65 | }
66 |
67 | // , where the unique identifier is stored
68 | // Ex: urn:uuid:fe93046f-af57-475a-a0cb-a0d4bc99ba6d
69 | type pkgIdentifier struct {
70 | ID string `xml:"id,attr"`
71 | Data string `xml:",chardata"`
72 | }
73 |
74 | // - elements, one per each file stored in the EPUB
75 | // Ex:
elements, which define the reading order
87 | // Ex: element
108 | type pkgMetadata struct {
109 | XmlnsDc string `xml:"xmlns:dc,attr"`
110 | Identifier pkgIdentifier `xml:"dc:identifier"`
111 | // Ex: Your title here
112 | Title string `xml:"dc:title"`
113 | // Ex: en
114 | Language string `xml:"dc:language"`
115 | Description string `xml:"dc:description,omitempty"`
116 | Creator *pkgCreator
117 | Meta []pkgMeta `xml:"meta"`
118 | }
119 |
120 | // The element
121 | type pkgSpine struct {
122 | Items []pkgItemref `xml:"itemref"`
123 | Toc string `xml:"toc,attr"`
124 | Ppd string `xml:"page-progression-direction,attr,omitempty"`
125 | }
126 |
127 | // Constructor for pkg
128 | func newPackage() *pkg {
129 | p := &pkg{
130 | xml: &pkgRoot{
131 | Metadata: pkgMetadata{
132 | XmlnsDc: xmlnsDc,
133 | Identifier: pkgIdentifier{
134 | ID: pkgUniqueIdentifier,
135 | },
136 | },
137 | },
138 | }
139 |
140 | err := xml.Unmarshal([]byte(pkgFileTemplate), &p.xml)
141 | if err != nil {
142 | panic(fmt.Sprintf(
143 | "Error unmarshalling package file XML: %s\n"+
144 | "\tp.xml=%#v\n"+
145 | "\tpkgFileTemplate=%s",
146 | err,
147 | *p.xml,
148 | pkgFileTemplate))
149 | }
150 |
151 | return p
152 | }
153 |
154 | func (p *pkg) addToManifest(id string, href string, mediaType string, properties string) {
155 | href = filepath.ToSlash(href)
156 | i := &pkgItem{
157 | ID: id,
158 | Href: href,
159 | MediaType: mediaType,
160 | Properties: properties,
161 | }
162 | p.xml.ManifestItems = append(p.xml.ManifestItems, *i)
163 | }
164 |
165 | func (p *pkg) addToSpine(id string) {
166 | i := &pkgItemref{
167 | Idref: id,
168 | }
169 |
170 | p.xml.Spine.Items = append(p.xml.Spine.Items, *i)
171 | }
172 |
173 | func (p *pkg) setAuthor(author string) {
174 | p.xml.Metadata.Creator = &pkgCreator{
175 | Data: author,
176 | ID: pkgCreatorID,
177 | }
178 | p.authorMeta = &pkgMeta{
179 | Data: pkgAuthorData,
180 | ID: pkgAuthorID,
181 | Property: pkgAuthorProperty,
182 | Refines: pkgAuthorRefines,
183 | Scheme: pkgAuthorScheme,
184 | }
185 |
186 | p.xml.Metadata.Meta = updateMeta(p.xml.Metadata.Meta, p.authorMeta)
187 | }
188 |
189 | // Add an EPUB 2 cover meta element for backward compatibility (http://idpf.org/forum/topic-715)
190 | func (p *pkg) setCover(coverRef string) {
191 | p.coverMeta = &pkgMeta{
192 | Name: "cover",
193 | Content: coverRef,
194 | }
195 | p.xml.Metadata.Meta = updateMeta(p.xml.Metadata.Meta, p.coverMeta)
196 | }
197 |
198 | func (p *pkg) setIdentifier(identifier string) {
199 | p.xml.Metadata.Identifier.Data = identifier
200 | }
201 |
202 | func (p *pkg) setLang(lang string) {
203 | p.xml.Metadata.Language = lang
204 | }
205 |
206 | func (p *pkg) setDescription(desc string) {
207 | p.xml.Metadata.Description = desc
208 | }
209 |
210 | func (p *pkg) setPpd(direction string) {
211 | p.xml.Spine.Ppd = direction
212 | }
213 |
214 | func (p *pkg) setModified(timestamp string) {
215 | p.modifiedMeta = &pkgMeta{
216 | Data: timestamp,
217 | Property: pkgModifiedProperty,
218 | }
219 |
220 | p.xml.Metadata.Meta = updateMeta(p.xml.Metadata.Meta, p.modifiedMeta)
221 | }
222 |
223 | func (p *pkg) setTitle(title string) {
224 | p.xml.Metadata.Title = title
225 | }
226 |
227 | // Update the
30 |
31 |
33 |
34 | `
35 | // This seems to be the standard based on the latest EPUB spec:
36 | // http://www.idpf.org/epub/31/spec/epub-ocf.html
37 | contentFolderName = "EPUB"
38 | coverImageProperties = "cover-image"
39 | // Permissions for any new directories we create
40 | dirPermissions = 0755
41 | // Permissions for any new files we create
42 | filePermissions = 0644
43 | mediaTypeCSS = "text/css"
44 | mediaTypeEpub = "application/epub+zip"
45 | mediaTypeJpeg = "image/jpeg"
46 | mediaTypeNcx = "application/x-dtbncx+xml"
47 | mediaTypeXhtml = "application/xhtml+xml"
48 | metaInfFolderName = "META-INF"
49 | mimetypeFilename = "mimetype"
50 | pkgFilename = "package.opf"
51 | tempDirPrefix = "go-epub"
52 | xhtmlFolderName = "xhtml"
53 | )
54 |
55 | // WriteTo the dest io.Writer. The return value is the number of bytes written. Any error encountered during the write is also returned.
56 | func (e *Epub) WriteTo(dst io.Writer) (int64, error) {
57 | e.Lock()
58 | defer e.Unlock()
59 | tempDir := uuid.Must(uuid.NewV4()).String()
60 |
61 | err := filesystem.Mkdir(tempDir, dirPermissions)
62 | if err != nil {
63 | panic(fmt.Sprintf("Error creating temp directory: %s", err))
64 | }
65 | defer func() {
66 | if err := filesystem.RemoveAll(tempDir); err != nil {
67 | panic(fmt.Sprintf("Error removing temp directory: %s", err))
68 | }
69 | }()
70 | writeMimetype(tempDir)
71 | createEpubFolders(tempDir)
72 |
73 | // Must be called after:
74 | // createEpubFolders()
75 | writeContainerFile(tempDir)
76 |
77 | // Must be called after:
78 | // createEpubFolders()
79 | err = e.writeCSSFiles(tempDir)
80 | if err != nil {
81 | return 0, err
82 | }
83 |
84 | // Must be called after:
85 | // createEpubFolders()
86 | err = e.writeFonts(tempDir)
87 | if err != nil {
88 | return 0, err
89 | }
90 |
91 | // Must be called after:
92 | // createEpubFolders()
93 | err = e.writeImages(tempDir)
94 | if err != nil {
95 | return 0, err
96 | }
97 |
98 | // Must be called after:
99 | // createEpubFolders()
100 | err = e.writeVideos(tempDir)
101 | if err != nil {
102 | return 0, err
103 | }
104 |
105 | // Must be called after:
106 | // createEpubFolders()
107 | e.writeSections(tempDir)
108 |
109 | // Must be called after:
110 | // createEpubFolders()
111 | // writeSections()
112 | e.writeToc(tempDir)
113 |
114 | // Must be called after:
115 | // createEpubFolders()
116 | // writeCSSFiles()
117 | // writeImages()
118 | // writeVideos()
119 | // writeSections()
120 | // writeToc()
121 | e.writePackageFile(tempDir)
122 | // Must be called last
123 | return e.writeEpub(tempDir, dst)
124 | }
125 |
126 | // Write writes the EPUB file. The destination path must be the full path to
127 | // the resulting file, including filename and extension.
128 | // The result is always writen to the local filesystem even if the underlying storage is in memory.
129 | func (e *Epub) Write(destFilePath string) error {
130 |
131 | f, err := os.Create(destFilePath)
132 | if err != nil {
133 | return &UnableToCreateEpubError{
134 | Path: destFilePath,
135 | Err: err,
136 | }
137 | }
138 | defer f.Close()
139 | _, err = e.WriteTo(f)
140 | return err
141 | }
142 |
143 | // Create the EPUB folder structure in a temp directory
144 | func createEpubFolders(rootEpubDir string) {
145 | if err := filesystem.Mkdir(
146 | filepath.Join(
147 | rootEpubDir,
148 | contentFolderName,
149 | ),
150 | dirPermissions); err != nil {
151 | // No reason this should happen if tempDir creation was successful
152 | panic(fmt.Sprintf("Error creating EPUB subdirectory: %s", err))
153 | }
154 |
155 | if err := filesystem.Mkdir(
156 | filepath.Join(
157 | rootEpubDir,
158 | contentFolderName,
159 | xhtmlFolderName,
160 | ),
161 | dirPermissions); err != nil {
162 | panic(fmt.Sprintf("Error creating xhtml subdirectory: %s", err))
163 | }
164 |
165 | if err := filesystem.Mkdir(
166 | filepath.Join(
167 | rootEpubDir,
168 | metaInfFolderName,
169 | ),
170 | dirPermissions); err != nil {
171 | panic(fmt.Sprintf("Error creating META-INF subdirectory: %s", err))
172 | }
173 | }
174 |
175 | // Write the contatiner file (container.xml), which mostly just points to the
176 | // package file (package.opf)
177 | //
178 | // Sample: https://github.com/bmaupin/epub-samples/blob/master/minimal-v3plus2/META-INF/container.xml
179 | // Spec: http://www.idpf.org/epub/301/spec/epub-ocf.html#sec-container-metainf-container.xml
180 | func writeContainerFile(rootEpubDir string) {
181 | containerFilePath := filepath.Join(rootEpubDir, metaInfFolderName, containerFilename)
182 | if err := filesystem.WriteFile(
183 | containerFilePath,
184 | []byte(
185 | fmt.Sprintf(
186 | containerFileTemplate,
187 | contentFolderName,
188 | pkgFilename,
189 | ),
190 | ),
191 | filePermissions,
192 | ); err != nil {
193 | panic(fmt.Sprintf("Error writing container file: %s", err))
194 | }
195 | }
196 |
197 | // Write the CSS files to the temporary directory and add them to the package
198 | // file
199 | func (e *Epub) writeCSSFiles(rootEpubDir string) error {
200 | err := e.writeMedia(rootEpubDir, e.css, CSSFolderName)
201 | if err != nil {
202 | return err
203 | }
204 |
205 | // Clean up the cover temp file if one was created
206 | os.Remove(e.cover.cssTempFile)
207 |
208 | return nil
209 | }
210 |
211 | // writeCounter counts the number of bytes written to it.
212 | type writeCounter struct {
213 | Total int64 // Total # of bytes written
214 | }
215 |
216 | // Write implements the io.Writer interface.
217 | // Always completes and never returns an error.
218 | func (wc *writeCounter) Write(p []byte) (int, error) {
219 | n := len(p)
220 | wc.Total += int64(n)
221 | return n, nil
222 | }
223 |
224 | // Write the EPUB file itself by zipping up everything from a temp directory
225 | // The return value is the number of bytes written. Any error encountered during the write is also returned.
226 | func (e *Epub) writeEpub(rootEpubDir string, dst io.Writer) (int64, error) {
227 | counter := &writeCounter{}
228 | teeWriter := io.MultiWriter(counter, dst)
229 |
230 | z := zip.NewWriter(teeWriter)
231 |
232 | skipMimetypeFile := false
233 |
234 | // addFileToZip adds the file present at path to the zip archive. The path is relative to the rootEpubDir
235 | addFileToZip := func(path string, d fs.DirEntry, err error) error {
236 | if err != nil {
237 | return err
238 | }
239 |
240 | // Get the path of the file relative to the folder we're zipping
241 | relativePath, err := filepath.Rel(rootEpubDir, path)
242 | if err != nil {
243 | // tempDir and path are both internal, so we shouldn't get here
244 | return err
245 | }
246 | relativePath = filepath.ToSlash(relativePath)
247 |
248 | // Only include regular files, not directories
249 | info, err := d.Info()
250 | if err != nil {
251 | return err
252 | }
253 | if !info.Mode().IsRegular() {
254 | return nil
255 | }
256 |
257 | var w io.Writer
258 | if filepath.FromSlash(path) == filepath.Join(rootEpubDir, mimetypeFilename) {
259 | // Skip the mimetype file if it's already been written
260 | if skipMimetypeFile == true {
261 | return nil
262 | }
263 | // The mimetype file must be uncompressed according to the EPUB spec
264 | w, err = z.CreateHeader(&zip.FileHeader{
265 | Name: relativePath,
266 | Method: zip.Store,
267 | })
268 | } else {
269 | w, err = z.Create(relativePath)
270 | }
271 | if err != nil {
272 | return fmt.Errorf("error creating zip writer: %w", err)
273 | }
274 |
275 | r, err := filesystem.Open(path)
276 | if err != nil {
277 | return fmt.Errorf("error opening file %v being added to EPUB: %w", path, err)
278 | }
279 | defer func() {
280 | if err := r.Close(); err != nil {
281 | panic(err)
282 | }
283 | }()
284 |
285 | _, err = io.Copy(w, r)
286 | if err != nil {
287 | return fmt.Errorf("error copying contents of file being added EPUB: %w", err)
288 | }
289 | return nil
290 | }
291 |
292 | // Add the mimetype file first
293 | mimetypeFilePath := filepath.Join(rootEpubDir, mimetypeFilename)
294 | mimetypeInfo, err := fs.Stat(filesystem, mimetypeFilePath)
295 | if err != nil {
296 | if err := z.Close(); err != nil {
297 | panic(err)
298 | }
299 | return counter.Total, fmt.Errorf("unable to get FileInfo for mimetype file: %w", err)
300 | }
301 | err = addFileToZip(mimetypeFilePath, fileInfoToDirEntry(mimetypeInfo), nil)
302 | if err != nil {
303 | if err := z.Close(); err != nil {
304 | panic(err)
305 | }
306 | return counter.Total, fmt.Errorf("unable to add mimetype file to EPUB: %w", err)
307 | }
308 |
309 | skipMimetypeFile = true
310 |
311 | err = fs.WalkDir(filesystem, rootEpubDir, addFileToZip)
312 | if err != nil {
313 | if err := z.Close(); err != nil {
314 | panic(err)
315 | }
316 | return counter.Total, fmt.Errorf("unable to add file to EPUB: %w", err)
317 | }
318 |
319 | err = z.Close()
320 | return counter.Total, err
321 | }
322 |
323 | // Get fonts from their source and save them in the temporary directory
324 | func (e *Epub) writeFonts(rootEpubDir string) error {
325 | return e.writeMedia(rootEpubDir, e.fonts, FontFolderName)
326 | }
327 |
328 | // Get images from their source and save them in the temporary directory
329 | func (e *Epub) writeImages(rootEpubDir string) error {
330 | return e.writeMedia(rootEpubDir, e.images, ImageFolderName)
331 | }
332 |
333 | // Get videos from their source and save them in the temporary directory
334 | func (e *Epub) writeVideos(rootEpubDir string) error {
335 | return e.writeMedia(rootEpubDir, e.videos, VideoFolderName)
336 | }
337 |
338 | // Get media from their source and save them in the temporary directory
339 | func (e *Epub) writeMedia(rootEpubDir string, mediaMap map[string]string, mediaFolderName string) error {
340 | if len(mediaMap) > 0 {
341 | mediaFolderPath := filepath.Join(rootEpubDir, contentFolderName, mediaFolderName)
342 | if err := filesystem.Mkdir(mediaFolderPath, dirPermissions); err != nil {
343 | return fmt.Errorf("unable to create directory: %s", err)
344 | }
345 |
346 | for mediaFilename, mediaSource := range mediaMap {
347 | mediaType, err := grabber{(e.Client)}.fetchMedia(mediaSource, mediaFolderPath, mediaFilename)
348 | if err != nil {
349 | return err
350 | }
351 | // The cover image has a special value for the properties attribute
352 | mediaProperties := ""
353 | if mediaFilename == e.cover.imageFilename {
354 | mediaProperties = coverImageProperties
355 | }
356 |
357 | // Add the file to the OPF manifest
358 | e.pkg.addToManifest(fixXMLId(mediaFilename), filepath.Join(mediaFolderName, mediaFilename), mediaType, mediaProperties)
359 | }
360 | }
361 | return nil
362 | }
363 |
364 | // fixXMLId takes a string and returns an XML id compatible string.
365 | // https://www.w3.org/TR/REC-xml-names/#NT-NCName
366 | // This means it must not contain a colon (:) or whitespace and it must not
367 | // start with a digit, punctuation or diacritics
368 | func fixXMLId(id string) string {
369 | if len(id) == 0 {
370 | panic("No id given")
371 | }
372 | fixedId := []rune{}
373 | for i := 0; len(id) > 0; i++ {
374 | r, size := utf8.DecodeRuneInString(id)
375 | if i == 0 {
376 | // The new id should be prefixed with 'id' if an invalid
377 | // starting character is found
378 | // this is not 100% accurate, but a better check than no check
379 | if unicode.IsNumber(r) || unicode.IsPunct(r) || unicode.IsSymbol(r) {
380 | fixedId = append(fixedId, []rune("id")...)
381 | }
382 | }
383 | if !unicode.IsSpace(r) && r != ':' {
384 | fixedId = append(fixedId, r)
385 | }
386 | id = id[size:]
387 | }
388 | return string(fixedId)
389 | }
390 |
391 | // Write the mimetype file
392 | //
393 | // Sample: https://github.com/bmaupin/epub-samples/blob/master/minimal-v3plus2/mimetype
394 | // Spec: http://www.idpf.org/epub/301/spec/epub-ocf.html#sec-zip-container-mime
395 | func writeMimetype(rootEpubDir string) {
396 | mimetypeFilePath := filepath.Join(rootEpubDir, mimetypeFilename)
397 |
398 | if err := filesystem.WriteFile(mimetypeFilePath, []byte(mediaTypeEpub), filePermissions); err != nil {
399 | panic(fmt.Sprintf("Error writing mimetype file: %s", err))
400 | }
401 | }
402 |
403 | func (e *Epub) writePackageFile(rootEpubDir string) {
404 | e.pkg.write(rootEpubDir)
405 | }
406 |
407 | // Write the section files to the temporary directory and add the sections to
408 | // the TOC and package files
409 | func (e *Epub) writeSections(rootEpubDir string) {
410 | var index int
411 |
412 | if len(e.sections) > 0 {
413 | // If a cover was set, add it to the package spine first so it shows up
414 | // first in the reading order
415 | if e.cover.xhtmlFilename != "" {
416 | e.pkg.addToSpine(e.cover.xhtmlFilename)
417 | }
418 |
419 | for _, section := range e.sections {
420 | // Set the title of the cover page XHTML to the title of the EPUB
421 | if section.filename == e.cover.xhtmlFilename {
422 | section.xhtml.setTitle(e.Title())
423 | }
424 |
425 | sectionFilePath := filepath.Join(rootEpubDir, contentFolderName, xhtmlFolderName, section.filename)
426 | section.xhtml.write(sectionFilePath)
427 | relativePath := filepath.Join(xhtmlFolderName, section.filename)
428 |
429 | // The cover page should have already been added to the spine first
430 | if section.filename != e.cover.xhtmlFilename {
431 | e.pkg.addToSpine(section.filename)
432 | }
433 | e.pkg.addToManifest(section.filename, relativePath, mediaTypeXhtml, "")
434 |
435 | // Don't add pages without titles or the cover to the TOC
436 | if section.xhtml.Title() != "" && section.filename != e.cover.xhtmlFilename {
437 | e.toc.addSection(index, section.xhtml.Title(), relativePath)
438 |
439 | // Add subsections
440 | if section.children != nil {
441 | for _, child := range *section.children {
442 | index += 1
443 | relativeSubPath := filepath.Join(xhtmlFolderName, child.filename)
444 | e.toc.addSubSection(relativePath, index, child.xhtml.Title(), relativeSubPath)
445 |
446 | subSectionFilePath := filepath.Join(rootEpubDir, contentFolderName, xhtmlFolderName, child.filename)
447 | child.xhtml.write(subSectionFilePath)
448 |
449 | // Add subsection to spine
450 | e.pkg.addToSpine(child.filename)
451 | e.pkg.addToManifest(child.filename, relativeSubPath, mediaTypeXhtml, "")
452 | }
453 | }
454 | }
455 |
456 | index += 1
457 | }
458 | }
459 | }
460 |
461 | // Write the TOC file to the temporary directory and add the TOC entries to the
462 | // package file
463 | func (e *Epub) writeToc(rootEpubDir string) {
464 | e.pkg.addToManifest(tocNavItemID, tocNavFilename, mediaTypeXhtml, tocNavItemProperties)
465 | e.pkg.addToManifest(tocNcxItemID, tocNcxFilename, mediaTypeNcx, "")
466 |
467 | e.toc.write(rootEpubDir)
468 | }
469 |
--------------------------------------------------------------------------------
/pkg/epub/epub.go:
--------------------------------------------------------------------------------
1 | /*
2 | Package epub generates valid EPUB 3.0 files with additional EPUB 2.0 table of
3 | contents (as seen here: https://github.com/bmaupin/epub-samples) for maximum
4 | compatibility.
5 |
6 | Basic usage:
7 |
8 | // Create a new EPUB
9 | e := epub.NewEpub("My title")
10 |
11 | // Set the author
12 | e.SetAuthor("Hingle McCringleberry")
13 |
14 | // Add a section
15 | section1Body := `Section 1
16 | This is a paragraph.
`
17 | e.AddSection(section1Body, "Section 1", "", "")
18 |
19 | // Write the EPUB
20 | err = e.Write("My EPUB.epub")
21 | if err != nil {
22 | // handle error
23 | }
24 | */
25 | package epub
26 |
27 | import (
28 | "fmt"
29 | "io/fs"
30 | "net/http"
31 | "os"
32 | "path"
33 | "path/filepath"
34 | "strings"
35 | "sync"
36 |
37 | // TODO: Eventually this should include the major version (e.g. github.com/gofrs/uuid/v3) but that would break
38 | // compatibility with Go < 1.9 (https://github.com/golang/go/wiki/Modules#semantic-import-versioning)
39 | "github.com/gofrs/uuid"
40 | "github.com/vincent-petithory/dataurl"
41 | )
42 |
43 | // FilenameAlreadyUsedError is thrown by AddCSS, AddFont, AddImage, or AddSection
44 | // if the same filename is used more than once.
45 | type FilenameAlreadyUsedError struct {
46 | Filename string // Filename that caused the error
47 | }
48 |
49 | func (e *FilenameAlreadyUsedError) Error() string {
50 | return fmt.Sprintf("Filename already used: %s", e.Filename)
51 | }
52 |
53 | // FileRetrievalError is thrown by AddCSS, AddFont, AddImage, or Write if there was a
54 | // problem retrieving the source file that was provided.
55 | type FileRetrievalError struct {
56 | Source string // The source of the file whose retrieval failed
57 | Err error // The underlying error that was thrown
58 | }
59 |
60 | func (e *FileRetrievalError) Error() string {
61 | return fmt.Sprintf("Error retrieving %q from source: %+v", e.Source, e.Err)
62 | }
63 |
64 | // ParentDoesNotExistError is thrown by AddSubSection if the parent with the
65 | // previously defined internal filename does not exist.
66 | type ParentDoesNotExistError struct {
67 | Filename string // Filename that caused the error
68 | }
69 |
70 | func (e *ParentDoesNotExistError) Error() string {
71 | return fmt.Sprintf("Parent with the internal filename %s does not exist", e.Filename)
72 | }
73 |
74 | // Folder names used for resources inside the EPUB
75 | const (
76 | CSSFolderName = "css"
77 | FontFolderName = "fonts"
78 | ImageFolderName = "images"
79 | VideoFolderName = "videos"
80 | )
81 |
82 | const (
83 | cssFileFormat = "css%04d%s"
84 | defaultCoverBody = ` 
3 | 
4 | 
81 |
82 |