refactor & config improvments

server/src/main/kotlin/ir/armor/tachidesk/impl/APKExtractor.java

@@ -0,0 +1,254 @@
+package ir.armor.tachidesk.impl;
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class APKExtractor {
+    // decompressXML -- Parse the 'compressed' binary form of Android XML docs
+    // such as for AndroidManifest.xml in .apk files
+    public static int endDocTag = 0x00100101;
+    public static int startTag = 0x00100102;
+    public static int endTag = 0x00100103;
+
+    static void prt(String str) {
+        //System.err.print(str);
+    }
+
+    public static String decompressXML(byte[] xml) {
+
+        StringBuilder finalXML = new StringBuilder();
+
+        // Compressed XML file/bytes starts with 24x bytes of data,
+        // 9 32 bit words in little endian order (LSB first):
+        // 0th word is 03 00 08 00
+        // 3rd word SEEMS TO BE: Offset at then of StringTable
+        // 4th word is: Number of strings in string table
+        // WARNING: Sometime I indiscriminently display or refer to word in
+        // little endian storage format, or in integer format (ie MSB first).
+        int numbStrings = LEW(xml, 4 * 4);
+
+        // StringIndexTable starts at offset 24x, an array of 32 bit LE offsets
+        // of the length/string data in the StringTable.
+        int sitOff = 0x24; // Offset of start of StringIndexTable
+
+        // StringTable, each string is represented with a 16 bit little endian
+        // character count, followed by that number of 16 bit (LE) (Unicode)
+        // chars.
+        int stOff = sitOff + numbStrings * 4; // StringTable follows
+        // StrIndexTable
+
+        // XMLTags, The XML tag tree starts after some unknown content after the
+        // StringTable. There is some unknown data after the StringTable, scan
+        // forward from this point to the flag for the start of an XML start
+        // tag.
+        int xmlTagOff = LEW(xml, 3 * 4); // Start from the offset in the 3rd
+        // word.
+        // Scan forward until we find the bytes: 0x02011000(x00100102 in normal
+        // int)
+        for (int ii = xmlTagOff; ii < xml.length - 4; ii += 4) {
+            if (LEW(xml, ii) == startTag) {
+                xmlTagOff = ii;
+                break;
+            }
+        } // end of hack, scanning for start of first start tag
+
+        // XML tags and attributes:
+        // Every XML start and end tag consists of 6 32 bit words:
+        // 0th word: 02011000 for startTag and 03011000 for endTag
+        // 1st word: a flag?, like 38000000
+        // 2nd word: Line of where this tag appeared in the original source file
+        // 3rd word: FFFFFFFF ??
+        // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS
+        // 5th word: StringIndex of Element Name
+        // (Note: 01011000 in 0th word means end of XML document, endDocTag)
+
+        // Start tags (not end tags) contain 3 more words:
+        // 6th word: 14001400 meaning??
+        // 7th word: Number of Attributes that follow this tag(follow word 8th)
+        // 8th word: 00000000 meaning??
+
+        // Attributes consist of 5 words:
+        // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF
+        // 1st word: StringIndex of Attribute Name
+        // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId
+        // used
+        // 3rd word: Flags?
+        // 4th word: str ind of attr value again, or ResourceId of value
+
+        // TMP, dump string table to tr for debugging
+        // tr.addSelect("strings", null);
+        // for (int ii=0; ii<numbStrings; ii++) {
+        // // Length of string starts at StringTable plus offset in StrIndTable
+        // String str = compXmlString(xml, sitOff, stOff, ii);
+        // tr.add(String.valueOf(ii), str);
+        // }
+        // tr.parent();
+
+        // Step through the XML tree element tags and attributes
+        int off = xmlTagOff;
+        int indent = 0;
+        int startTagLineNo = -2;
+        while (off < xml.length) {
+            int tag0 = LEW(xml, off);
+            // int tag1 = LEW(xml, off+1*4);
+            int lineNo = LEW(xml, off + 2 * 4);
+            // int tag3 = LEW(xml, off+3*4);
+            int nameNsSi = LEW(xml, off + 4 * 4);
+            int nameSi = LEW(xml, off + 5 * 4);
+
+            if (tag0 == startTag) { // XML START TAG
+                int tag6 = LEW(xml, off + 6 * 4); // Expected to be 14001400
+                int numbAttrs = LEW(xml, off + 7 * 4); // Number of Attributes
+                // to follow
+                // int tag8 = LEW(xml, off+8*4); // Expected to be 00000000
+                off += 9 * 4; // Skip over 6+3 words of startTag data
+                String name = compXmlString(xml, sitOff, stOff, nameSi);
+                // tr.addSelect(name, null);
+                startTagLineNo = lineNo;
+
+                // Look for the Attributes
+                StringBuffer sb = new StringBuffer();
+                for (int ii = 0; ii < numbAttrs; ii++) {
+                    int attrNameNsSi = LEW(xml, off); // AttrName Namespace Str
+                    // Ind, or FFFFFFFF
+                    int attrNameSi = LEW(xml, off + 1 * 4); // AttrName String
+                    // Index
+                    int attrValueSi = LEW(xml, off + 2 * 4); // AttrValue Str
+                    // Ind, or
+                    // FFFFFFFF
+                    int attrFlags = LEW(xml, off + 3 * 4);
+                    int attrResId = LEW(xml, off + 4 * 4); // AttrValue
+                    // ResourceId or dup
+                    // AttrValue StrInd
+                    off += 5 * 4; // Skip over the 5 words of an attribute
+
+                    String attrName = compXmlString(xml, sitOff, stOff,
+                            attrNameSi);
+                    String attrValue = attrValueSi != -1 ? compXmlString(xml,
+                            sitOff, stOff, attrValueSi) : "resourceID 0x"
+                            + Integer.toHexString(attrResId);
+                    sb.append(" " + attrName + "=\"" + attrValue + "\"");
+                    // tr.add(attrName, attrValue);
+                }
+                finalXML.append("<" + name + sb + ">");
+                prtIndent(indent, "<" + name + sb + ">");
+                indent++;
+
+            } else if (tag0 == endTag) { // XML END TAG
+                indent--;
+                off += 6 * 4; // Skip over 6 words of endTag data
+                String name = compXmlString(xml, sitOff, stOff, nameSi);
+                finalXML.append("</" + name + ">");
+                prtIndent(indent, "</" + name + "> (line " + startTagLineNo
+                        + "-" + lineNo + ")");
+                // tr.parent(); // Step back up the NobTree
+
+            } else if (tag0 == endDocTag) { // END OF XML DOC TAG
+                break;
+
+            } else {
+                prt("  Unrecognized tag code '" + Integer.toHexString(tag0)
+                        + "' at offset " + off);
+                break;
+            }
+        } // end of while loop scanning tags and attributes of XML tree
+        //prt("    end at offset " + off);
+        return finalXML.toString();
+    } // end of decompressXML
+
+    public static String compXmlString(byte[] xml, int sitOff, int stOff, int strInd) {
+        if (strInd < 0)
+            return null;
+        int strOff = stOff + LEW(xml, sitOff + strInd * 4);
+        return compXmlStringAt(xml, strOff);
+    }
+
+    public static String spaces = "                                             ";
+
+    public static void prtIndent(int indent, String str) {
+        prt(spaces.substring(0, Math.min(indent * 2, spaces.length())) + str);
+    }
+
+    // compXmlStringAt -- Return the string stored in StringTable format at
+    // offset strOff. This offset points to the 16 bit string length, which
+    // is followed by that number of 16 bit (Unicode) chars.
+    public static String compXmlStringAt(byte[] arr, int strOff) {
+        int strLen = arr[strOff + 1] << 8 & 0xff00 | arr[strOff] & 0xff;
+        byte[] chars = new byte[strLen];
+        for (int ii = 0; ii < strLen; ii++) {
+            chars[ii] = arr[strOff + 2 + ii * 2];
+        }
+        return new String(chars); // Hack, just use 8 byte chars
+    } // end of compXmlStringAt
+
+    // LEW -- Return value of a Little Endian 32 bit word from the byte array
+    // at offset off.
+    public static int LEW(byte[] arr, int off) {
+        return arr[off + 3] << 24 & 0xff000000 | arr[off + 2] << 16 & 0xff0000
+                | arr[off + 1] << 8 & 0xff00 | arr[off] & 0xFF;
+    } // end of LEW
+
+    public static Document loadXMLFromString(String xml) throws Exception {
+        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
+        return docBuilder.parse(new InputSource(new StringReader(xml)));
+    }
+
+    public static String extract_dex_and_read_className(String filePath, String dexPath) throws IOException {
+        ZipFile zip = null;
+
+        zip = new ZipFile(filePath);
+        ZipEntry androidManifest = zip.getEntry("AndroidManifest.xml");
+        ZipEntry classesDex = zip.getEntry("classes.dex");
+
+        // write dex file
+        InputStream dexStream = zip.getInputStream(classesDex);
+        try (OutputStream os = Files.newOutputStream(Paths.get(dexPath))) {
+            byte[] buffer = new byte[1024];
+            int len;
+            while ((len = dexStream.read(buffer)) > 0) {
+                os.write(buffer, 0, len);
+            }
+        }
+
+        // read xml file
+        InputStream is = zip.getInputStream(androidManifest);
+        byte[] buf = new byte[1024000]; // 100 kb
+        is.read(buf);
+        is.close();
+        zip.close();
+
+        String xml = APKExtractor.decompressXML(buf);
+        try {
+            Document xmlDoc = loadXMLFromString(xml);
+            String pkg = xmlDoc.getDocumentElement().getAttribute("package");
+            NodeList nodes = xmlDoc.getElementsByTagName("meta-data");
+            for (int i = 0; i < nodes.getLength(); i++) {
+                NamedNodeMap attributes = nodes.item(i).getAttributes();
+                System.out.println(attributes.getNamedItem("name").getNodeValue());
+                if (attributes.getNamedItem("name").getNodeValue().equals("tachiyomi.extension.class"))
+                    return pkg + attributes.getNamedItem("value").getNodeValue();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Category.kt

@@ -0,0 +1,69 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import ir.armor.tachidesk.database.dataclass.CategoryDataClass
+import ir.armor.tachidesk.database.table.CategoryMangaTable
+import ir.armor.tachidesk.database.table.CategoryTable
+import ir.armor.tachidesk.database.table.toDataClass
+import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+
+fun createCategory(name: String) {
+    transaction {
+        val count = CategoryTable.selectAll().count()
+        if (CategoryTable.select { CategoryTable.name eq name }.firstOrNull() == null)
+            CategoryTable.insert {
+                it[CategoryTable.name] = name
+                it[CategoryTable.order] = count.toInt() + 1
+            }
+    }
+}
+
+fun updateCategory(categoryId: Int, name: String?, isLanding: Boolean?) {
+    transaction {
+        CategoryTable.update({ CategoryTable.id eq categoryId }) {
+            if (name != null) it[CategoryTable.name] = name
+            if (isLanding != null) it[CategoryTable.isLanding] = isLanding
+        }
+    }
+}
+
+fun reorderCategory(categoryId: Int, from: Int, to: Int) {
+    transaction {
+        val categories = CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).toMutableList()
+        categories.add(to - 1, categories.removeAt(from - 1))
+        categories.forEachIndexed { index, cat ->
+            CategoryTable.update({ CategoryTable.id eq cat[CategoryTable.id].value }) {
+                it[CategoryTable.order] = index + 1
+            }
+        }
+    }
+}
+
+fun removeCategory(categoryId: Int) {
+    transaction {
+        CategoryMangaTable.select { CategoryMangaTable.category eq categoryId }.forEach {
+            removeMangaFromCategory(it[CategoryMangaTable.manga].value, categoryId)
+        }
+        CategoryTable.deleteWhere { CategoryTable.id eq categoryId }
+    }
+}
+
+fun getCategoryList(): List<CategoryDataClass> {
+    return transaction {
+        CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).map {
+            CategoryTable.toDataClass(it)
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/CategoryManga.kt

@@ -0,0 +1,64 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import ir.armor.tachidesk.database.dataclass.CategoryDataClass
+import ir.armor.tachidesk.database.dataclass.MangaDataClass
+import ir.armor.tachidesk.database.table.CategoryMangaTable
+import ir.armor.tachidesk.database.table.CategoryTable
+import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.database.table.toDataClass
+import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+
+fun addMangaToCategory(mangaId: Int, categoryId: Int) {
+    transaction {
+        if (CategoryMangaTable.select { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }.firstOrNull() == null) {
+            CategoryMangaTable.insert {
+                it[CategoryMangaTable.category] = categoryId
+                it[CategoryMangaTable.manga] = mangaId
+            }
+
+            MangaTable.update({ MangaTable.id eq mangaId }) {
+                it[MangaTable.defaultCategory] = false
+            }
+        }
+    }
+}
+
+fun removeMangaFromCategory(mangaId: Int, categoryId: Int) {
+    transaction {
+        CategoryMangaTable.deleteWhere { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }
+        if (CategoryMangaTable.select { CategoryMangaTable.manga eq mangaId }.count() == 0L) {
+            MangaTable.update({ MangaTable.id eq mangaId }) {
+                it[MangaTable.defaultCategory] = true
+            }
+        }
+    }
+}
+
+fun getCategoryMangaList(categoryId: Int): List<MangaDataClass> {
+    return transaction {
+        CategoryMangaTable.innerJoin(MangaTable).select { CategoryMangaTable.category eq categoryId }.map {
+            MangaTable.toDataClass(it)
+        }
+    }
+}
+
+fun getMangaCategories(mangaId: Int): List<CategoryDataClass> {
+    return transaction {
+        CategoryMangaTable.innerJoin(CategoryTable).select { CategoryMangaTable.manga eq mangaId }.orderBy(CategoryTable.order to SortOrder.ASC).map {
+            CategoryTable.toDataClass(it)
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Chapter.kt

@@ -0,0 +1,134 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import ir.armor.tachidesk.database.dataclass.ChapterDataClass
+import ir.armor.tachidesk.database.table.ChapterTable
+import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.database.table.PageTable
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.insertAndGetId
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+
+fun getChapterList(mangaId: Int): List<ChapterDataClass> {
+    val mangaDetails = getManga(mangaId)
+    val source = getHttpSource(mangaDetails.sourceId.toLong())
+
+    val chapterList = source.fetchChapterList(
+        SManga.create().apply {
+            title = mangaDetails.title
+            url = mangaDetails.url
+        }
+    ).toBlocking().first()
+
+    val chapterCount = chapterList.count()
+
+    return transaction {
+        chapterList.reversed().forEachIndexed { index, fetchedChapter ->
+            val chapterEntry = ChapterTable.select { ChapterTable.url eq fetchedChapter.url }.firstOrNull()
+            if (chapterEntry == null) {
+                ChapterTable.insertAndGetId {
+                    it[url] = fetchedChapter.url
+                    it[name] = fetchedChapter.name
+                    it[date_upload] = fetchedChapter.date_upload
+                    it[chapter_number] = fetchedChapter.chapter_number
+                    it[scanlator] = fetchedChapter.scanlator
+
+                    it[chapterIndex] = index + 1
+                    it[manga] = mangaId
+                }
+            } else {
+                ChapterTable.update({ ChapterTable.url eq fetchedChapter.url }) {
+                    it[name] = fetchedChapter.name
+                    it[date_upload] = fetchedChapter.date_upload
+                    it[chapter_number] = fetchedChapter.chapter_number
+                    it[scanlator] = fetchedChapter.scanlator
+
+                    it[chapterIndex] = index + 1
+                    it[manga] = mangaId
+                }
+            }
+        }
+
+        // clear any orphaned chapters
+        val dbChapterCount = transaction { ChapterTable.selectAll().count() }
+        if (dbChapterCount > chapterCount) { // we got some clean up due
+            // TODO
+        }
+
+        return@transaction chapterList.mapIndexed { index, it ->
+            ChapterDataClass(
+                ChapterTable.select { ChapterTable.url eq it.url }.firstOrNull()!![ChapterTable.id].value,
+                it.url,
+                it.name,
+                it.date_upload,
+                it.chapter_number,
+                it.scanlator,
+                mangaId,
+                chapterCount - index,
+                chapterCount
+            )
+        }
+    }
+}
+
+fun getChapter(chapterIndex: Int, mangaId: Int): ChapterDataClass {
+    return transaction {
+        val chapterEntry = ChapterTable.select {
+            ChapterTable.chapterIndex eq chapterIndex and (ChapterTable.manga eq mangaId)
+        }.firstOrNull()!!
+        val mangaEntry = MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!!
+        val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
+
+        val pageList = source.fetchPageList(
+            SChapter.create().apply {
+                url = chapterEntry[ChapterTable.url]
+                name = chapterEntry[ChapterTable.name]
+            }
+        ).toBlocking().first()
+
+        val chapterId = chapterEntry[ChapterTable.id].value
+        val chapterCount = transaction { ChapterTable.selectAll().count() }
+
+        val chapter = ChapterDataClass(
+            chapterId,
+            chapterEntry[ChapterTable.url],
+            chapterEntry[ChapterTable.name],
+            chapterEntry[ChapterTable.date_upload],
+            chapterEntry[ChapterTable.chapter_number],
+            chapterEntry[ChapterTable.scanlator],
+            mangaId,
+            chapterEntry[ChapterTable.chapterIndex],
+            chapterCount.toInt(),
+
+            pageList.count()
+        )
+
+        pageList.forEach { page ->
+            val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq page.index) }.firstOrNull() }
+            if (pageEntry == null) {
+                transaction {
+                    PageTable.insert {
+                        it[index] = page.index
+                        it[url] = page.url
+                        it[imageUrl] = page.imageUrl
+                        it[this.chapter] = chapterId
+                    }
+                }
+            }
+        }
+
+        return@transaction chapter
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Extension.kt

@@ -0,0 +1,206 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import com.googlecode.d2j.dex.Dex2jar
+import com.googlecode.d2j.reader.MultiDexFileReader
+import com.googlecode.dex2jar.tools.BaksmaliBaseDexExceptionHandler
+import eu.kanade.tachiyomi.extension.api.ExtensionGithubApi
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.source.SourceFactory
+import eu.kanade.tachiyomi.source.online.HttpSource
+import ir.armor.tachidesk.database.table.ExtensionTable
+import ir.armor.tachidesk.database.table.SourceTable
+import ir.armor.tachidesk.server.applicationDirs
+import kotlinx.coroutines.runBlocking
+import mu.KotlinLogging
+import okhttp3.Request
+import okio.buffer
+import okio.sink
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import uy.kohesive.injekt.injectLazy
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import java.net.URLClassLoader
+import java.nio.file.Files
+import java.nio.file.Path
+
+private val logger = KotlinLogging.logger {}
+
+private fun dex2jar(dexFile: String, jarFile: String, fileNameWithoutType: String) {
+    // adopted from com.googlecode.dex2jar.tools.Dex2jarCmd.doCommandLine
+    // source at: https://github.com/DexPatcher/dex2jar/tree/v2.1-20190905-lanchon/dex-tools/src/main/java/com/googlecode/dex2jar/tools/Dex2jarCmd.java
+
+    val jarFilePath = File(jarFile).toPath()
+    val reader = MultiDexFileReader.open(Files.readAllBytes(File(dexFile).toPath()))
+    val handler = BaksmaliBaseDexExceptionHandler()
+    Dex2jar
+        .from(reader)
+        .withExceptionHandler(handler)
+        .reUseReg(false)
+        .topoLogicalSort()
+        .skipDebug(true)
+        .optimizeSynchronized(false)
+        .printIR(false)
+        .noCode(false)
+        .skipExceptions(false)
+        .to(jarFilePath)
+    if (handler.hasException()) {
+        val errorFile: Path = File(applicationDirs.extensionsRoot).toPath().resolve("$fileNameWithoutType-error.txt")
+        logger.error(
+            "Detail Error Information in File $errorFile\n" +
+                "Please report this file to one of following link if possible (any one).\n" +
+                "    https://sourceforge.net/p/dex2jar/tickets/\n" +
+                "    https://bitbucket.org/pxb1988/dex2jar/issues\n" +
+                "    https://github.com/pxb1988/dex2jar/issues\n" +
+                "    dex2jar@googlegroups.com"
+        )
+        handler.dump(errorFile, emptyArray<String>())
+    }
+}
+
+fun installAPK(apkName: String): Int {
+    logger.info("Installing $apkName")
+    val extensionRecord = getExtensionList(true).first { it.apkName == apkName }
+    val fileNameWithoutType = apkName.substringBefore(".apk")
+    val dirPathWithoutType = "${applicationDirs.extensionsRoot}/$fileNameWithoutType"
+
+    // check if we don't have the dex file already downloaded
+    val jarPath = "${applicationDirs.extensionsRoot}/$fileNameWithoutType.jar"
+    if (!File(jarPath).exists()) {
+        runBlocking {
+            val api = ExtensionGithubApi()
+            val apkToDownload = api.getApkUrl(extensionRecord)
+
+            val apkFilePath = "$dirPathWithoutType.apk"
+            val jarFilePath = "$dirPathWithoutType.jar"
+            val dexFilePath = "$dirPathWithoutType.dex"
+
+            // download apk file
+            downloadAPKFile(apkToDownload, apkFilePath)
+
+            val className: String = APKExtractor.extract_dex_and_read_className(apkFilePath, dexFilePath)
+            logger.info(className)
+            // dex -> jar
+            dex2jar(dexFilePath, jarFilePath, fileNameWithoutType)
+
+            // clean up
+            File(apkFilePath).delete()
+            File(dexFilePath).delete()
+
+            // update sources of the extension
+            val child = URLClassLoader(arrayOf<URL>(URL("file:$jarFilePath")), this::class.java.classLoader)
+            val classToLoad = Class.forName(className, true, child)
+            val instance = classToLoad.newInstance()
+
+            val extensionId = transaction {
+                return@transaction ExtensionTable.select { ExtensionTable.name eq extensionRecord.name }.first()[ExtensionTable.id]
+            }
+
+            if (instance is HttpSource) { // single source
+                val httpSource = instance as HttpSource
+                transaction {
+                    if (SourceTable.select { SourceTable.id eq httpSource.id }.count() == 0L) {
+                        SourceTable.insert {
+                            it[this.id] = httpSource.id
+                            it[name] = httpSource.name
+                            it[this.lang] = httpSource.lang
+                            it[extension] = extensionId
+                        }
+                    }
+                    logger.info("Installed source ${httpSource.name} with id {httpSource.id}")
+                }
+            } else { // multi source
+                val sourceFactory = instance as SourceFactory
+                transaction {
+                    sourceFactory.createSources().forEachIndexed { index, source ->
+                        val httpSource = source as HttpSource
+                        if (SourceTable.select { SourceTable.id eq httpSource.id }.count() == 0L) {
+                            SourceTable.insert {
+                                it[this.id] = httpSource.id
+                                it[name] = httpSource.name
+                                it[this.lang] = httpSource.lang
+                                it[extension] = extensionId
+                                it[partOfFactorySource] = true
+                                it[positionInFactorySource] = index
+                            }
+                        }
+                        logger.info("Installed source ${httpSource.name} with id:${httpSource.id}")
+                    }
+                }
+            }
+
+            // update extension info
+            transaction {
+                ExtensionTable.update({ ExtensionTable.name eq extensionRecord.name }) {
+                    it[installed] = true
+                    it[classFQName] = className
+                }
+            }
+        }
+        return 201 // we downloaded successfully
+    } else {
+        return 302
+    }
+}
+
+val networkHelper: NetworkHelper by injectLazy()
+
+private fun downloadAPKFile(url: String, apkPath: String) {
+    val request = Request.Builder().url(url).build()
+    val response = networkHelper.client.newCall(request).execute()
+
+    val downloadedFile = File(apkPath)
+    val sink = downloadedFile.sink().buffer()
+    sink.writeAll(response.body!!.source())
+    sink.close()
+}
+
+fun removeExtension(apkName: String) {
+    logger.info("Uninstalling $apkName")
+
+    val extensionRecord = getExtensionList(true).first { it.apkName == apkName }
+    val fileNameWithoutType = apkName.substringBefore(".apk")
+    val jarPath = "${applicationDirs.extensionsRoot}/$fileNameWithoutType.jar"
+    transaction {
+        val extensionId = ExtensionTable.select { ExtensionTable.name eq extensionRecord.name }.first()[ExtensionTable.id]
+
+        SourceTable.deleteWhere { SourceTable.extension eq extensionId }
+        ExtensionTable.update({ ExtensionTable.name eq extensionRecord.name }) {
+            it[ExtensionTable.installed] = false
+        }
+    }
+
+    if (File(jarPath).exists()) {
+        File(jarPath).delete()
+    }
+}
+
+val network: NetworkHelper by injectLazy()
+
+fun getExtensionIcon(apkName: String): Pair<InputStream, String> {
+    val iconUrl = transaction { ExtensionTable.select { ExtensionTable.apkName eq apkName }.firstOrNull()!! }[ExtensionTable.iconUrl]
+
+    val saveDir = "${applicationDirs.extensionsRoot}/icon"
+
+    return getCachedResponse(saveDir, apkName) {
+        network.client.newCall(
+            GET(iconUrl)
+        ).execute()
+    }
+}
+
+fun getExtensionIconUrl(apkName: String): String {
+    return "/api/v1/extension/icon/$apkName"
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/ExtensionsList.kt

@@ -0,0 +1,94 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.extension.api.ExtensionGithubApi
+import eu.kanade.tachiyomi.extension.model.Extension
+import ir.armor.tachidesk.database.dataclass.ExtensionDataClass
+import ir.armor.tachidesk.database.table.ExtensionTable
+import kotlinx.coroutines.runBlocking
+import mu.KotlinLogging
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+
+private val logger = KotlinLogging.logger {}
+
+private object Data {
+    var lastExtensionCheck: Long = 0
+}
+
+private fun extensionDatabaseIsEmtpy(): Boolean {
+    return transaction {
+        return@transaction ExtensionTable.selectAll().count() == 0L
+    }
+}
+
+fun getExtensionList(offline: Boolean = false): List<ExtensionDataClass> {
+    // update if 60 seconds has passed or requested offline and database is empty
+    if (Data.lastExtensionCheck + 60 * 1000 < System.currentTimeMillis() || (offline && extensionDatabaseIsEmtpy())) {
+        logger.info("Getting extensions list from the internet")
+        Data.lastExtensionCheck = System.currentTimeMillis()
+        var foundExtensions: List<Extension.Available>
+        runBlocking {
+            val api = ExtensionGithubApi()
+            foundExtensions = api.findExtensions()
+            transaction {
+                foundExtensions.forEach { foundExtension ->
+                    val extensionRecord = ExtensionTable.select { ExtensionTable.name eq foundExtension.name }.firstOrNull()
+                    if (extensionRecord != null) {
+                        // update the record
+                        ExtensionTable.update({ ExtensionTable.name eq foundExtension.name }) {
+                            it[name] = foundExtension.name
+                            it[pkgName] = foundExtension.pkgName
+                            it[versionName] = foundExtension.versionName
+                            it[versionCode] = foundExtension.versionCode
+                            it[lang] = foundExtension.lang
+                            it[isNsfw] = foundExtension.isNsfw
+                            it[apkName] = foundExtension.apkName
+                            it[iconUrl] = foundExtension.iconUrl
+                        }
+                    } else {
+                        // insert new record
+                        ExtensionTable.insert {
+                            it[name] = foundExtension.name
+                            it[pkgName] = foundExtension.pkgName
+                            it[versionName] = foundExtension.versionName
+                            it[versionCode] = foundExtension.versionCode
+                            it[lang] = foundExtension.lang
+                            it[isNsfw] = foundExtension.isNsfw
+                            it[apkName] = foundExtension.apkName
+                            it[iconUrl] = foundExtension.iconUrl
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        logger.info("used cached extension list")
+    }
+
+    return transaction {
+        return@transaction ExtensionTable.selectAll().map {
+            ExtensionDataClass(
+                it[ExtensionTable.name],
+                it[ExtensionTable.pkgName],
+                it[ExtensionTable.versionName],
+                it[ExtensionTable.versionCode],
+                it[ExtensionTable.lang],
+                it[ExtensionTable.isNsfw],
+                it[ExtensionTable.apkName],
+                getExtensionIconUrl(it[ExtensionTable.apkName]),
+                it[ExtensionTable.installed],
+                it[ExtensionTable.classFQName]
+            )
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/File.kt

@@ -0,0 +1,85 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import okhttp3.Response
+import okio.BufferedSource
+import okio.buffer
+import okio.sink
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.InputStream
+import java.io.OutputStream
+import java.nio.file.Files
+import java.nio.file.Paths
+
+// fun writeStream(fileStream: InputStream, path: String) {
+//    Files.newOutputStream(Paths.get(path)).use { os ->
+//        val buffer = ByteArray(128 * 1024)
+//        var len: Int
+//        while (fileStream.read(buffer).also { len = it } > 0) {
+//            os.write(buffer, 0, len)
+//        }
+//    }
+// }
+
+fun pathToInputStream(path: String): InputStream {
+    return BufferedInputStream(FileInputStream(path))
+}
+
+fun findFileNameStartingWith(directoryPath: String, fileName: String): String? {
+    File(directoryPath).listFiles().forEach { file ->
+        if (file.name.startsWith(fileName))
+            return "$directoryPath/${file.name}"
+    }
+    return null
+}
+
+/**
+ * Saves the given source to an output stream and closes both resources.
+ *
+ * @param stream the stream where the source is copied.
+ */
+private fun BufferedSource.saveTo(stream: OutputStream) {
+    use { input ->
+        stream.sink().buffer().use {
+            it.writeAll(input)
+            it.flush()
+        }
+    }
+}
+
+fun getCachedResponse(saveDir: String, fileName: String, fetcher: () -> Response): Pair<InputStream, String> {
+    val cachedFile = findFileNameStartingWith(saveDir, fileName)
+    val filePath = "$saveDir/$fileName"
+    if (cachedFile != null) {
+        val fileType = cachedFile.substringAfter(filePath)
+        return Pair(
+            pathToInputStream(cachedFile),
+            "image/$fileType"
+        )
+    }
+
+    val response = fetcher()
+
+    if (response.code == 200) {
+        val contentType = response.headers["content-type"]!!
+        val fullPath = filePath + "." + contentType.substringAfter("image/")
+
+        Files.newOutputStream(Paths.get(fullPath)).use { os ->
+            response.body!!.source().saveTo(os)
+        }
+        return Pair(
+            pathToInputStream(fullPath),
+            contentType
+        )
+    } else {
+        throw Exception("request error! ${response.code}")
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Library.kt

@@ -0,0 +1,50 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import ir.armor.tachidesk.database.dataclass.MangaDataClass
+import ir.armor.tachidesk.database.table.CategoryMangaTable
+import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.database.table.toDataClass
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+
+fun addMangaToLibrary(mangaId: Int) {
+    val manga = getManga(mangaId)
+    if (!manga.inLibrary) {
+        transaction {
+            MangaTable.update({ MangaTable.id eq manga.id }) {
+                it[inLibrary] = true
+            }
+        }
+    }
+}
+
+fun removeMangaFromLibrary(mangaId: Int) {
+    val manga = getManga(mangaId)
+    if (manga.inLibrary) {
+        transaction {
+            MangaTable.update({ MangaTable.id eq manga.id }) {
+                it[inLibrary] = false
+                it[defaultCategory] = true
+            }
+            CategoryMangaTable.deleteWhere { CategoryMangaTable.manga eq mangaId }
+        }
+    }
+}
+
+fun getLibraryMangas(): List<MangaDataClass> {
+    return transaction {
+        MangaTable.select { (MangaTable.inLibrary eq true) and (MangaTable.defaultCategory eq true) }.map {
+            MangaTable.toDataClass(it)
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Manga.kt

@@ -0,0 +1,108 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.SManga
+import ir.armor.tachidesk.database.dataclass.MangaDataClass
+import ir.armor.tachidesk.database.table.MangaStatus
+import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.server.applicationDirs
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import java.io.InputStream
+
+fun getManga(mangaId: Int, proxyThumbnail: Boolean = true): MangaDataClass {
+    var mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+
+    return if (mangaEntry[MangaTable.initialized]) {
+        MangaDataClass(
+            mangaId,
+            mangaEntry[MangaTable.sourceReference].toString(),
+
+            mangaEntry[MangaTable.url],
+            mangaEntry[MangaTable.title],
+            if (proxyThumbnail) proxyThumbnailUrl(mangaId) else mangaEntry[MangaTable.thumbnail_url],
+
+            true,
+
+            mangaEntry[MangaTable.artist],
+            mangaEntry[MangaTable.author],
+            mangaEntry[MangaTable.description],
+            mangaEntry[MangaTable.genre],
+            MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
+            mangaEntry[MangaTable.inLibrary],
+            getSource(mangaEntry[MangaTable.sourceReference])
+        )
+    } else { // initialize manga
+        val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
+        val fetchedManga = source.fetchMangaDetails(
+            SManga.create().apply {
+                url = mangaEntry[MangaTable.url]
+                title = mangaEntry[MangaTable.title]
+            }
+        ).toBlocking().first()
+
+        transaction {
+            MangaTable.update({ MangaTable.id eq mangaId }) {
+
+                it[MangaTable.initialized] = true
+
+                it[MangaTable.artist] = fetchedManga.artist
+                it[MangaTable.author] = fetchedManga.author
+                it[MangaTable.description] = fetchedManga.description
+                it[MangaTable.genre] = fetchedManga.genre
+                it[MangaTable.status] = fetchedManga.status
+                if (fetchedManga.thumbnail_url != null && fetchedManga.thumbnail_url!!.isNotEmpty())
+                    it[MangaTable.thumbnail_url] = fetchedManga.thumbnail_url
+            }
+        }
+
+        mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+        val newThumbnail = mangaEntry[MangaTable.thumbnail_url]
+
+        MangaDataClass(
+            mangaId,
+            mangaEntry[MangaTable.sourceReference].toString(),
+
+            mangaEntry[MangaTable.url],
+            mangaEntry[MangaTable.title],
+            if (proxyThumbnail) proxyThumbnailUrl(mangaId) else newThumbnail,
+
+            true,
+
+            fetchedManga.artist,
+            fetchedManga.author,
+            fetchedManga.description,
+            fetchedManga.genre,
+            MangaStatus.valueOf(fetchedManga.status).name,
+            false,
+            getSource(mangaEntry[MangaTable.sourceReference])
+        )
+    }
+}
+
+fun getThumbnail(mangaId: Int): Pair<InputStream, String> {
+    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+    val saveDir = applicationDirs.thumbnailsRoot
+    val fileName = mangaId.toString()
+
+    return getCachedResponse(saveDir, fileName) {
+        val sourceId = mangaEntry[MangaTable.sourceReference]
+        val source = getHttpSource(sourceId)
+        var thumbnailUrl = mangaEntry[MangaTable.thumbnail_url]
+        if (thumbnailUrl == null || thumbnailUrl.isEmpty()) {
+            thumbnailUrl = getManga(mangaId, proxyThumbnail = false).thumbnailUrl!!
+        }
+
+        source.client.newCall(
+            GET(thumbnailUrl, source.headers)
+        ).execute()
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/MangaDexHelper.kt

@@ -0,0 +1,98 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.source.online.HttpSource
+import okhttp3.FormBody
+import okhttp3.OkHttpClient
+import java.net.URLEncoder
+
+class MangaDexHelper(private val mangaDexSource: HttpSource) {
+
+    private fun clientBuilder(): OkHttpClient = clientBuilder(0)
+
+    private fun clientBuilder(
+        r18Toggle: Int,
+        okHttpClient: OkHttpClient = mangaDexSource.network.client
+    ): OkHttpClient = okHttpClient.newBuilder()
+        .addNetworkInterceptor { chain ->
+            val originalCookies = chain.request().header("Cookie") ?: ""
+            val newReq = chain
+                .request()
+                .newBuilder()
+                .header("Cookie", "$originalCookies; ${cookiesHeader(r18Toggle)}")
+                .build()
+            chain.proceed(newReq)
+        }.build()
+
+    private fun cookiesHeader(r18Toggle: Int): String {
+        val cookies = mutableMapOf<String, String>()
+        cookies["mangadex_h_toggle"] = r18Toggle.toString()
+        return buildCookies(cookies)
+    }
+
+    private fun buildCookies(cookies: Map<String, String>) =
+        cookies.entries.joinToString(separator = "; ", postfix = ";") {
+            "${URLEncoder.encode(it.key, "UTF-8")}=${URLEncoder.encode(it.value, "UTF-8")}"
+        }
+
+//    fun isLogged(): Boolean {
+//        val httpUrl = mangaDexSource.baseUrl.toHttpUrlOrNull()!!
+//        return network.cookieManager.get(httpUrl).any { it.name == REMEMBER_ME }
+//    }
+
+    fun login(username: String, password: String, twoFactorCode: String = ""): Boolean {
+        val formBody = FormBody.Builder()
+            .add("login_username", username)
+            .add("login_password", password)
+            .add("no_js", "1")
+            .add("remember_me", "1")
+
+        twoFactorCode.let {
+            formBody.add("two_factor", it)
+        }
+
+        val response = clientBuilder().newCall(
+            POST(
+                "${mangaDexSource.baseUrl}/ajax/actions.ajax.php?function=login",
+                mangaDexSource.headers,
+                formBody.build()
+            )
+        ).execute()
+        return response.body!!.string().isEmpty()
+    }
+//
+//    fun logout(): Boolean {
+//        return withContext(Dispatchers.IO) {
+//            // https://mangadex.org/ajax/actions.ajax.php?function=logout
+//            val httpUrl = baseUrl.toHttpUrlOrNull()!!
+//            val listOfDexCookies = network.cookieManager.get(httpUrl)
+//            val cookie = listOfDexCookies.find { it.name == REMEMBER_ME }
+//            val token = cookie?.value
+//            if (token.isNullOrEmpty()) {
+//                return@withContext true
+//            }
+//            val result = clientBuilder().newCall(
+//                    POSTWithCookie(
+//                            "$baseUrl/ajax/actions.ajax.php?function=logout",
+//                            REMEMBER_ME,
+//                            token,
+//                            headers
+//                    )
+//            ).execute()
+//            val resultStr = result.body!!.string()
+//            if (resultStr.contains("success", true)) {
+//                network.cookieManager.remove(httpUrl)
+//                return@withContext true
+//            }
+//
+//            false
+//        }
+//    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/MangaList.kt

@@ -0,0 +1,98 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.source.model.MangasPage
+import ir.armor.tachidesk.database.dataclass.MangaDataClass
+import ir.armor.tachidesk.database.dataclass.PagedMangaListDataClass
+import ir.armor.tachidesk.database.table.MangaStatus
+import ir.armor.tachidesk.database.table.MangaTable
+import org.jetbrains.exposed.sql.insertAndGetId
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+
+fun proxyThumbnailUrl(mangaId: Int): String {
+    return "/api/v1/manga/$mangaId/thumbnail"
+}
+
+fun getMangaList(sourceId: Long, pageNum: Int = 1, popular: Boolean): PagedMangaListDataClass {
+    val source = getHttpSource(sourceId.toLong())
+    val mangasPage = if (popular) {
+        source.fetchPopularManga(pageNum).toBlocking().first()
+    } else {
+        if (source.supportsLatest)
+            source.fetchLatestUpdates(pageNum).toBlocking().first()
+        else
+            throw Exception("Source $source doesn't support latest")
+    }
+    return mangasPage.processEntries(sourceId)
+}
+
+fun MangasPage.processEntries(sourceId: Long): PagedMangaListDataClass {
+    val mangasPage = this
+    val mangaList = transaction {
+        return@transaction mangasPage.mangas.map { manga ->
+            var mangaEntry = MangaTable.select { MangaTable.url eq manga.url }.firstOrNull()
+            if (mangaEntry == null) { // create manga entry
+                val mangaId = MangaTable.insertAndGetId {
+                    it[url] = manga.url
+                    it[title] = manga.title
+
+                    it[artist] = manga.artist
+                    it[author] = manga.author
+                    it[description] = manga.description
+                    it[genre] = manga.genre
+                    it[status] = manga.status
+                    it[thumbnail_url] = manga.thumbnail_url
+
+                    it[sourceReference] = sourceId
+                }.value
+
+                MangaDataClass(
+                    mangaId,
+                    sourceId.toString(),
+
+                    manga.url,
+                    manga.title,
+                    proxyThumbnailUrl(mangaId),
+
+                    manga.initialized,
+
+                    manga.artist,
+                    manga.author,
+                    manga.description,
+                    manga.genre,
+                    MangaStatus.valueOf(manga.status).name
+                )
+            } else {
+                val mangaId = mangaEntry[MangaTable.id].value
+                MangaDataClass(
+                    mangaId,
+                    sourceId.toString(),
+
+                    manga.url,
+                    manga.title,
+                    proxyThumbnailUrl(mangaId),
+
+                    true,
+
+                    mangaEntry[MangaTable.artist],
+                    mangaEntry[MangaTable.author],
+                    mangaEntry[MangaTable.description],
+                    mangaEntry[MangaTable.genre],
+                    MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
+                    mangaEntry[MangaTable.inLibrary]
+                )
+            }
+        }
+    }
+    return PagedMangaListDataClass(
+        mangaList,
+        mangasPage.hasNextPage
+    )
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Page.kt

@@ -0,0 +1,79 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.source.online.HttpSource
+import ir.armor.tachidesk.database.table.ChapterTable
+import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.database.table.PageTable
+import ir.armor.tachidesk.database.table.SourceTable
+import ir.armor.tachidesk.server.applicationDirs
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import java.io.File
+import java.io.InputStream
+
+fun getTrueImageUrl(page: Page, source: HttpSource): String {
+    if (page.imageUrl == null) {
+        page.imageUrl = source.fetchImageUrl(page).toBlocking().first()!!
+    }
+    return page.imageUrl!!
+}
+
+fun getPageImage(mangaId: Int, chapterId: Int, index: Int): Pair<InputStream, String> {
+    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+    val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
+    val chapterEntry = transaction { ChapterTable.select { ChapterTable.id eq chapterId }.firstOrNull()!! }
+    val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq index) }.firstOrNull()!! }
+
+    val tachiPage = Page(
+        pageEntry[PageTable.index],
+        pageEntry[PageTable.url],
+        pageEntry[PageTable.imageUrl]
+    )
+
+    if (pageEntry[PageTable.imageUrl] == null) {
+        transaction {
+            PageTable.update({ (PageTable.chapter eq chapterId) and (PageTable.index eq index) }) {
+                it[imageUrl] = getTrueImageUrl(tachiPage, source)
+            }
+        }
+    }
+
+    val saveDir = getChapterDir(mangaId, chapterId)
+    File(saveDir).mkdirs()
+    val fileName = index.toString()
+
+    return getCachedResponse(saveDir, fileName) {
+        source.fetchImage(tachiPage).toBlocking().first()
+    }
+}
+
+fun getChapterDir(mangaId: Int, chapterId: Int): String {
+    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+    val sourceId = mangaEntry[MangaTable.sourceReference]
+    val source = getHttpSource(sourceId)
+    val sourceEntry = transaction { SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()!! }
+    val chapterEntry = transaction { ChapterTable.select { ChapterTable.id eq chapterId }.firstOrNull()!! }
+
+    val chapterDir = when {
+        chapterEntry[ChapterTable.scanlator] != null -> "${chapterEntry[ChapterTable.scanlator]}_${chapterEntry[ChapterTable.name]}"
+        else -> chapterEntry[ChapterTable.name]
+    }
+
+    val mangaTitle = mangaEntry[MangaTable.title]
+    val sourceName = source.toString()
+
+    val mangaDir = "${applicationDirs.mangaRoot}/$sourceName/$mangaTitle/$chapterDir"
+    // make sure dirs exist
+    File(mangaDir).mkdirs()
+    return mangaDir
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Search.kt

@@ -0,0 +1,66 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import ir.armor.tachidesk.database.dataclass.PagedMangaListDataClass
+
+fun sourceFilters(sourceId: Long) {
+    val source = getHttpSource(sourceId)
+    // source.getFilterList().toItems()
+}
+
+fun sourceSearch(sourceId: Long, searchTerm: String, pageNum: Int): PagedMangaListDataClass {
+    val source = getHttpSource(sourceId)
+    val searchManga = source.fetchSearchManga(pageNum, searchTerm, source.getFilterList()).toBlocking().first()
+    return searchManga.processEntries(sourceId)
+}
+
+fun sourceGlobalSearch(searchTerm: String) {
+    // TODO
+}
+
+data class FilterWrapper(
+    val type: String,
+    val filter: Any
+)
+
+// private fun FilterList.toFilterWrapper(): List<FilterWrapper> {
+//    return mapNotNull { filter ->
+//        when (filter) {
+//            is Filter.Header -> FilterWrapper("Header",filter)
+//            is Filter.Separator -> FilterWrapper("Separator",filter)
+//            is Filter.CheckBox -> FilterWrapper("CheckBox",filter)
+//            is Filter.TriState -> FilterWrapper("TriState",filter)
+//            is Filter.Text -> FilterWrapper("Text",filter)
+//            is Filter.Select<*> -> FilterWrapper("Select",filter)
+//            is Filter.Group<*> -> {
+//                val group = GroupItem(filter)
+//                val subItems = filter.state.mapNotNull {
+//                    when (it) {
+//                        is Filter.CheckBox -> FilterWrapper("CheckBox",filter)
+//                        is Filter.TriState -> FilterWrapper("TriState",filter)
+//                        is Filter.Text -> FilterWrapper("Text",filter)
+//                        is Filter.Select<*> -> FilterWrapper("Select",filter)
+//                        else -> null
+//                    } as? ISectionable<*, *>
+//                }
+//                subItems.forEach { it.header = group }
+//                group.subItems = subItems
+//                group
+//            }
+//            is Filter.Sort -> {
+//                val group = SortGroup(filter)
+//                val subItems = filter.values.map {
+//                    SortItem(it, group)
+//                }
+//                group.subItems = subItems
+//                group
+//            }
+//        }
+//    }
+// }

server/src/main/kotlin/ir/armor/tachidesk/impl/SourceList.kt

@@ -0,0 +1,107 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import eu.kanade.tachiyomi.source.SourceFactory
+import eu.kanade.tachiyomi.source.online.HttpSource
+import ir.armor.tachidesk.database.dataclass.SourceDataClass
+import ir.armor.tachidesk.database.entity.ExtensionEntity
+import ir.armor.tachidesk.database.entity.SourceEntity
+import ir.armor.tachidesk.database.table.ExtensionTable
+import ir.armor.tachidesk.database.table.SourceTable
+import ir.armor.tachidesk.server.applicationDirs
+import mu.KotlinLogging
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+import java.lang.NullPointerException
+import java.net.URL
+import java.net.URLClassLoader
+
+private val logger = KotlinLogging.logger {}
+
+private val sourceCache = mutableListOf<Pair<Long, HttpSource>>()
+private val extensionCache = mutableListOf<Pair<String, Any>>()
+
+fun getHttpSource(sourceId: Long): HttpSource {
+    val sourceRecord = transaction {
+        SourceEntity.findById(sourceId)
+    } ?: throw NullPointerException("Source with id $sourceId is not installed")
+
+    val cachedResult: Pair<Long, HttpSource>? = sourceCache.firstOrNull { it.first == sourceId }
+    if (cachedResult != null) {
+        logger.info("used cached HttpSource: ${cachedResult.second.name}")
+        return cachedResult.second
+    }
+
+    val result: HttpSource = transaction {
+        val extensionId = sourceRecord.extension.id.value
+        val extensionRecord = ExtensionEntity.findById(extensionId)!!
+        val apkName = extensionRecord.apkName
+        val className = extensionRecord.classFQName
+        val jarName = apkName.substringBefore(".apk") + ".jar"
+        val jarPath = "${applicationDirs.extensionsRoot}/$jarName"
+
+        val cachedExtensionPair = extensionCache.firstOrNull { it.first == jarPath }
+        var usedCached = false
+        val instance =
+            if (cachedExtensionPair != null) {
+                usedCached = true
+                logger.info("Used cached Extension")
+                cachedExtensionPair.second
+            } else {
+                logger.info("No Extension cache")
+                val child = URLClassLoader(arrayOf<URL>(URL("file:$jarPath")), this::class.java.classLoader)
+                val classToLoad = Class.forName(className, true, child)
+                classToLoad.newInstance()
+            }
+        if (sourceRecord.partOfFactorySource) {
+            return@transaction if (usedCached) {
+                (instance as List<HttpSource>)[sourceRecord.positionInFactorySource!!]
+            } else {
+                val list = (instance as SourceFactory).createSources()
+                extensionCache.add(Pair(jarPath, list))
+                list[sourceRecord.positionInFactorySource!!] as HttpSource
+            }
+        } else {
+            if (!usedCached)
+                extensionCache.add(Pair(jarPath, instance))
+            return@transaction instance as HttpSource
+        }
+    }
+    sourceCache.add(Pair(sourceId, result))
+    return result
+}
+
+fun getSourceList(): List<SourceDataClass> {
+    return transaction {
+        return@transaction SourceTable.selectAll().map {
+            SourceDataClass(
+                it[SourceTable.id].value.toString(),
+                it[SourceTable.name],
+                it[SourceTable.lang],
+                getExtensionIconUrl(ExtensionTable.select { ExtensionTable.id eq it[SourceTable.extension] }.first()[ExtensionTable.apkName]),
+                getHttpSource(it[SourceTable.id].value).supportsLatest
+            )
+        }
+    }
+}
+
+fun getSource(sourceId: Long): SourceDataClass {
+    return transaction {
+        val source = SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()
+
+        return@transaction SourceDataClass(
+            sourceId.toString(),
+            source?.get(SourceTable.name),
+            source?.get(SourceTable.lang),
+            source?.let { ExtensionTable.select { ExtensionTable.id eq source[SourceTable.extension] }.first()[ExtensionTable.iconUrl] },
+            source?.let { getHttpSource(sourceId).supportsLatest }
+        )
+    }
+}