Add VoidScans

PythonCoderAS · PythonCoderAS · commit e9e27c27d43c · 2021-04-03T18:26:53.000-04:00
diff --git a/README.md b/README.md
@@ -3,4 +3,5 @@ Sources for small scanlation sites.
 
 # Websites
 * https://glitchycomics.com/
-* https://rainofsnow.com/
+* https://rainofsnow.com/
+* https://voidscans.net/
diff --git a/src/VoidScans/VoidScans.ts b/src/VoidScans/VoidScans.ts
@@ -0,0 +1,119 @@
+import {
+    Chapter,
+    ChapterDetails,
+    HomeSection,
+    Manga, MangaTile,
+    PagedResults,
+    Request,
+    SearchRequest,
+    Source,
+    SourceInfo,
+} from "paperback-extensions-common"
+import {VoidScansParser} from "./VoidScansParser";
+
+const BASE = "https://voidscans.net"
+
+export const VoidScansInfo: SourceInfo = {
+    icon: "icon.png",
+    version: "1.1.0",
+    name: "VoidScans",
+    author: "PythonCoderAS",
+    authorWebsite: "https://github.com/PythonCoderAS",
+    description: "Extension that pulls manga from VoidScans",
+    language: "en",
+    hentaiSource: false,
+    websiteBaseURL: BASE
+}
+
+export class VoidScans extends Source {
+
+    private readonly parser: VoidScansParser = new VoidScansParser();
+
+    getMangaShareUrl(mangaId: string): string | null {
+        return `${BASE}/library/${mangaId}`;
+    }
+
+    async getHomePageSections(sectionCallback: (section: HomeSection) => void): Promise<void> {
+        sectionCallback(createHomeSection({
+            id: "1",
+            items: (await this.getWebsiteMangaDirectory(null)).results,
+            title: "All Manga"
+        }));
+    }
+
+    async getWebsiteMangaDirectory(metadata: any): Promise<PagedResults> {
+        const options: Request = createRequestObject({
+            url: `${BASE}/library`,
+            method: 'GET'
+        });
+        let response = await this.requestManager.schedule(options, 1);
+        let $ = this.cheerio.load(response.data);
+        return createPagedResults({
+            results: this.parser.parseMangaList($, BASE)
+        });
+    }
+
+    async getChapterPage(mangaId: string, chapterId: string, page: number = 1): Promise<string | null>{
+        const options: Request = createRequestObject({
+            url: `${BASE}/read/${mangaId}/${chapterId}/${page}`,
+            method: 'GET'
+        });
+        let response = await this.requestManager.schedule(options, 1);
+        let $ = this.cheerio.load(response.data);
+        return this.parser.parsePage($)
+    }
+
+    async getChapterDetails(mangaId: string, chapterId: string): Promise<ChapterDetails> {
+        const pages: string[] = [];
+        let page = await this.getChapterPage(mangaId, chapterId);
+        let num = 2;
+        while (page){
+            pages.push(page)
+            page = await this.getChapterPage(mangaId, chapterId, num);
+            num++;
+        }
+        return createChapterDetails({
+            id: chapterId,
+            longStrip: true,
+            mangaId: mangaId,
+            pages: pages
+        })
+    }
+
+    async getChapters(mangaId: string): Promise<Chapter[]> {
+        const options: Request = createRequestObject({
+            url: `${BASE}/library/${mangaId}`,
+            method: 'GET'
+        });
+        let response = await this.requestManager.schedule(options, 1);
+        let $ = this.cheerio.load(response.data);
+        return this.parser.parseChapterList($, mangaId);
+    }
+
+    async getMangaDetails(mangaId: string): Promise<Manga> {
+        const options: Request = createRequestObject({
+            url: `${BASE}/library/${mangaId}`,
+            method: 'GET'
+        });
+        let response = await this.requestManager.schedule(options, 1);
+        let $ = this.cheerio.load(response.data);
+        return this.parser.parseManga($, mangaId);
+    }
+
+    async searchRequest(query: SearchRequest, metadata: any): Promise<PagedResults> {
+        // TODO: Wait for search to be implemented on the website.
+        const results = (await this.getWebsiteMangaDirectory(null)).results;
+        const data: MangaTile[] = [];
+        for (let i = 0; i < results.length; i++) {
+            const key = results[i];
+            if (query.title) {
+                if ((key.primaryText?.text || "").toLowerCase().includes((query.title.toLowerCase()))) {
+                    data.push(key);
+                }
+            }
+        }
+        return createPagedResults({
+            results: data
+        });
+    }
+}
diff --git a/src/VoidScans/VoidScansParser.ts b/src/VoidScans/VoidScansParser.ts
@@ -0,0 +1,57 @@
+import {Chapter, LanguageCode, Manga, MangaStatus, MangaTile} from "paperback-extensions-common";
+
+export class VoidScansParser {
+    parseMangaList($: CheerioStatic, base: string) {
+        const mangaTiles: MangaTile[] = [];
+        $("div.col").map((index, element) => {
+            const link = $("a.btn", element);
+            const linkId = link.attr("href");
+            if (linkId){
+                mangaTiles.push(createMangaTile({
+                    id: linkId.replace(`${base}/library/`, ""),
+                    title: createIconText({
+                        text: ""
+                    }),
+                    image: $("img", element).attr("src") || "",
+                    primaryText: createIconText({
+                        text: $("p.card-text", element).text()
+                    })
+                }))
+            }
+        })
+        return mangaTiles;
+    }
+
+    parsePage($: CheerioStatic): string | null {
+        return $("img").attr("src") || null;
+    }
+
+    parseChapterList($: CheerioStatic, mangaId: string) {
+        const chapters: Chapter[] = [];
+        $("ul.list-group").first().children().map((index, element) => {
+            const link = $(element).first();
+            const chapNum = Number(link.text().replace("Chapter ", ""));
+            const data: Chapter = {
+                chapNum: chapNum,
+                id: String(chapNum),
+                langCode: LanguageCode.ENGLISH,
+                mangaId: mangaId,
+            }
+            chapters.push(createChapter(data))
+        })
+        return chapters
+    }
+
+    parseManga($: CheerioStatic, mangaId: string) {
+        const mangaObj: Manga = {
+            desc: $("p").first().text().trim(),
+            id: mangaId,
+            image: $("img#manga-img").attr("src") || "",
+            rating: 0,
+            status: MangaStatus.ONGOING,
+            titles: [$("h1").first().text()],
+        }
+        return createManga(mangaObj)
+    }
+
+}
diff --git a/src/tests/VoidScans.test.ts b/src/tests/VoidScans.test.ts
@@ -0,0 +1,80 @@
+import cheerio from "cheerio";
+import {VoidScans} from "../VoidScans/VoidScans";
+import {APIWrapper, Source} from "paperback-extensions-common";
+
+describe("VoidScans Tests", function () {
+    let wrapper: APIWrapper = new APIWrapper();
+    let source: Source = new VoidScans(cheerio);
+    let chai = require("chai"),
+        expect = chai.expect;
+    let chaiAsPromised = require("chai-as-promised");
+    chai.use(chaiAsPromised);
+
+    let mangaId = "2";
+
+    it("Retrieve Manga Details", async () => {
+        let details = await wrapper.getMangaDetails(source, mangaId);
+        expect(
+            details,
+            "No results found with test-defined ID [" + mangaId + "]"
+        ).to.exist;
+
+        // Validate that the fields are filled
+        let data = details;
+        expect(data.id, "Missing ID").to.be.not.empty;
+        expect(data.image, "Missing Image").to.exist;
+        expect(data.status, "Missing Status").to.exist;
+        expect(data.titles, "Missing Titles").to.be.not.empty;
+        expect(data.rating, "Missing Rating").to.exist;
+        expect(data.desc, "Missing Description").to.be.not.empty;
+    });
+
+    it("Get Chapters", async () => {
+        let data = await wrapper.getChapters(source, mangaId);
+
+        expect(data, "No chapters present for: [" + mangaId + "]").to.not.be.empty;
+
+        let entry = data[0];
+        expect(entry.id, "No ID present").to.not.be.empty;
+        expect(entry.chapNum, "No chapter number present").to.exist;
+    });
+
+    it("Get Chapter Details", async () => {
+        let chapters = await wrapper.getChapters(source, mangaId);
+        let data = await wrapper.getChapterDetails(source, mangaId, chapters[0].id);
+
+        expect(data, "Empty server response").to.not.be.empty;
+
+        expect(data.id, "Missing ID").to.be.not.empty;
+        expect(data.mangaId, "Missing MangaID").to.be.not.empty;
+        expect(data.pages, "No pages present").to.be.not.empty;
+    });
+
+    it("Testing search", async () => {
+        let testSearch = createSearchRequest({
+            title: "Son",
+        });
+
+        let search = await wrapper.searchRequest(source, testSearch);
+        let result = search.results[0];
+
+        expect(result, "No response from server").to.exist;
+
+        expect(result.id, "No ID found for search query").to.be.not.empty;
+        expect(result.title, "No title").to.be.not.empty;
+    });
+
+    it("Testing Home Page", async () => {
+        let result = await wrapper.getHomePageSections(source);
+        expect(result, "No response from server").to.exist;
+        let item = result[0];
+        expect(item, "Empty response from server").to.exist;
+        if (item.items) {
+            let subitem = item.items[0];
+
+            expect(subitem.id, "No ID found for homepage item").to.not.be.empty;
+            expect(subitem.title, "No Title found for homepage item").to.not.be.empty;
+            expect(subitem.image, "No Image found for homepage item").to.not.be.empty;
+        }
+    })
+});
