Commit: 2fbaa590caa2e05189cdaee5429e46e8c1a1436c - pixivd (git)

D wrapper around (some) of the pixiv web API

Commit MetaInfo

• Revision: 2fbaa590caa2e05189cdaee5429e46e8c1a1436c (tree)
• Zeit: 2023-01-19 13:44:07
• Autor: supercell <stigma@disr...>
• Commiter: supercell

Log Message

Big ol' re-write.

Ändern Zusammenfassung

• modified: README
• modified: dub.sdl
• add: dub.selections.json
• delete: source/pixivd.d
• add: source/pixivd/client.d
• add: source/pixivd/enums.d
• add: source/pixivd/mixins.d
• add: source/pixivd/package.d
• add: source/pixivd/types/illustration.d
• add: source/pixivd/types/package.d
• add: source/pixivd/types/pixiv_exception.d
• add: source/pixivd/types/thumbnail.d
• add: source/pixivd/types/ugoira.d
• add: source/pixivd/types/user.d

Diff

--- a/README
+++ b/README
@@ -15,6 +15,13 @@ and change the dub.sdl file as written in the comments.
 
 = usage =
 
+*NOTICE*: You need to know what QuantumDepth the GraphicsMagick library uses
+on the system which will run this library.  Having the incorrect configuration
+_will_ result in runtime errors.  To find this out, run
+`gm version | head -n1 | cut -d' ' -f4`.  Then, use the `--override-config`
+option when compiling with dub or the "subConfiguration" setting in a dub
+SDL/JSON file.
+
 the basic usage is that you create a Client structure by passing your
 PHPSESSID cookie value (see PHPSESSID file for information on how to find this).
 

--- a/dub.sdl
+++ b/dub.sdl
@@ -4,8 +4,10 @@ authors "supercell"
 copyright "Copyright © 2022, supercell"
 license "GPL-3.0"
 
+systemDependencies "GraphicsMagick"
+
 dependency "magickd:graphicsmagick_c" repository="git+https://repo.or.cz/magickd.git" \
-    version="82221a99b4c74b2a88e0ea421b3d6f25b05d465f"
+    version="8f77b94429c8d883ce4c22a2d4d6346296809b81"
 
 ######
 #

--- /dev/null
+++ b/dub.selections.json
@@ -0,0 +1,6 @@
+{
+	"fileVersion": 1,
+	"versions": {
+		"magickd": {"version":"8f77b94429c8d883ce4c22a2d4d6346296809b81","repository":"git+https://repo.or.cz/magickd.git"}
+	}
+}

