baphomet-js/src/module/szurubooru/client.ts

/**
 * Szurubooru api client
 */

let axios = require('axios');
let { logger } = require('../../logging');

function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min)) + min; //The maximum is exclusive and the minimum is inclusive
}

class SzurubooruClient {

    url: string;
    baseUrl: string;
    username: string;
    token: string;

    randomImageCount: number;

    _randomSearchQueryValues: string = "type:image,animated,video sort:random";
    _randomSearchUrlTemplate: string = "%s/posts/?offset=%s&limit=%d&query=%s";

    constructor(url: string, username: string, token: string) {
        this.url = url;
        this.baseUrl = url.replace('/api', '');
        this.username = username;
        this.token = token;
        this.updateRandomScope();
    }

    getRandomSearchUrl(offset: number, limit: number, tags: Array<string> = []) {
        var searchQuery = this._randomSearchQueryValues;
        if (tags !== null && tags.length > 0) {
            searchQuery = this._randomSearchQueryValues + tags.join(" ");
        }
        return this.url + '/posts/?offset=' + offset + '&limit=' + limit + '&query=' + searchQuery;
    }

    /**
     * Determine a sane range of offset values
     * 
     * @param {*} limit The content limit of a single page
     * @param {*} total The number of objects to search through
     */
    getValidOffsetRange(limit: number, total: number): Array<number> {
        let offsetOverflow = total % limit;
        var offsetCeiling = (Math.round(total / limit));
        if (offsetOverflow === 0) {
            offsetCeiling -= 1;
        }
        return [0, offsetCeiling];
    }


    /**
     * Determine a random offset based on the potential random search size
     *
     * Because Szurubooru doesn't randomize each sort:random search request, we must
     * manually calculate a random offset for each request to simulate randomness in the
     * posts returned.
     * 
     * @param {*} self 
     * @param {*} imageCount 
     */
    getRandomSearchParameters(imageCount?: number) {
        let resultLimit = 10;
        var offsetRange = [0, 1];
        if (imageCount === null) {
            offsetRange = this.getValidOffsetRange(resultLimit, this.randomImageCount);
        } else {
            offsetRange = this.getValidOffsetRange(resultLimit, imageCount);
        }
        return [resultLimit, getRandomInt(offsetRange[0], offsetRange[1])];
    }


    async updateRandomScope() {
        let client = this;
        let target = this.getRandomSearchUrl(0, 1);
        await this.makeGetRequest(target).then((result: any) => {
            client.randomImageCount = result.total;
        });

    }

    makeGetRequest(url: string) {
        logger.debug("Making get request to %s", url);
        return axios.get(url, {
            headers: {
                "Authorization": "Token " + Buffer.from(this.username + ':' + this.token).toString('base64'),
                "Accept": "application/json"
            }
        }).then((response: any) => {
            logger.debug("Recieved: %o", response.data);
            return response.data;
        }, (err: any) => {
            logger.error("Unexpected client error: %o", err);
            return null;
        });
    }

    /**
     * Return a random post matching the optionally provided tags.
     * 
     * @param {*} self 
     * @param {*} tags 
     */
    getRandomPost(tags: Array<string> = []) {
        let client = this;
        var resultLimit = 0;
        var randomSearchOffset = 0;
        if (tags.length === 0) {
            let randomSearchParameters = this.getRandomSearchParameters();
            resultLimit = randomSearchParameters[0];
            randomSearchOffset = randomSearchParameters[1];
        }
        let searchUrl = this.getRandomSearchUrl(randomSearchOffset, resultLimit, tags);
        return this.makeGetRequest(searchUrl)
            .then((data: any) => {
                if (data !== null) {
                    let limitSpace = Math.min(resultLimit, data.results.length - 1);
                    let randomPost = data.results[getRandomInt(0, limitSpace)];
                    return client.baseUrl + '/' + randomPost.contentUrl;
                } else {
                    return null
                }
            }, (err: any) => {
                logger.error("Unexpected error: %o", err);
                return null;
            })
    }
}

export { SzurubooruClient as Client };