--- a/source/pixivd.d
+++ /dev/null
@@ -1,802 +0,0 @@
-/**
- * Examples:
- * ---
- * import std.file : getcwd;
- * import std.stdio : writefln;
- *
- * import pixivd;
- *
- * int main()
- * {
- *     // To avoid using your account, pass anything (apart from null).
- *     // By doing this, you will be limited to public only illustrations.
- *     Client client = Client("MyPHPSessionID");
- *
- *     Illustration illust = client.fetchIllustration("87445220");
- *     writefln("Downloading %s", illust.title);
- *
- *     // You can specify the size to download, the default is Size.original.
- *     illust.download(getcwd(), Size.original);
- *
- *     return 0;
- * }
- * ---
- */
-module pixivd;
-
-import std.array;
-import std.datetime;
-import std.datetime.systime;
-import std.file;
-import std.format;
-import std.json;
-import std.net.curl;
-import std.path;
-import std.stdio;
-import std.string;
-import std.typecons;
-import std.zip;
-
-import graphicsmagick_c.magick;
-
-struct Client {
-    /**
-     * The language you'd like the translations to be in.
-     */
-    string lang = "en";
-
-    this(string sessionID)
-    {
-        m_sessionID = sessionID;
-        m_pixivConnection = refCounted(HTTP());
-        m_pixivConnection.addRequestHeader("Accept", "application/json");
-        m_pixivConnection.addRequestHeader("Host", "www.pixiv.net");
-        m_pixivConnection.addRequestHeader("Referer", "https://www.pixiv.net/");
-        m_pixivConnection.setUserAgent("Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Firefix/91.0");
-        m_pixivConnection.setCookie("PHPSESSID=" ~ sessionID);
-    }
-
-    /**
-     * Fetch the metadata for the specified illustration id.
-     */
-    Illustration fetchIllustration(string id)
-    {
-        auto jsonResponse = appender!string;
-
-        m_pixivConnection.url = format!"https://www.pixiv.net/ajax/illust/%s?lang=%s"(id, lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            jsonResponse.put(data);
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue illustJSON;
-
-        illustJSON = parseJSON(jsonResponse.data());
-
-        return Illustration.fromJSON(illustJSON, &this);
-    }
-
-    Ugoira fetchUgoiraMeta(string id)
-    {
-        auto jsonResponse = appender!string;
-
-        m_pixivConnection.url = format!"https://www.pixiv.net/ajax/illust/%s/ugoira_meta?lang=%s"(id, lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            jsonResponse.put(data);
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue ugoiraJson;
-
-        ugoiraJson = parseJSON(jsonResponse.data());
-
-        return Ugoira.fromJson(ugoiraJson, &this);
-    }
-
-    /**
-     * Fetch new illustrations from followed artists.
-     *
-     * A maximum of 60 illustrations are returned in one response.
-     */
-    long[] fetchIllustrationsFollowing(long page = 1, DailyMode mode = DailyMode.all)
-    {
-        auto app = appender!string();
-
-        m_pixivConnection.url =
-            format!"https://www.pixiv.net/ajax/follow_latest/illust?p=%d&mode=%s&lang=%s"(page, mode, lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            app.put(data);
-            return data.length;
-        };
-        m_pixivConnection.perform();
-
-        JSONValue json = parseJSON(app.data());
-
-        static if (__VERSION__ < 2083L) {
-            if (JSON_TYPE.TRUE == json["error"].type) {
-                throw new Exception(json["message"].str);
-            }
-        } else {
-            if (true == json["error"].boolean) {
-                throw new Exception(json["message"].str);
-            }
-        }
-
-        JSONValue body_ = json["body"];
-        JSONValue[] jsonIDS = body_["page"]["ids"].array;
-
-        long[] ids = new long[jsonIDS.length];
-        foreach (i, id; jsonIDS) {
-            ids[i] = id.integer;
-        }
-
-        return ids;
-    }
-
-    UserProfile fetchProfileAll(string id)
-    {
-        auto rawResponse = appender!string;
-
-        m_pixivConnection.url = format!"https://www.pixiv.net/ajax/user/%s/profile/all?lang=%s"(id, lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            rawResponse ~= data;
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue jsonResponse = parseJSON(rawResponse.data());
-
-        UserProfile up = UserProfile.fromJson(jsonResponse);
-
-        return up;
-    }
-
-    FullUser fetchUser(string id)
-    {
-        auto rawResponse = appender!string;
-
-        m_pixivConnection.url = format!"https://www.pixiv.net/ajax/user/%s?full=1&lang=%s"(id, lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            rawResponse ~= data;
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue fullUserJson = parseJSON(rawResponse.data());
-
-        FullUser user = FullUser.fromJSON(fullUserJson);
-
-        return user;
-    }
-
-    private string getUserId()
-    {
-        auto tumengResponse = appender!string;
-        m_pixivConnection.url = "https://www.pixiv.net/ajax/linked_service/tumeng?page=1";
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            tumengResponse ~= data;
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue json = parseJSON(tumengResponse.data());
-
-        if (mixin(compatJsonTrue!("json", `["error"]`))) {
-            throw new Exception(json["message"].str);
-        }
-
-        if ("page" in json["body"] && "user" in json["body"]["page"]) {
-            JSONValue user = json["body"]["page"]["user"];
-
-            if ("id" in user)
-                return user["id"].str;
-            else
-                return "";
-        }
-
-        return "";
-    }
-
-    string[] fetchFollowing(int offset, int limit, long* total, string rest = "show")
-    {
-        auto rawResponse = appender!string;
-
-        string id = getUserId();
-
-        if ("" == id)
-            throw new Exception("Couldn't determine user id");
-
-        m_pixivConnection.url = format!"https://www.pixiv.net/ajax/user/%s/following?offset=%d&limit=%d&rest=%s&lang=%s"
-            (id, offset, limit, rest, this.lang);
-        m_pixivConnection.onReceive = (ubyte[] data) {
-            rawResponse ~= data;
-            return data.length;
-        };
-
-        m_pixivConnection.perform();
-
-        JSONValue json = parseJSON(rawResponse.data());
-
-        if (mixin(compatJsonTrue!("json", `["error"]`))) {
-            throw new Exception(json["message"].str);
-        }
-
-        string[] ids = new string[limit];
-
-        foreach(idx, jsonValue; json["body"]["users"].array) {
-            ids[idx] = jsonValue["userId"].str;
-        }
-
-        if (null !is total)
-            *total = json["body"]["total"].integer;
-
-        return ids;
-    }
-
-    @property RefCounted!HTTP pixivConnection()
-    {
-        return m_pixivConnection;
-    }
-
-    private string m_sessionID;
-    private RefCounted!HTTP m_pixivConnection;
-}
-
-enum ContentType {
-    illustration,
-    manga = 1,
-    ugoira = 2,
-    novel,
-}
-
-/**
- * This enum represents the possible image sizes that can be downloaded.
- * Size.original will provide the best quality image.
- */
-enum Size {
-    mini = "mini",
-    original = "original",
-    regular = "regular",
-    small = "small",
-    thumb = "thumb",
-}
-
-/**
- * The mode for downloading daily illustrations.
- */
-enum DailyMode : string {
-    all = "all",
-    r18 = "r18",
-    safe = "safe",
-}
-
-struct Illustration {
-    immutable long bookmarkCount;
-    immutable long commentCount;
-    immutable SysTime createDate;
-    immutable string description;
-    immutable long height;
-    immutable string id;
-    immutable string[string] imageURLs;
-    // immutable bool isBookmarked;
-    // immutable bool isMuted;
-    // immutable string[string][] metaPages;
-    immutable long pageCount;
-    immutable long restrict;
-    // immutable long sanityLevel; // is this 'sl'?
-    // ??series??
-    // immutable string[string][] tags;
-    immutable long viewCount;
-    immutable string title;
-    // ??tools??
-    ContentType type;
-    immutable User user;
-    // immutable bool visible;
-    immutable long width;
-    immutable long xRestrict;
-
-    private Client* m_client;
-
-    ~this()
-    {
-        m_client = null;
-    }
-
-    static Illustration fromJSON(JSONValue json, Client* c)
-    {
-        static if (__VERSION__ < 2083L) {
-            if (JSON_TYPE.TRUE == json["error"].type) {
-                throw new Exception(json["message"].str);
-            }
-        } else {
-            if (true == json["error"].boolean) {
-                throw new Exception(json["message"].str);
-            }
-        }
-
-        scope body_ = json["body"];
-        scope urls = body_["urls"];
-
-        auto illust = Illustration(
-            body_["bookmarkCount"].integer,
-            body_["commentCount"].integer,
-            SysTime.fromISOExtString(body_["createDate"].str),
-            body_["description"].str,
-            body_["height"].integer,
-            body_["id"].str,
-            [
-                "mini": urls["mini"].str,
-                "original": urls["original"].str,
-                "regular": urls["regular"].str,
-                "small": urls["small"].str,
-                "thumb": urls["thumb"].str,
-            ],
-            body_["pageCount"].integer,
-            body_["restrict"].integer,
-            body_["viewCount"].integer,
-            body_["title"].str,
-            cast(ContentType)body_["illustType"].integer,
-            User(
-                body_["userAccount"].str,
-                body_["userId"].str,
-                body_["userName"].str,
-            ),
-            body_["width"].integer,
-            body_["xRestrict"].integer,
-        );
-
-        illust.m_client = c;
-
-        return illust;
-    }
-
-
-    /**
-     * Download the illustration to the desired directory.
-     *
-     * If the illustration has multiple pages, a directory will be created and
-     * the images placed inside.
-     *
-     * Params:
-     *   directory = The directory to download the illustration to.
-     *   size      = The size of the image to download.
-     *   filename  = The filename of a single-page illustration, or the
-     *               sub-directory name of a multi-page illustration. Do
-     *               $(B not) include an extension. This defaults to the
-     *               illustration id.
-     *
-     * Throws:
-     *   FileException if the directory does not exist.
-     */
-    void download(string directory, bool overwrite = false, Size size = Size.original, string filename = null)
-    {
-        immutable owd = getcwd();
-        chdir(directory);
-        scope(exit) chdir(owd);
-
-
-        if (null is filename)
-           filename = id;
-
-        if (1 == pageCount) {
-            downloadImage(imageURLs[size], filename, overwrite);
-        } else {
-            downloadPagedImage(size, filename, overwrite);
-        }
-    }
-
-    /// Download an image which contains multiple pages.
-    private void downloadPagedImage(Size size, string filename, bool overwrite)
-    {
-        mkdirRecurse(filename);
-        scope owd = getcwd();
-        chdir(filename);
-        scope(exit) chdir(owd);
-
-        auto jsonResponse = appender!string;
-
-        m_client.pixivConnection.url = format!"https://www.pixiv.net/ajax/illust/%s/pages?lang=%s"(id, m_client.lang);
-        m_client.pixivConnection.onReceive = (ubyte[] data) {
-            jsonResponse.put(data);
-            return data.length;
-        };
-        m_client.pixivConnection.perform();
-
-        auto pagesJSON = parseJSON(jsonResponse.data());
-        auto pages = pagesJSON["body"].array;
-
-        foreach (JSONValue page; pages) {
-            string url = page["urls"][size].str;
-            downloadImage(url, baseName(url).stripExtension, overwrite);
-        }
-    }
-
-    /// Download a single-paged image.
-    private void downloadImage(string url, string filename, bool overwrite)
-    {
-        const fullFilename = filename ~ url.extension;
-
-        if (false == overwrite && true == exists(fullFilename)) {
-            throw new FileExistsException(fullFilename);
-        }
-
-        auto imageFile = File(fullFilename, "w+");
-        m_client.pixivConnection.url = url;
-        m_client.pixivConnection.onReceive = (ubyte[] data) {
-            imageFile.rawWrite(data);
-            return data.length;
-        };
-        m_client.pixivConnection.perform();
-        /* Close the file early so setTimes() works */
-        imageFile.close();
-
-        setTimes(fullFilename, createDate, createDate);
-    }
-}
-
-class FileExistsException : Exception {
-    this(string filename) {
-        super(format!"File already exists: %s"(msg));
-    }
-}
-
-class Ugoira
-{
-    struct Frame
-    {
-        const string file;
-        const long delay;
-    }
-
-    string src() const
-    {
-        return m_src;
-    }
-
-    static Ugoira fromJson(const ref JSONValue js, Client *c)
-    {
-        if (mixin(compatJsonTrue!("js", `["error"]`))) {
-            throw new Exception(js["message"].str);
-        }
-
-        static if (__VERSION__ < 2083L) {
-            JSON_TYPE arrayType = JSON_TYPE.ARRAY;
-        } else {
-            JSONType arrayType = JSONType.array;
-        }
-
-        auto ugoira = new Ugoira();
-        ugoira.m_client = c;
-
-        if ("body" !in js)
-            throw new Exception(`JSON response has no "body".`);
-
-        if ("src" in js["body"]) {
-            ugoira.m_src = js["body"]["src"].str;
-        }
-
-        if ("originalSrc" in js["body"]) {
-            ugoira.m_originalSrc = js["body"]["originalSrc"].str;
-        }
-
-        if ("mime_type" in js["body"]) {
-            ugoira.m_mimeType = js["body"]["mime_type"].str;
-        }
-
-        if ("frames" in js["body"]) {
-            auto frames = js["body"]["frames"].array;
-            foreach (const ref JSONValue frame; frames) {
-                ugoira.m_frames ~= Frame(frame["file"].str, frame["delay"].integer);
-            }
-        }
-
-        return ugoira;
-    }
-
-    //~ void download(string directory, bool original = true) {
-
-    //~ }
-
-    void downloadAsGif(string directory, bool original = true, string fileName = null, bool overwrite = false /* ignored */) {
-        string owd = getcwd();
-        chdir(directory);
-        scope(exit) chdir(owd);
-
-        if (null is fileName) {
-            string id = split(m_src, "/")[$ - 1].split("_")[0];
-            fileName = id ~ ".gif";
-        }
-
-        string zipFileName;
-
-        if (original) {
-            m_client.m_pixivConnection.url = m_originalSrc;
-            zipFileName = baseName(m_originalSrc);
-        } else {
-            m_client.m_pixivConnection.url = m_src;
-            zipFileName = baseName(m_src);
-        }
-
-        File zipFile = File(zipFileName, "w+");
-        scope(exit) remove(zipFileName);
-
-        m_client.m_pixivConnection.onReceive = (ubyte[] data) {
-            zipFile.rawWrite(data);
-            return data.length;
-        };
-
-        m_client.m_pixivConnection.perform();
-        zipFile.close();
-
-        /*
-         * GraphicsMagick Initialization.
-         */
-        InitializeMagick(null);
-        ExceptionInfo exception;
-        Image *image;
-        Image *images;
-
-        ImageInfo *imageInfo;
-
-        GetExceptionInfo(&exception);
-        imageInfo = CloneImageInfo(null);
-        images = NewImageList();
-
-        auto archive = new ZipArchive(read(zipFileName));
-        /* so we can remove the individual files later */
-        string[] amNames = new string[archive.totalEntries];
-        size_t idx = 0;
-
-        /*
-         * Since the order of members isn't guaranteed, we just extract
-         * all the files.
-         */
-        foreach(name, am; archive.directory) {
-            archive.expand(am);
-            File(name, "w+").rawWrite(am.expandedData);
-            amNames[idx] = name;
-            idx += 1;
-        }
-
-        foreach (frame; m_frames) {
-            assert(exists(frame.file), "File '" ~ frame.file ~ "' does not exist.");
-
-            size_t length = frame.file.length > MaxTextExtent ? MaxTextExtent : frame.file.length;
-            imageInfo.filename[0 .. length] = frame.file;
-            imageInfo.filename[length] = '\0';
-
-            image = ReadImage(imageInfo, &exception);
-            if (UndefinedException != exception.severity) {
-                CatchException(&exception);
-                throw new Exception( cast(string)(fromStringz(exception.description)) );
-            }
-            if (null !is image) {
-                image.delay = cast(uint)frame.delay / 10;
-                image.dispose = PreviousDispose;
-                /* Infinite loop */
-                image.iterations = 0;
-                AppendImageToList(&images, image);
-            }
-        }
-
-        imageInfo.adjoin = MagickTrue;
-
-        WriteImages(imageInfo, images, &fileName[0], &exception);
-        if (UndefinedException != exception.severity) {
-            CatchException(&exception);
-            throw new Exception( cast(string)(fromStringz(exception.description)) );
-        }
-
-        foreach(name; amNames)
-            remove(name);
-
-        DestroyImageList(images);
-        DestroyImageInfo(imageInfo);
-        DestroyExceptionInfo(&exception);
-        DestroyMagick();
-    }
-
-private:
-    string m_mimeType;
-    string m_originalSrc;
-    string m_src;
-    Frame[] m_frames;
-    Client *m_client;
-}
-
-class UserProfile
-{
-    static UserProfile fromJson(const ref JSONValue js)
-    {
-        if (mixin(compatJsonTrue!("js", `["error"]`))) {
-            throw new Exception(js["message"].str);
-        }
-
-        auto up = new UserProfile();
-
-        if ("body" !in js)
-            throw new Exception("JSON response has no \"body\".");
-
-        /* NOTE: illusts, manga, etc. are arrays if there are none. */
-
-        static if (__VERSION__ < 2083L) {
-            JSON_TYPE arrayType = JSON_TYPE.ARRAY;
-        } else {
-            JSONType arrayType = JSONType.array;
-        }
-
-        if ("illusts" in js["body"] && arrayType != js["body"]["illusts"].type) {
-            foreach (k, v; js["body"]["illusts"].objectNoRef) {
-                up.illusts[k] = (v.isNull ? null : v.str);
-            }
-        }
-
-        if ("manga" in js["body"] && arrayType != js["body"]["manga"].type) {
-            foreach (k, v; js["body"]["manga"].objectNoRef) {
-                up.manga[k] = (v.isNull ? null : v.str);
-            }
-        }
-
-        return up;
-    }
-
-    string[string] illusts;
-    string[string] manga;
-}
-
-struct User {
-    /// The user's account name.
-    immutable string account;
-    /// User account ID
-    immutable string id;
-    /// The display name of the account
-    immutable string name;
-}
-
-private template compatJsonTrue(string jsonVarName, string obj)
-{
-static if (__VERSION__ < 2083L) {
-    const char[] compatJsonTrue = jsonVarName ~ obj ~ ".type == JSON_TYPE.TRUE";
-} else {
-    const char[] compatJsonTrue = jsonVarName ~ obj ~ ".boolean == true";
-}
-}
-
-class FullUser
-{
-public:
-
-    @property string id() const
-    {
-        return m_id;
-    }
-
-    @property string name() const
-    {
-        return m_name;
-    }
-
-    @property string image() const
-    {
-        return m_imageURL;
-    }
-
-    @property string imageBig() const
-    {
-        return m_imageBigURL;
-    }
-
-    @property bool premium() const
-    {
-        return m_premium;
-    }
-
-    @property bool isFollowed() const
-    {
-        return m_isFollowed;
-    }
-
-    static FullUser fromJSON(const ref JSONValue json)
-    {
-        auto user = new FullUser();
-
-        if (mixin(compatJsonTrue!("json", `["error"]`))) {
-            throw new Exception(json["message"].str);
-        }
-
-        if ("userId" in json["body"])
-            user.id = json["body"]["userId"].str;
-        else
-            user.id = null;
-
-        if ("name" in json["body"])
-            user.name = json["body"]["name"].str;
-        else
-            user.name = null;
-
-        if ("image" in json["body"])
-            user.imageURL = json["body"]["image"].str;
-        else
-            user.imageURL = null;
-
-        if ("imageBig" in json["body"])
-            user.imageBigURL = json["body"]["imageBig"].str;
-        else
-            user.imageBigURL = null;
-
-        if ("premium" in json["body"])
-            user.premium = mixin(compatJsonTrue!("json", `["body"]["premium"]`));
-
-        if ("isFollowed" in json["body"])
-            user.isFollowed = mixin(compatJsonTrue!("json", `["body"]["isFollowed"]`));
-
-        return user;
-    }
-
-package:
-
-    @property void id(string id_)
-    {
-        m_id = id_;
-    }
-
-    @property void name(string name_)
-    {
-        m_name = name_;
-    }
-
-    @property void imageURL(string image)
-    {
-        m_imageURL = image;
-    }
-
-    @property void imageBigURL(string imageBig)
-    {
-        m_imageBigURL = imageBig;
-    }
-
-    @property void premium(bool premium_)
-    {
-        m_premium = premium_;
-    }
-
-    @property void isFollowed(bool followed)
-    {
-        m_isFollowed = followed;
-    }
-
-private:
-    string m_id;
-    string m_name;
-    string m_imageURL;
-    string m_imageBigURL;
-    bool m_premium;
-    bool m_isFollowed;
-    bool m_isMyPixiv;
-    bool m_isBlocking;
-    /* background */
-    /* sketchLiveId */
-    long m_partial;
-    bool m_acceptRequest;
-    /* sketchLives[] */
-    long m_following;
-    bool m_followedBack;
-    string m_comment;
-    string m_commentHTML;
-    string m_webpage;
-    /* social */
-    /* region */
-    /* birthDay */
-    /* gender */
-    /* job */
-    /* workspace */
-    bool m_official;
-    /* group */
-}

--- /dev/null
+++ b/source/pixivd/client.d
@@ -0,0 +1,995 @@
+module pixivd.client;
+
+import core.sync.mutex : Mutex;
+
+import std.array : appender;
+import std.format : format;
+import std.json;
+import std.net.curl : HTTP;
+
+import graphicsmagick_c;
+import graphicsmagick_c.magick.api;
+
+import pixivd.enums;
+import pixivd.mixins;
+import pixivd.types;
+
+public enum PixivDVersion = 0.7;
+public enum PixivDVersionString = "0.7";
+
+/**
+ *
+ * The main client for performing pixiv API requests.
+ *
+ * ```
+ * // Create without setting the PHPSESSID
+ * auto client = new Client();
+ * // Set the PHPSESSID
+ * client.phpsessid = "COOKIE_VALUE_HERE";
+ * ```
+ */
+class Client
+{
+private:
+
+    string m_phpsessid;
+    HTTP m_client;
+
+    bool m_isGMInitialized = false;
+
+public:
+
+    @property string phpsessid() const
+    {
+        return m_phpsessid;
+    }
+
+    @property void phpsessid(string sessionID)
+    {
+        m_phpsessid = sessionID;
+        m_client.setCookie("PHPSESSID=" ~ m_phpsessid);
+    }
+
+    /**
+     * Create a new instance of Client, providing a PHPSESSID to begin
+     * with.
+     *
+     * Params:
+     *  - phpsessid The PHPSESSID Cookie from a Web Browser.
+     */
+    this(string phpsessid)
+    {
+        m_phpsessid = phpsessid;
+        m_client = HTTP();
+        m_client.addRequestHeader("Accept", "application/json, */*");
+        m_client.addRequestHeader("Host", "www.pixiv.net");
+        m_client.addRequestHeader("Referer", "https://www.pixiv.net/");
+        m_client.setUserAgent(
+            "Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Firefix/91.0");
+        if ("" != m_phpsessid)
+        {
+            m_client.setCookie("PHPSESSID=" ~ m_phpsessid);
+        }
+    }
+
+    this()
+    {
+        this("");
+    }
+
+    ~this()
+    {
+        m_client.shutdown();
+        if (true == m_isGMInitialized) {
+            DestroyMagick();
+	    }
+    }
+
+    /**
+     * Fetch an illustration
+     *
+     * Throws:
+     *  - ConvException if we failed to parse the `id` as a string.
+     *  - PixivExcetpion if something happened when parsing the response.
+     */
+    Illustration fetchIllustration(string id)
+    {
+        auto response = appender!string;
+
+        m_client.url = format!"https://www.pixiv.net/ajax/illust/%s"(id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+
+        m_client.perform();
+
+        JSONValue json = parseJSON(response.data());
+
+        return Illustration.fromJSON(json);
+    }
+
+    /** 
+     * Fetch an illustration.
+     *
+     * Params:
+     *   thumb = A Thumbnail for the image you want to fetch.
+     * Returns: A complete Image instance for the provided Thumbnail.
+     */
+    Illustration fetchIllustration(Thumbnail thumb)
+    {
+        auto response = appender!string;
+
+        m_client.url = format!"https://www.pixiv.net/ajax/illust/%s"(thumb.id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+
+        m_client.perform();
+
+        JSONValue json = parseJSON(response.data());
+
+        return Illustration.fromJSON(json);
+    }
+
+    ///
+    unittest
+    {
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        import std.net.curl : CurlTimeoutException;
+        import std.stdio : writefln;
+
+        auto client = new Client();
+
+        try
+        {
+            Illustration illust = client.fetchIllustration("95917058");
+            assert("95917058" == illust.id);
+            assert("user_hccs8584" == illust.userAccount);
+
+            writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+            Thread.sleep(3.seconds); // Try not to abuse the server.
+        }
+        catch (CurlTimeoutException cte)
+        {
+            // It's possible that there is no internet connection
+            // or that Pixiv is down, so we won't error.
+            writefln("CurlTimeoutException: %s", cte.msg);
+        }
+    }
+
+    /// ditto
+    Illustration fetchIllustration(size_t id)
+    {
+        import std.conv : to;
+
+        return fetchIllustration(to!string(id));
+    }
+
+    ///
+    unittest
+    {
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        import std.net.curl : CurlTimeoutException;
+        import std.stdio : writefln;
+
+        auto client = new Client();
+
+        try
+        {
+            Illustration illust = client.fetchIllustration(95917058);
+            assert("95917058" == illust.id);
+            assert("user_hccs8584" == illust.userAccount);
+
+            writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+            Thread.sleep(3.seconds); // Try not to abuse the server.
+        }
+        catch (CurlTimeoutException cte)
+        {
+            // It's possible that there is no internet connection
+            // or that Pixiv is down, so we won't error.
+            writefln("CurlTimeoutException: %s", cte.msg);
+        }
+    }
+
+    Thumbnail[] fetchIllustrationsFollowing(long page = 1, DailyMode mode = DailyMode.all, string lang = "en")
+    {
+        auto res = appender!string;
+
+        m_client.url = format!"https://www.pixiv.net/ajax/follow_latest/illust?p=%d&mode=%s&lang=%s"(page, mode, lang);
+        m_client.onReceive = (ubyte[] data) { res.put(data); return data.length; };
+
+        m_client.perform();
+
+        JSONValue json = parseJSON(res.data());
+
+        static if (__VERSION__ < 2083L)
+        {
+            if (JSON_TYPE.TRUE == json["error"].type)
+            {
+                throw new PixivJSONException(json["message"].str);
+            }
+        }
+        else
+        {
+            if (true == json["error"].boolean)
+            {
+                throw new PixivJSONException(json["message"].str);
+            }
+        }
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("No \"body\" in returned JSON.");
+        }
+
+        auto body_ = json["body"];
+
+        if ("thumbnails" !in body_)
+        {
+            throw new PixivJSONException("No \"thumbnails\" in fetchIllustrationsFollowing");
+        }
+
+        Thumbnail[] thumbnails;
+        auto jsonThumbs = body_["thumbnails"]["illust"].array;
+
+        foreach (ref thumb; jsonThumbs)
+        {
+            thumbnails ~= Thumbnail.fromJSON(thumb);
+        }
+
+        return thumbnails;
+    }
+
+    ///
+    unittest
+    {
+        import std.net.curl : CurlTimeoutException;
+        import std.process : environment;
+        import std.stdio : writefln;
+
+        auto phpsessid = environment.get("PIXIV_PHPSESSID");
+        if (null is phpsessid)
+        {
+            // Won't test as there is no PHPSESSID.
+            return;
+        }
+
+        auto client = new Client(phpsessid);
+
+        try
+        {
+            import core.thread : Thread;
+            import core.time : seconds;
+
+            Thumbnail[] thumbs = client.fetchIllustrationsFollowing();
+            assert(thumbs.length > 0);
+
+            writefln("%s -- Sleeping for 3 seconds.", __PRETTY_FUNCTION__);
+            Thread.sleep(3.seconds);
+        }
+        catch (CurlTimeoutException cte)
+        {
+            // It's possible that there is no internet connection
+            // or that Pixiv is down, so we won't error.
+            writefln("CurlTimeoutException: %s", cte.msg);
+        }
+    }
+
+    /** 
+     * Fetch a list of Users that the logged in user follows.
+     *
+     * Params:
+     *   offset = [in] The number of accounts to offset the retrieval by
+     *   limit = [in] Limit the number of accounts returned
+     *   show = [in] Whether to retrieve public ("show"), or private ("hide") followings.
+     * Returns: An array of `User`.
+     */
+    User[] fetchFollowing(int offset, int limit = 24, string rest = "show")
+    {
+        long numAccounts;
+        return fetchFollowing(offset, numAccounts, limit, rest);
+    }
+
+    /** 
+     * Fetch a list of Users that the logged in user follows.
+     *
+     * An optional `totalNumberOfAccounts` parameter allows you to store the total number
+     * of accounts the user follows (the value differs depending on `rest`).
+     *
+     * Params:
+     *   offset = The number of accounts to offset the retrieval by.
+     *   totalNumberOfAccounts = [out] The total number of accounts the user follows (depends on `rest`).
+     *   limit = Limit the number of accounts returned (default 24).
+     *   show = [in] Whether to retrieve public ("show"), or private ("hide") followings.
+     */
+    User[] fetchFollowing(in int offset, out long totalNumberOfAccounts, in int limit = 24, in string rest = "show")
+    {
+        import std.string : split;
+
+        auto response = appender!string;
+
+        if ("" == m_phpsessid)
+        {
+            throw new Exception("PHPSESSID not set. Please use `.phpsessid = `");
+        }
+
+        string id = m_phpsessid.split('_')[0];
+        if ("" == id)
+        {
+            throw new Exception("Could not determine user id");
+        }
+
+        m_client.url = "https://www.pixiv.net/ajax/user/%s/following?offset=%d&limit=%d&rest=%s&lang=en".format(id,
+            offset, limit, rest);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+        m_client.perform();
+
+        auto json = parseJSON(response[]);
+        if (mixin(mixCheckJsonError!("json")))
+        {
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("No \"body\" in returned JSON.");
+        }
+
+        User[] users;
+        totalNumberOfAccounts = json["body"]["total"].integer;
+        auto jsonUsers = json["body"]["users"].array;
+        foreach (ref jsonUser; jsonUsers)
+        {
+            users ~= User.fromJSON(jsonUser);
+        }
+
+        return users;
+    }
+
+    ///
+    unittest
+    {
+        import std.net.curl : CurlTimeoutException;
+        import std.process : environment;
+        import std.stdio : writefln;
+
+        auto sessid = environment.get("PIXIV_PHPSESSID");
+        if (null is sessid)
+        {
+            // test requires authorisation, so will skip.
+            return;
+        }
+
+        auto client = new Client(sessid);
+        try
+        {
+            User[] users = client.fetchFollowing(0);
+            assert(0 == users.length, "No users returned (assumes you follow anyone)");
+
+            foreach (user; users)
+            {
+                assert("" != user.userId);
+                assert("" != user.userName);
+            }
+        }
+        catch (CurlTimeoutException cte)
+        {
+            // Possible that there is no internet connection
+            // or that pixiv is down.
+            writefln("CurlTimeoutException: %s", cte.msg);
+        }
+    }
+
+    FullUser fetchUser(User user)
+    {
+        return fetchUser(user.userId);
+    }
+
+    FullUser fetchUser(string id)
+    {
+        auto response = appender!string;
+
+        m_client.url = "https://www.pixiv.net/ajax/user/%s?full=1&lang=en".format(id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+
+        m_client.perform();
+
+        auto json = parseJSON(response.data());
+        if (mixin(mixCheckJsonError!("json")))
+        {
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("JSON response contains no 'body'.");
+        }
+
+        return FullUser.fromJSON(json["body"]);
+    }
+
+    ///
+    unittest
+    {
+        import std.net.curl : CurlTimeoutException;
+
+        auto client = new Client();
+        FullUser user;
+
+        try
+        {
+            user = client.fetchUser("4938312");
+        }
+        catch (CurlTimeoutException cte)
+        {
+            import std.stdio : stderr;
+
+            stderr.writefln("%s -- Failed to connect to server: ", __PRETTY_FUNCTION__, cte.msg);
+            return; // exit test early.
+        }
+        assert("4938312" == user.userId, "user.userId != 4938312");
+        assert(false == user.following, "user.following != false");
+        assert(false == user.followed, "user.followed != false");
+    }
+    
+    UserBrief fetchUserAll(string id)
+    {
+        auto response = appender!string;
+
+        m_client.url = "https://www.pixiv.net/ajax/user/%s/profile/all".format(id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+
+        m_client.perform();
+
+        auto json = parseJSON(response.data());
+        if (mixin(mixCheckJsonError!("json")))
+        {
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("JSON response contains no 'body'.");
+        }
+
+        return UserBrief.fromJSON(json["body"]);
+    }
+
+    /** 
+     * Download an Illustration (incl. manga, novels, ugoira).
+     *
+     * Params:
+     *   illust = Illustration to download
+     *   directory = Directory where to save the Illustration
+     *   overwrite = Overwrite existing file(s)?
+     */
+    void downloadIllust(Illustration illust, string directory, bool overwrite = false)
+    {
+        switch (illust.type)
+        {
+        case ContentType.illustration:
+            _downloadIllustration(illust, directory, overwrite);
+            break;
+        case ContentType.manga:
+            _downloadManga(illust, directory, overwrite);
+            break;
+        case ContentType.novel:
+            _downloadNovel(illust, directory, overwrite);
+            break;
+        case ContentType.ugoira:
+            _downloadUgoira(illust, directory, overwrite);
+            break;
+        default:
+            assert(0, "Unsupported Content Type for illustration " ~ illust.id);
+        }
+    }
+
+    ///
+    unittest
+    {
+        import std.datetime.systime : SysTime;
+        import std.file : exists, getcwd, getTimes, remove;
+        import std.path : extension;
+        import std.stdio : File;
+
+        auto client = new Client();
+
+        try
+        {
+            // Download a single illustration
+            Illustration illust = client.fetchIllustration("82631500");
+            assert("フフフ" == illust.title, "Incorrect illustration title");
+            assert(1 == illust.pages, "Incorrect number of pages");
+            assert("2020-06-28T15:13:22+00:00" == illust.createDate, "Incorrect createDate");
+
+            const fileName = illust.id ~ illust.urls["original"].extension;
+
+            client.downloadIllust(illust, getcwd(), true);
+
+            assert(true == exists(fileName), "true != exists(fileName)");
+            File imageFile = File(fileName, "r");
+            scope (exit)
+            {
+                remove(fileName);
+            }
+
+            SysTime createDate = SysTime.fromISOExtString(illust.createDate);
+            SysTime oAccessTime;
+            SysTime oModificationTime;
+            getTimes(fileName, oAccessTime, oModificationTime);
+
+            assert(oAccessTime == createDate, "oAccessTime != createDate");
+            assert(oModificationTime == createDate, "oModificationTIme != createDate");
+            assert(imageFile.size > 0, "illust file size is not 0");
+        }
+        catch (Exception e)
+        {
+            assert(false, e.msg);
+        }
+
+        import std.stdio : stderr;
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        stderr.writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+        Thread.sleep(3.seconds);
+    }
+
+    ///
+    unittest
+    {
+        import std.file : chdir, exists, getcwd, rmdirRecurse;
+        import std.format : format;
+        import std.net.curl : CurlTimeoutException;
+        import std.path : extension;
+
+        auto client = new Client();
+
+        try
+        {
+            Illustration illust = client.fetchIllustration("81573844");
+
+            assert("過去絵ミクさん" == illust.title, "Incorrect illustration title");
+            assert(2 == illust.pages, "Incorrect number of pages");
+
+            client.downloadIllust(illust, getcwd(), true);
+            const ext = extension(illust.urls["original"]);
+
+            chdir(illust.id);
+
+            foreach (i; 0 .. illust.pages)
+            {
+                const filename = format!"%s_p%d%s"(illust.id, i, ext);
+                assert(exists(filename), "Multi-paged image not downloading all pages");
+            }
+
+            chdir("..");
+
+            rmdirRecurse(illust.id);
+        }
+        catch (CurlTimeoutException cte)
+        {
+            // PASS
+            import std.stdio : stderr;
+
+            stderr.writefln("TIMEOUT: %s", cte.msg);
+        }
+
+        import std.stdio : stderr;
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        stderr.writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+        Thread.sleep(3.seconds);
+    }
+
+    /** 
+     * Fetch metadata for an ugoira (moving illustration).
+     *
+     * Params:
+     *   illust = The illustration (which is an Ugoira) to fetch the metadata for
+     * Returns: An Ugoira instance containing the source URL and Frame durations for the ugoira.
+     */
+    Ugoira fetchUgoiraMeta(Illustration illust)
+    {
+        return fetchUgoiraMeta(illust.id);
+    }
+
+    /** 
+     * Fetch metadata for an ugoira (moving illustration).
+     *
+     * Params:
+     *   id = The illustration id to fetch the metadata for.
+     * Returns: An Ugoira instance containing the source URL and Frame durations for the ugoira.
+     */
+    Ugoira fetchUgoiraMeta(string id)
+    {
+        auto response = appender!string;
+
+        m_client.url = format!"https://www.pixiv.net/ajax/illust/%s/ugoira_meta"(id);
+        m_client.onReceive = (ubyte[] data) {
+            response ~= data;
+            return data.length;
+        };
+        m_client.perform();
+
+        JSONValue json = parseJSON(response.data());
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("No \"body\" in JSON response.");
+        }
+        return Ugoira.fromJSON(json);
+    }
+
+    ///
+    unittest
+    {
+        auto client = new Client();
+
+        Ugoira ugoira = client.fetchUgoiraMeta("103331804");
+
+        assert("image/jpeg" == ugoira.getMimeType());
+        assert("https://i.pximg.net/img-zip-ugoira/img/2022/12/04/16/13/51/103331804_ugoira600x600.zip" ==
+                ugoira.getSource());
+
+        import std.stdio : stderr;
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        stderr.writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+        Thread.sleep(3.seconds);
+    }
+
+private:
+
+    void _downloadIllustration(Illustration illust, string directory, bool overwrite)
+    {
+        import std.file : getcwd, chdir, mkdirRecurse, exists;
+
+        if (false == exists(directory))
+        {
+            mkdirRecurse(directory);
+        }
+
+        const originalDir = getcwd();
+        chdir(directory);
+
+        if (1 == illust.pages)
+        {
+            _downloadSingleIllust(illust, overwrite);
+        }
+        else
+        {
+            _downloadPagedIllust(illust, overwrite);
+        }
+
+        chdir(originalDir);
+    }
+
+    void _downloadSingleIllust(Illustration illust, bool overwrite)
+    {
+        import std.datetime.systime;
+
+        import std.file : FileException, exists, setTimes;
+        import std.path : extension;
+        import std.stdio : File;
+
+        const baseFileName = illust.id ~ illust.urls["original"].extension;
+
+        if (true == exists(baseFileName) && false == overwrite)
+        {
+            throw new FileException(baseFileName, "File already exists");
+        }
+
+        File imageFile = File(baseFileName, "w+");
+
+        m_client.url = illust.urls["original"];
+        m_client.onReceive = (ubyte[] data) {
+            imageFile.rawWrite(data);
+            return data.length;
+        };
+
+        m_client.perform();
+        imageFile.close();
+
+        SysTime createDate = SysTime.fromISOExtString(illust.createDate);
+
+        setTimes(baseFileName, createDate, createDate);
+    }
+
+    void _downloadPagedIllust(Illustration illust, bool overwrite)
+    {
+        import std.array : appender;
+        import std.file : chdir, exists, getcwd, mkdir;
+        import std.stdio : File;
+
+        if (false == exists(illust.id))
+        {
+            mkdir(illust.id);
+        }
+        const originalDir = getcwd();
+        chdir(illust.id);
+        scope (exit)
+            chdir(originalDir);
+
+        auto response = appender!string;
+
+        m_client.url = "https://www.pixiv.net/ajax/illust/%s/pages".format(illust.id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;
+        };
+        m_client.perform();
+
+        JSONValue json = parseJSON(response.data());
+        if (mixin(mixCheckJsonError!("json")))
+        {
+            throw new PixivJSONException(json["msg"].str);
+        }
+
+        if ("body" !in json)
+        {
+            throw new PixivJSONException("JSON response contains no 'body'.");
+        }
+
+        foreach (jsonobj; json["body"].array)
+        {
+            import std.path : baseName, stripExtension;
+
+            const url = jsonobj["urls"]["original"].str;
+            File img = File(baseName(url), "w+");
+
+            m_client.url = url;
+            m_client.onReceive = (ubyte[] data) {
+                img.rawWrite(data);
+                return data.length;
+            };
+
+            m_client.perform();
+            img.close();
+        }
+    }
+
+    void _downloadManga(Illustration illust, string directory, bool overwrite)
+    {
+        import std.array : appender;
+        import std.datetime : SysTime;
+        import std.file : FileException, chdir, getcwd, exists, mkdirRecurse, setTimes;
+        import std.stdio : File;
+        import std.path : baseName, buildPath;
+
+        if (false == exists(directory)) {
+            mkdirRecurse(directory);
+        }
+
+        immutable origDir = getcwd();
+        chdir(directory);
+        scope(exit) chdir(origDir);
+
+        if (false == exists(illust.id)) {
+            mkdirRecurse(illust.id);
+        }
+        chdir(illust.id);
+
+        auto response = appender!string;
+        m_client.url = "https://www.pixiv.net/ajax/illust/%s/pages".format(illust.id);
+        m_client.onReceive = (ubyte[] data) {
+            response.put(data);
+            return data.length;  
+        };
+
+        m_client.perform();
+
+        auto json = parseJSON(response.data());
+        if (mixin(mixCheckJsonError!("json"))){
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        auto bodyArr = json["body"].array;
+
+        foreach(obj; bodyArr) {
+            auto filename = baseName(obj["urls"]["original"].str);
+            if (true == exists(filename) && false == overwrite) {
+                throw new FileException(filename, "File already exists");
+            }
+            File outFile = File(filename, "w+");
+            m_client.url = obj["urls"]["original"].str;
+            m_client.onReceive = (ubyte[] data) {
+                outFile.rawWrite(data);
+                return data.length;
+            };
+            m_client.perform();
+            outFile.close();
+
+            SysTime createDate = SysTime.fromISOExtString(illust.createDate);
+
+            setTimes(filename, createDate, createDate);
+        }
+    }
+
+    void _downloadNovel(Illustration illust, string directory, bool overwrite)
+    {
+        throw new Exception("Unsupported media type: Novel");
+    }
+
+    void _downloadUgoira(Illustration illust, string directory, bool overwrite)
+    {
+        import core.stdc.string : strncpy;
+
+        import std.file : chdir, getcwd, mkdirRecurse, read, remove, rmdirRecurse, tempDir;
+        import std.format : format;
+        import std.path : baseName, buildPath;
+        import std.stdio : File;
+        import std.string : fromStringz;
+        import std.zip : ZipArchive, ArchiveMember;
+
+        // We want to download a GIF.
+        // To do this we:
+        //  1. Download the zip file for the Ugoira
+        //  2. Extract the zip file
+        //  3. Create an ImageList in GraphicsMagick
+        //  4. Append all the individual frames with the specific delay.
+        //  5. Save the ImageList as a GIF file.
+
+        // NOTE: There is no need to remove the individual files as all
+        // work takes place in a directory which is deleted at the end.
+
+        string gifFileName = illust.id ~ ".gif";
+
+        string originalDir = getcwd();
+        chdir(tempDir());
+
+        mkdirRecurse(illust.id);
+        chdir(illust.id);
+        scope (exit)
+        {
+            // We will likely be in the |directory| provided.
+            chdir(tempDir());
+            rmdirRecurse(illust.id);
+
+            chdir(originalDir);
+        }
+
+        Ugoira ugoira = fetchUgoiraMeta(illust);
+
+        string zipFileName = baseName(ugoira.getOriginalSource());
+
+        auto zipFile = File(zipFileName, "w+");
+
+        m_client.url = ugoira.getOriginalSource();
+        m_client.onReceive = (ubyte[] data) {
+            zipFile.rawWrite(data);
+            return data.length;
+        };
+
+        m_client.perform();
+        zipFile.close();
+
+        auto zip = new ZipArchive(read(zipFileName));
+
+        foreach (name, ArchiveMember am; zip.directory())
+        {
+            zip.expand(am);
+            File(name, "w+").rawWrite(am.expandedData());
+        }
+
+        if (false == m_isGMInitialized)
+        {
+
+            version (GMagick_Static)
+            {
+                // no-op
+            }
+            else
+            {
+                void* libgm;
+                GMSupport support = loadGraphicsMagick(libgm);
+
+                if (GMSupport.noLibrary == support)
+                {
+                    throw new PixivException("No GraphicsMagick library found.");
+                }
+            }
+
+            InitializeMagick(null);
+            m_isGMInitialized = true;
+        }
+
+        Image* currentImage;
+        Image* imageList;
+
+        ImageInfo* imageInfo;
+        ExceptionInfo exception;
+
+        GetExceptionInfo(&exception);
+        imageInfo = CloneImageInfo(null);
+        imageList = NewImageList();
+
+        foreach (frame; ugoira.getFrames())
+        {        
+            string filename = buildPath(getcwd(), frame.file);
+            size_t length = filename.length;
+            strncpy(imageInfo.filename.ptr, filename.ptr, length);
+
+            currentImage = ReadImage(imageInfo, &exception);
+
+            if (UndefinedException != exception.severity)
+            {
+                CatchException(&exception);
+                string msg = format!"Error reading GIF Image: %s -- %s"(
+                    fromStringz(exception.reason),
+                    fromStringz(exception.description));
+                throw new PixivException(msg);
+            }
+
+            if (null !is currentImage)
+            {
+                currentImage.delay = frame.delay / 10;
+                currentImage.dispose = PreviousDispose;
+                currentImage.iterations = 0;
+                AppendImageToList(&imageList, currentImage);
+            }
+        }
+
+        if (null !is imageList)
+        {
+            imageInfo.adjoin = MagickTrue;
+
+            chdir(directory);
+            WriteImages(imageInfo, imageList, gifFileName.ptr, &exception);
+
+            if (UndefinedException != exception.severity)
+            {
+                CatchException(&exception);
+                string msg = format!"Error reading GIF Image: %s -- %s"(
+                    fromStringz(exception.reason),
+                    fromStringz(exception.description));
+                throw new PixivException(msg);
+            }
+            DestroyImageList(imageList);
+        }
+
+        if (null !is imageInfo)
+        {
+            DestroyImageInfo(imageInfo);
+        }
+
+        DestroyExceptionInfo(&exception);
+    }
+
+    unittest
+    {
+        import std.file : exists, getcwd;
+
+        auto client = new Client();
+
+        Illustration illust = client.fetchIllustration("44360221");
+        assert(ContentType.ugoira == illust.type, "44360221 is not an Ugoira");
+
+        client.downloadIllust(illust, getcwd(), true);
+        assert(true == exists("44360221.gif"), "44360221.gif does not exist after download.");
+
+        import std.stdio : stderr;
+        import core.thread : Thread;
+        import core.time : seconds;
+
+        stderr.writefln("%s -- Sleeping for 3 seconds", __PRETTY_FUNCTION__);
+        Thread.sleep(3.seconds);
+    }
+}

--- /dev/null
+++ b/source/pixivd/enums.d
@@ -0,0 +1,18 @@
+module pixivd.enums;
+
+enum ContentType
+{
+    illustration = 0,
+    manga = 1,
+    ugoira = 2,
+    novel
+}
+
+/**
+ * The mode for downloading daily illustrations.
+ */
+enum DailyMode : string {
+    all = "all",
+    r18 = "r18",
+    safe = "safe",
+}

--- /dev/null
+++ b/source/pixivd/mixins.d
@@ -0,0 +1,24 @@
+module pixivd.mixins;
+
+package(pixivd) template mixCheckJsonError(string jsonVarName)
+{
+    static if (__VERSION__ < 2083L)
+    {
+        const char[] mixCheckJsonError = jsonVarName ~ "[\"error\"].type == JSON_TYPE.TRUE";
+    }
+    else
+    {
+        const char[] mixCheckJsonError = jsonVarName ~ "[\"error\"].boolean == true";
+    }
+}
+
+package(pixivd) template mixGetJsonBoolean(string jsonVarName, string key) {
+    static if (__VERSION__ < 2083L)
+    {
+        const char[] mixGetJsonBoolean = jsonVarName ~ "[\"" ~ key ~ "\"].type == JSON_TYPE.TRUE";
+    }
+    else
+    {
+        const char[] mixGetJsonBoolean = jsonVarName ~ "[\"" ~ key ~ "\"].boolean()";
+    }
+}

--- /dev/null
+++ b/source/pixivd/package.d
@@ -0,0 +1,7 @@
+module pixivd;
+
+public
+{
+    import pixivd.client;
+    import pixivd.enums;
+}

--- /dev/null
+++ b/source/pixivd/types/illustration.d
@@ -0,0 +1,95 @@
+module pixivd.types.illustration;
+
+import std.json;
+
+import pixivd.types.pixiv_exception;
+import pixivd.enums : ContentType;
+import pixivd.mixins;
+
+class Illustration
+{
+    string id;
+    string title;
+    string description;
+    ContentType type;
+    string createDate;
+    string uploadDate;
+    size_t restrict;
+    size_t xRestrict;
+    string[string] urls;
+    // tags
+    string alt;
+    string userId;
+    string userName;
+    string userAccount;
+    // userIllusts
+    bool likeData;
+    size_t width;
+    size_t height;
+    size_t pages;
+    size_t bookmarks;
+    size_t likes;
+    size_t comments;
+    size_t responses;
+    size_t views;
+
+    /**
+     * Create an Illustration from a JSONValue.
+     */
+    static Illustration fromJSON(in ref JSONValue json)
+    {
+        if (mixin(mixCheckJsonError!("json"))) {
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        if ("body" !in json) {
+            throw new PixivJSONException("No \"body\" in returned JSON.");
+        }
+
+        JSONValue body_ = json["body"];
+        auto illust = new Illustration();
+
+        // Set the image properties.
+        // Nested in `try` because any of the .str/.integer/.etc methods
+        // can throw if the JSON value doesn't match the type.
+        try {
+            illust.id = body_["id"].str;
+            illust.title = body_["title"].str;
+            illust.description = body_["description"].str;
+            illust.type = cast(ContentType)body_["illustType"].integer;
+            illust.createDate = body_["createDate"].str;
+            illust.uploadDate = body_["uploadDate"].str;
+            illust.restrict = body_["restrict"].integer;
+            illust.xRestrict = body_["xRestrict"].integer;
+
+            auto urls = body_["urls"];
+
+            illust.urls["mini"] = urls["mini"].str;
+            illust.urls["thumb"] = urls["thumb"].str;
+            illust.urls["small"] = urls["small"].str;
+            illust.urls["regular"] = urls["regular"].str;
+            illust.urls["original"] = urls["original"].str;
+
+            illust.alt = body_["alt"].str;
+            illust.userId = body_["userId"].str;
+            illust.userName = body_["userName"].str;
+            illust.userAccount = body_["userAccount"].str;
+
+            // userIllusts
+
+            illust.likeData = mixin(mixGetJsonBoolean!("body_", "likeData"));
+            illust.width = body_["width"].integer;
+            illust.height = body_["height"].integer;
+            illust.pages = body_["pageCount"].integer;
+            illust.bookmarks = body_["bookmarkCount"].integer;
+            illust.likes = body_["likeCount"].integer;
+            illust.comments = body_["commentCount"].integer;
+            illust.responses = body_["responseCount"].integer;
+            illust.views = body_["viewCount"].integer;
+
+            return illust;
+        } catch (JSONException e) {
+            throw new PixivJSONException(e.msg);
+        }
+    }
+}

--- /dev/null
+++ b/source/pixivd/types/package.d
@@ -0,0 +1,10 @@
+module pixivd.types;
+
+public
+{
+    import pixivd.types.illustration;
+    import pixivd.types.pixiv_exception;
+    import pixivd.types.thumbnail;
+    import pixivd.types.ugoira;
+    import pixivd.types.user;
+}

--- /dev/null
+++ b/source/pixivd/types/pixiv_exception.d
@@ -0,0 +1,18 @@
+module pixivd.types.pixiv_exception;
+
+class PixivException : Exception
+{
+    this(string msg)
+    {
+        super(msg);
+    }
+}
+
+/// Exception with the JSON response.
+class PixivJSONException : PixivException
+{
+    this(string msg)
+    {
+        super("Error in JSON response: " ~ msg);
+    }
+}

--- /dev/null
+++ b/source/pixivd/types/thumbnail.d
@@ -0,0 +1,81 @@
+module pixivd.types.thumbnail;
+
+import std.json;
+
+import pixivd.enums : ContentType;
+import pixivd.mixins;
+
+class Thumbnail
+{
+    string id;
+    string title;
+    ContentType type;
+    long xRestrict;
+    long restrict;
+    long sl;
+    string url;
+    string description;
+    string[] tags;
+    string userId;
+    string userName;
+    long width;
+    long height;
+    long pages;
+    bool canBookmark;
+    // bookmarkData;
+    string alt;
+    // titleCaptionTranslation
+    string createDate;
+    string updateDate;
+    bool isUnlisted;
+    bool isMasked;
+    string[string] urls;
+    string profileImageUrl;
+
+    static Thumbnail fromJSON(in ref JSONValue json)
+    {
+        auto thumb = new Thumbnail();
+
+        with (thumb)
+        {
+            id = json["id"].str;
+            title = json["title"].str;
+            type = cast(ContentType) json["illustType"].integer;
+            xRestrict = json["xRestrict"].integer;
+            restrict = json["restrict"].integer;
+            sl = json["sl"].integer;
+            url = json["url"].str;
+            description = json["description"].str;
+
+            auto ptags = json["tags"].array;
+            foreach (ref tag; ptags)
+            {
+                tags ~= tag.str;
+            }
+
+            userId = json["userId"].str;
+            userName = json["userName"].str;
+            width = json["width"].integer;
+            height = json["height"].integer;
+            pages = json["pageCount"].integer;
+            canBookmark = mixin(mixGetJsonBoolean!("json", "isBookmarkable"));
+            // bookmarkData
+            alt = json["alt"].str;
+            // titleCaptionTranslation
+            createDate = json["createDate"].str;
+            updateDate = json["updateDate"].str;
+            isUnlisted = mixin(mixGetJsonBoolean!("json", "isUnlisted"));
+            isMasked = mixin(mixGetJsonBoolean!("json", "isMasked"));
+
+            auto purls = json["urls"];
+            foreach(ref size; ["250x250", "360x360", "540x540"])
+            {
+                urls[size] = purls[size].str;
+            }
+
+            profileImageUrl = json["profileImageUrl"].str;
+        }
+
+        return thumb;
+    }
+}

--- /dev/null
+++ b/source/pixivd/types/ugoira.d
@@ -0,0 +1,72 @@
+module pixivd.types.ugoira;
+
+import std.json;
+
+import pixivd.mixins;
+import pixivd.types.pixiv_exception : PixivJSONException;
+
+class Ugoira
+{
+public:
+
+    struct Frame {
+        immutable string file;
+        immutable long delay;
+    }
+
+private:
+    string mimeType;
+    string originalSource;
+    string source;
+    Frame[] frames;
+
+public:
+    static Ugoira fromJSON(in ref JSONValue json) {
+
+        if (mixin(mixCheckJsonError!("json"))) {
+            throw new PixivJSONException(json["message"].str);
+        }
+
+        static if (__VERSION__ < 2083L) {
+            JSON_TYPE arrayType = JSON_TYPE.ARRAY;
+        } else {
+            JSONType arrayType = JSONType.array;
+        }
+
+        auto bdy = json["body"];
+        auto ugoira = new Ugoira();
+
+        with (ugoira) {
+            mimeType = bdy["mime_type"].str;
+            originalSource = bdy["originalSrc"].str;
+            source = bdy["src"].str;
+
+            auto jsonframes = bdy["frames"].array;
+            foreach (const ref JSONValue frame; jsonframes) {
+                ugoira.frames ~= Frame(frame["file"].str, frame["delay"].integer);
+            }
+        }
+
+        return ugoira;
+    }
+
+    string getMimeType() const
+    {
+        return mimeType;
+    }
+
+    Frame[] getFrames()
+    {
+        return frames;
+    }
+
+    string getOriginalSource() const
+    {
+        return originalSource;
+    }
+
+    string getSource() const
+    {
+        return source;
+    }
+}

--- /dev/null
+++ b/source/pixivd/types/user.d
@@ -0,0 +1,136 @@
+module pixivd.types.user;
+
+import std.json;
+
+import pixivd.mixins;
+
+class User
+{
+public:
+    bool acceptRequest;
+    bool following;
+    bool followed;
+    // illusts;
+    bool isBlocking;
+    bool isMypixiv;
+    // novels;
+    string profileImageUrl;
+    string userComment;
+    string userId;
+    string userName;
+
+    static User fromJSON(in ref JSONValue json)
+    {
+        auto user = new User();
+
+        with (user) {
+            acceptRequest = mixin(mixGetJsonBoolean!("json", "acceptRequest"));
+            following = mixin(mixGetJsonBoolean!("json", "following"));
+            followed = mixin(mixGetJsonBoolean!("json", "followed"));
+            isBlocking = mixin(mixGetJsonBoolean!("json", "isBlocking"));
+            isMypixiv = mixin(mixGetJsonBoolean!("json", "isMypixiv"));
+
+            profileImageUrl = json["profileImageUrl"].str;
+            userComment = json["userComment"].str;
+            userId = json["userId"].str;
+            userName = json["userName"].str;
+        }
+
+        return user;
+    }
+}
+
+class FullUser : User
+{
+    public string profileImageUrlBig;
+
+    static FullUser fromJSON(in ref JSONValue json)
+    {
+        auto user = new FullUser();
+
+        with (user)
+        {
+            userId = json["userId"].str;
+            userName = json["name"].str;
+            profileImageUrl = json["image"].str;
+            profileImageUrlBig = json["imageBig"].str;
+
+            following = mixin(mixGetJsonBoolean!("json", "isFollowed"));
+            followed = mixin(mixGetJsonBoolean!("json", "followedBack"));
+        }
+
+        return user;
+    }
+}
+
+/**
+Information about a user and their illustrations, manga, novels, etc.
+*/
+class UserBrief
+{
+public:
+    struct Bookmark
+    {
+        long illust;
+        long novel;
+    }
+
+    struct SiteWorksStatus
+    {
+        bool booth;
+        bool sketch;
+        bool vroidHub;
+    }
+
+public:
+    Bookmark[string] bookmarkCount;
+    string[] illusts;
+    string[] manga;
+    // ?[] novels;
+    // ?[] mangaSeries;
+    // ?[] novelsSeries;
+    // Illustration[](?) pickup;
+    // ? request;
+
+    static UserBrief fromJSON(in ref JSONValue json)
+    {
+        auto ub = new UserBrief();
+
+        static if (__VERSION__ < 2083L) {
+            JSON_TYPE arrayType = JSON_TYPE.ARRAY;
+        } else {
+            JSONType arrayType = JSONType.array;
+        }
+        
+        with(ub) {
+            bookmarkCount["public"] = Bookmark(
+                json["bookmarkCount"]["public"]["illust"].integer,
+                json["bookmarkCount"]["public"]["novel"].integer
+            );
+            bookmarkCount["private"] = Bookmark(
+                json["bookmarkCount"]["private"]["illust"].integer,
+                json["bookmarkCount"]["private"]["novel"].integer
+            );
+            
+            /* 
+             * When an account doesn't have any illustrations or manga
+             * then the return type is an empty array, however, if there
+             * are illustrations or manga, then the type is an JSONObject.
+             */
+
+            if ("illusts" in json && (arrayType != json["illusts"].type)) {
+                foreach(k, v; json["illusts"].object) {
+                    illusts ~= k;
+                }
+            }
+            
+            if ("manga" in json && (arrayType != json["manga"].type)) {
+                foreach(k, v; json["manga"].object) {
+                    manga ~= k;
+                }
+            }
+        }
+        
+        return ub;
+    }
+}