var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import 'reflect-metadata';
import axios from 'axios';
import { buildURL, concatURL, parseQuery } from '@vssue/utils';
import Bluebird from 'bluebird';
import { normalizeUser, normalizeIssue, normalizeComment, normalizeReactions, mapReactionName, logMethod, noticeError, } from './utils';
/**
 * @see https://gitee.com/api/v5/oauth_doc
 */
export default class VssueGiteeAPI {
    constructor({ baseURL = "https://gitee.com" /* BASE_URL */, owner, repo, labels, clientId, clientSecret, state, proxy, }) {
        this.scope = 'user_info issues notes';
        if (typeof clientSecret === 'undefined') {
            throw new Error(`clientSecret is required for ${"Gitee" /* SITE_NAME */}`);
        }
        this.baseURL = baseURL;
        this.owner = owner;
        this.repo = repo;
        this.labels = labels;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.state = state;
        this.proxy = proxy;
        this._pageInfo = {
            page: 1,
            startCursor: null,
            endCursor: null,
            sort: null,
            perPage: null,
        };
        this.$http = axios.create({
            baseURL: concatURL(baseURL, 'api/v5'),
            headers: {
                'Accept': 'application/json',
            },
        });
        this.$http.interceptors.response.use(response => {
            if (response.data.error) {
                return Promise.reject(response.data.error_description);
            }
            if (response.data.errors) {
                return Promise.reject(response.data.errors[0].message);
            }
            return response;
        });
    }
    /**
     * The platform api info
     */
    get platform() {
        return {
            name: "Gitee" /* SITE_NAME */,
            link: this.baseURL,
            version: 'v5',
            meta: {
                reactable: false,
                sortable: true,
            },
        };
    }
    /**
     * Redirect to the authorization page of platform.
     *
     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#1-request-a-users-github-identity
     */
    redirectAuth() {
        window.location.href = buildURL(concatURL(this.baseURL, 'oauth/authorize'), {
            client_id: this.clientId,
            redirect_uri: window.location.href,
            scope: this.scope,
            state: this.state,
            response_type: 'code',
        });
    }
    _chooseAuth(query) {
        if (Array.isArray(query.state) || Array.isArray(query.code)) {
            for (let i in query.state) {
                if (query.state[i] === this.state && query.code[i]) {
                    return {
                        code: query.code[i],
                        state: query.state[i],
                    };
                }
            }
            return null;
        }
        return {
            code: query.code,
            state: query.state,
        };
    }
    _handleRequest(options, vssueData = {}) {
        const { accessToken } = vssueData;
        options.params = options.params || {};
        options.data = this._handleRequestPost(options.data, {
            options, vssueData,
        });
        options.headers = options.headers || {};
        if (accessToken) {
            options.headers['Authorization'] = `token ${accessToken}`;
            if (!options.method || options.method.toLowerCase() != 'post') {
                options.params.access_token = accessToken;
            }
        }
        return options;
    }
    _handleRequestPost(data, { options = {}, vssueData = {}, } = {}) {
        const { accessToken } = vssueData;
        data = data || {};
        if (accessToken) {
            data.access_token = accessToken;
        }
        console.log(`_handleRequestPost`, data, options, vssueData);
        return data;
    }
    /**
     * Handle authorization.
     *
     * @return A string for access token, `null` for no authorization code
     *
     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/
     *
     * @remarks
     * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.
     */
    async handleAuth() {
        const query = parseQuery(window.location.search);
        if (query.code) {
            const { code, state } = this._chooseAuth(query);
            if (state !== this.state) {
                return null;
            }
            let u = new URL(window.location.href);
            u.searchParams.delete('code');
            u.searchParams.delete('state');
            window.history.replaceState(null, '', u.href);
            return this.getAccessToken({ code });
        }
        return null;
    }
    /**
     * Get user access token via `code`
     *
     * @param options.code - The code from the query
     *
     * @return User access token
     *
     * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github
     */
    async getAccessToken({ code, }) {
        /**
         * access_token api does not support cors
         * @see https://github.com/isaacs/github/issues/330
         */
        const originalURL = concatURL(this.baseURL, 'oauth/token');
        const proxyURL = typeof this.proxy === 'function'
            ? this.proxy(originalURL)
            : this.proxy;
        const { data } = await this.$http.post(proxyURL, {
            client_id: this.clientId,
            client_secret: this.clientSecret,
            grant_type: 'authorization_code',
            code,
            /**
             * useless but mentioned in docs
             */
            redirect_uri: window.location.href,
            // state: this.state,
            response_type: 'code',
            scope: this.scope,
        }, {
            headers: {
                'Accept': 'application/json',
            },
        });
        const { access_token } = data;
        this.$http.defaults.data = this.$http.defaults.data || {};
        this.$http.defaults.data.access_token = access_token;
        this.$http.defaults.headers = this.$http.defaults.headers || {};
        this.$http.defaults.headers['Authorization'] = `token ${access_token}`;
        return access_token;
    }
    /**
     * Get the logined user with access token.
     *
     * @param options.accessToken - User access token
     *
     * @return The user
     *
     * @see https://developer.github.com/v3/users/#get-the-authenticated-user
     */
    async getUser({ accessToken, }) {
        const { data } = await this.$http.request({
            url: 'user',
            params: {
            //access_token: accessToken,
            },
            data: {
                access_token: accessToken,
            },
            headers: { 'Authorization': `token ${accessToken}` },
        });
        return normalizeUser(data);
    }
    get _fullRepoPath() {
        return `${this.owner}/${this.repo}`;
    }
    /**
     * Get issue of this page according to the issue id or the issue title
     *
     * @param options.accessToken - User access token
     * @param options.issueId - The id of issue
     * @param options.issueTitle - The title of issue
     *
     * @return The raw response of issue
     *
     * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository
     * @see https://developer.github.com/v3/issues/#get-a-single-issue
     * @see https://developer.github.com/v3/#pagination
     */
    async getIssue({ accessToken, issueId, issueTitle, }) {
        const options = {};
        console.log(`getIssue`, {
            accessToken,
            issueId,
            issueTitle,
        });
        if (accessToken) {
            options.headers = {
                'Authorization': `token ${accessToken}`,
            };
        }
        this._handleRequest(options, {
            accessToken,
        });
        if (issueId) {
            try {
                // to avoid caching
                options.params.timestamp = Date.now();
                options.params.state = 'all';
                const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, options);
                let issue = normalizeIssue(data);
                console.log(`getIssue`, 1, data, issue);
                return issue;
            }
            catch (e) {
                if (e.response && e.response.status === 404) {
                    return null;
                }
                else {
                    throw e;
                }
            }
        }
        else if (1) {
            let labels = this.labels;
            return await this.$http.get(`search/issues`, {
                params: this._handleRequestPost({
                    repo: this._fullRepoPath,
                    q: issueTitle,
                }, {
                    vssueData: {
                        accessToken,
                        issueId,
                        issueTitle,
                    },
                }),
            })
                .then(({ data }) => {
                let issue = data
                    .filter((issue) => {
                    return issue.title === issueTitle;
                })
                    .sort((a, b) => {
                    return a.labels.filter(k => labels.includes(k)).length
                        - b.labels.filter(k => labels.includes(k)).length;
                })[0];
                if (issue) {
                    return normalizeIssue(issue);
                }
                return null;
            });
        }
        else {
            options.params = {
                ...options.params,
                //labels: this.labels.join(','),
                sort: 'created',
                direction: 'asc',
                state: 'all',
                // to avoid caching
                timestamp: Date.now(),
            };
            const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues`, options);
            console.log(`getIssue`, 2.1, data, typeof data);
            console.log(this);
            const issue = data
                .map(normalizeIssue)
                .filter((issue) => {
                console.log([issue.title, issue.title === issueTitle, issue]);
                console.log(issue.labels);
                return issue.title === issueTitle;
            })[0];
            return issue || null;
        }
    }
    _handleApiError(e) {
        if (e && e.response && e.response.data && e.response.data.html_url && e.response.data.action) {
            setTimeout(() => {
                window.open(e.response.data.html_url, 'gitee');
            }, 1000);
        }
    }
    /**
     * Create a new issue
     *
     * @param options.accessToken - User access token
     * @param options.title - The title of issue
     * @param options.content - The content of issue
     *
     * @return The created issue
     *
     * @see https://developer.github.com/v3/issues/#create-an-issue
     */
    async postIssue({ accessToken, title, content, }) {
        const { data } = await Bluebird.resolve(this.$http.post(`repos/${this.owner}/issues`, this._handleRequestPost({
            title,
            body: content,
            repo: this.repo,
            labels: this.labels.join(','),
        }, {
            vssueData: {
                accessToken,
                title,
                content,
            },
        }), {
            headers: { 'Authorization': `token ${accessToken}` },
        }))
            .tapCatch(this._handleApiError);
        return normalizeIssue(data);
    }
    /**
     * Get comments of this page according to the issue id
     *
     * @param options.accessToken - User access token
     * @param options.issueId - The id of issue
     * @param options.query - The query parameters
     *
     * @return The comments
     *
     * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue
     * @see https://developer.github.com/v3/#pagination
     *
     * @reamrks
     * Github V3 does not support sort for issue comments now.
     * Github V3 have to request the parent issue to get the count of comments.
     */
    async getComments({ accessToken, issueId, query: { page = 1, perPage = 10, sort = 'desc', } = {}, }) {
        const issueOptions = {
            params: {
                // to avoid caching
                timestamp: Date.now(),
            },
        };
        const commentsOptions = {
            params: {
                // pagination
                'page': page,
                'per_page': perPage,
                /**
                 * github v3 api does not support sort for issue comments
                 * have sent feedback to github support
                 */
                // 'sort': 'created',
                // 'direction': sort,
                // to avoid caching
                'timestamp': Date.now(),
            },
            headers: {
                'Accept': [
                    'application/vnd.github.v3.raw+json',
                    'application/vnd.github.v3.html+json',
                    'application/vnd.github.squirrel-girl-preview',
                ],
            },
        };
        if (accessToken) {
            issueOptions.headers = {
                'Authorization': `token ${accessToken}`,
            };
            commentsOptions.headers['Authorization'] = `token ${accessToken}`;
        }
        // github v3 have to get the total count of comments by requesting the issue
        const [issueRes, commentsRes] = await Promise.all([
            this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, issueOptions),
            this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, commentsOptions),
        ]);
        // it's annoying that have to get the page and per_page from the `Link` header
        const linkHeader = commentsRes.headers['link'] || null;
        /* istanbul ignore next */
        const thisPage = /rel="next"/.test(linkHeader)
            ? Number(linkHeader.replace(/^.*[^_]page=(\d*).*rel="next".*$/, '$1')) - 1
            : /rel="prev"/.test(linkHeader)
                ? Number(linkHeader.replace(/^.*[^_]page=(\d*).*rel="prev".*$/, '$1')) + 1
                : 1;
        /* istanbul ignore next */
        const thisPerPage = linkHeader ? Number(linkHeader.replace(/^.*per_page=(\d*).*$/, '$1')) : perPage;
        return {
            count: Number(issueRes.data.comments),
            page: thisPage,
            perPage: thisPerPage,
            data: commentsRes.data.map(normalizeComment),
        };
    }
    /**
     * Create a new comment
     *
     * @param options.accessToken - User access token
     * @param options.issueId - The id of issue
     * @param options.content - The content of comment
     *
     * @return The created comment
     *
     * @see https://developer.github.com/v3/issues/comments/#create-a-comment
     */
    async postComment({ accessToken, issueId, content, }) {
        const { data } = await Bluebird.resolve(this.$http.post(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {
            body: content,
        }, {
            headers: {
                'Authorization': `token ${accessToken}`,
                'Accept': [
                    'application/vnd.github.v3.raw+json',
                    'application/vnd.github.v3.html+json',
                    'application/vnd.github.squirrel-girl-preview',
                ],
            },
        }))
            .tapCatch(this._handleApiError);
        return normalizeComment(data);
    }
    /**
     * Edit a comment
     *
     * @param options.accessToken - User access token
     * @param options.commentId - The id of comment
     * @param options.content - The content of comment
     *
     * @return The edited comment
     *
     * @see https://developer.github.com/v3/issues/comments/#edit-a-comment
     */
    async putComment({ accessToken, commentId, content, }) {
        const { data } = await this.$http.patch(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {
            body: content,
        }, {
            headers: {
                'Authorization': `token ${accessToken}`,
                'Accept': [
                    'application/vnd.github.v3.raw+json',
                    'application/vnd.github.v3.html+json',
                    'application/vnd.github.squirrel-girl-preview',
                ],
            },
        });
        return normalizeComment(data);
    }
    /**
     * Delete a comment
     *
     * @param options.accessToken - User access token
     * @param options.commentId - The id of comment
     *
     * @return `true` if succeed, `false` if failed
     *
     * @see https://developer.github.com/v3/issues/comments/#delete-a-comment
     */
    async deleteComment({ accessToken, commentId, }) {
        const { status } = await this.$http.delete(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {
            headers: { 'Authorization': `token ${accessToken}` },
        });
        return status === 204;
    }
    /**
     * Get reactions of a comment
     *
     * @param options.accessToken - User access token
     * @param options.commentId - The id of comment
     *
     * @return The comments
     *
     * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment
     * @see https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment
     *
     * @remarks
     * The `List reactions for an issue comment` API also returns author of each reaction.
     * As we only need the count, use the `Get a single comment` API is much simpler.
     */
    async getCommentReactions({ accessToken, commentId, }) {
        const { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {
            headers: {
                'Authorization': `token ${accessToken}`,
                'Accept': 'application/vnd.github.squirrel-girl-preview',
            },
        });
        return normalizeReactions(data.reactions);
    }
    /**
     * Create a new reaction of a comment
     *
     * @param options.accessToken - User access token
     * @param options.commentId - The id of comment
     * @param options.reaction - The reaction
     *
     * @return `true` if succeed, `false` if already token
     *
     * @see https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment
     */
    async postCommentReaction({ accessToken, commentId, reaction, }) {
        const response = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}/reactions`, {
            content: mapReactionName(reaction),
        }, {
            headers: {
                'Authorization': `token ${accessToken}`,
                'Accept': 'application/vnd.github.squirrel-girl-preview',
            },
        });
        return response.status === 201;
    }
}
__decorate([
    logMethod,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "handleAuth", null);
__decorate([
    logMethod,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "getAccessToken", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "getUser", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "getIssue", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "postIssue", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "getComments", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "postComment", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "putComment", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "deleteComment", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "getCommentReactions", null);
__decorate([
    logMethod,
    noticeError,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Promise)
], VssueGiteeAPI.prototype, "postCommentReaction", null);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import 'reflect-metadata'\nimport { VssueAPI } from 'vssue'\nimport axios, { AxiosInstance, AxiosRequestConfig, AxiosError } from 'axios'\nimport { buildURL, concatURL, parseQuery } from '@vssue/utils'\nimport Bluebird from 'bluebird'\nimport {\n\tnormalizeUser,\n\tnormalizeIssue,\n\tnormalizeComment,\n\tnormalizeReactions,\n\tmapReactionName, EnumMyConst, logMethod, noticeError, IIssues,\n} from './utils'\n\n/**\n * @see https://gitee.com/api/v5/oauth_doc\n */\nexport default class VssueGiteeAPI implements VssueAPI.Instance\n{\n\tbaseURL: string\n\towner: string\n\trepo: string\n\tlabels: Array<string>\n\tclientId: string\n\tclientSecret: string\n\tstate: string\n\tproxy: string | ((url: string) => string)\n\t$http: AxiosInstance\n\n\tprivate _pageInfo: {\n\t\tpage: number\n\t\tstartCursor: string | null\n\t\tendCursor: string | null\n\t\tsort: string | null\n\t\tperPage: number | null\n\t}\n\n\treadonly scope: string = 'user_info issues notes'\n\n\tconstructor({\n\t\tbaseURL = EnumMyConst.BASE_URL,\n\t\towner,\n\t\trepo,\n\t\tlabels,\n\t\tclientId,\n\t\tclientSecret,\n\t\tstate,\n\t\tproxy,\n\t}: VssueAPI.Options)\n\t{\n\t\tif (typeof clientSecret === 'undefined')\n\t\t{\n\t\t\tthrow new Error(`clientSecret is required for ${EnumMyConst.SITE_NAME}`)\n\t\t}\n\t\tthis.baseURL = baseURL\n\t\tthis.owner = owner\n\t\tthis.repo = repo\n\t\tthis.labels = labels\n\n\t\tthis.clientId = clientId\n\t\tthis.clientSecret = clientSecret\n\t\tthis.state = state\n\t\tthis.proxy = proxy\n\n\t\tthis._pageInfo = {\n\t\t\tpage: 1,\n\t\t\tstartCursor: null,\n\t\t\tendCursor: null,\n\t\t\tsort: null,\n\t\t\tperPage: null,\n\t\t};\n\n\t\tthis.$http = axios.create({\n\t\t\tbaseURL: concatURL(baseURL, 'api/v5'),\n\t\t\theaders: {\n\t\t\t\t'Accept': 'application/json',\n\t\t\t},\n\t\t});\n\n\t\tthis.$http.interceptors.response.use(response =>\n\t\t{\n\t\t\tif (response.data.error)\n\t\t\t{\n\t\t\t\treturn Promise.reject(response.data.error_description)\n\t\t\t}\n\t\t\tif (response.data.errors)\n\t\t\t{\n\t\t\t\treturn Promise.reject(response.data.errors[0].message)\n\t\t\t}\n\t\t\treturn response\n\t\t})\n\t}\n\n\t/**\n\t * The platform api info\n\t */\n\tget platform(): VssueAPI.Platform\n\t{\n\t\treturn {\n\t\t\tname: EnumMyConst.SITE_NAME,\n\t\t\tlink: this.baseURL,\n\t\t\tversion: 'v5',\n\t\t\tmeta: {\n\t\t\t\treactable: false,\n\t\t\t\tsortable: true,\n\t\t\t},\n\t\t}\n\t}\n\n\t/**\n\t * Redirect to the authorization page of platform.\n\t *\n\t * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#1-request-a-users-github-identity\n\t */\n\tredirectAuth(): void\n\t{\n\t\twindow.location.href = buildURL(concatURL(this.baseURL, 'oauth/authorize'), {\n\t\t\tclient_id: this.clientId,\n\t\t\tredirect_uri: window.location.href,\n\t\t\tscope: this.scope,\n\t\t\tstate: this.state,\n\t\t\tresponse_type: 'code',\n\t\t})\n\t}\n\n\tprotected _chooseAuth(query: {\n\t\tcode: string | string[],\n\t\tstate: string | string[],\n\t}): {\n\t\tcode: string;\n\t\tstate: string;\n\t}\n\t{\n\t\tif (Array.isArray(query.state) || Array.isArray(query.code))\n\t\t{\n\t\t\tfor (let i in (query.state as string[]))\n\t\t\t{\n\t\t\t\tif (query.state[i] === this.state && query.code[i])\n\t\t\t\t{\n\t\t\t\t\treturn {\n\t\t\t\t\t\tcode: query.code[i] as string,\n\t\t\t\t\t\tstate: query.state[i] as string,\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn null;\n\t\t}\n\n\t\treturn {\n\t\t\tcode: query.code as string,\n\t\t\tstate: query.state as string,\n\t\t}\n\t}\n\n\tprotected _handleRequest(options: AxiosRequestConfig & {\n\t\tdata?: {\n\t\t\taccess_token?: string;\n\t\t}\n\t}, vssueData: {\n\t\taccessToken?: string;\n\t\t[k: string]: unknown;\n\t} = {})\n\t{\n\t\tconst { accessToken } = vssueData;\n\n\t\toptions.params = options.params || {};\n\t\toptions.data = this._handleRequestPost(options.data, {\n\t\t\toptions, vssueData,\n\t\t});\n\n\t\toptions.headers = options.headers || {};\n\n\t\tif (accessToken)\n\t\t{\n\t\t\toptions.headers['Authorization'] = `token ${accessToken}`;\n\n\t\t\tif (!options.method || options.method.toLowerCase() != 'post')\n\t\t\t{\n\t\t\t\toptions.params.access_token = accessToken;\n\t\t\t}\n\t\t}\n\n\t\treturn options;\n\t}\n\n\tprotected _handleRequestPost(data: AxiosRequestConfig[\"data\"] & {\n\t\taccess_token?: string;\n\t}, {\n\t\toptions = {} as AxiosRequestConfig,\n\t\tvssueData = {} as {\n\t\t\taccessToken?: string;\n\t\t\t[k: string]: unknown;\n\t\t},\n\t} = {})\n\t{\n\t\tconst { accessToken } = vssueData;\n\n\t\tdata = data || {};\n\n\t\tif (accessToken)\n\t\t{\n\t\t\tdata.access_token = accessToken;\n\t\t}\n\n\t\tconsole.log(`_handleRequestPost`, data, options, vssueData);\n\n\t\treturn data;\n\t}\n\n\t/**\n\t * Handle authorization.\n\t *\n\t * @return A string for access token, `null` for no authorization code\n\t *\n\t * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/\n\t *\n\t * @remarks\n\t * If the `code` and `state` exist in the query, and the `state` matches, remove them from query, and try to get the access token.\n\t */\n\t@logMethod\n\tasync handleAuth(): Promise<VssueAPI.AccessToken>\n\t{\n\t\tconst query = parseQuery(window.location.search)\n\n\t\tif (query.code)\n\t\t{\n\t\t\tconst { code, state } = this._chooseAuth(query);\n\n\t\t\tif (state !== this.state)\n\t\t\t{\n\t\t\t\treturn null\n\t\t\t}\n\n\t\t\tlet u = new URL(window.location.href);\n\t\t\tu.searchParams.delete('code');\n\t\t\tu.searchParams.delete('state');\n\t\t\twindow.history.replaceState(null, '', u.href);\n\n\t\t\treturn this.getAccessToken({ code })\n\t\t}\n\n\t\treturn null\n\t}\n\n\t/**\n\t * Get user access token via `code`\n\t *\n\t * @param options.code - The code from the query\n\t *\n\t * @return User access token\n\t *\n\t * @see https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#2-users-are-redirected-back-to-your-site-by-github\n\t */\n\t@logMethod\n\tasync getAccessToken({\n\t\tcode,\n\t}: {\n\t\tcode: string\n\t}): Promise<string>\n\t{\n\t\t/**\n\t\t * access_token api does not support cors\n\t\t * @see https://github.com/isaacs/github/issues/330\n\t\t */\n\t\tconst originalURL = concatURL(this.baseURL, 'oauth/token')\n\t\tconst proxyURL = typeof this.proxy === 'function'\n\t\t\t? this.proxy(originalURL)\n\t\t\t: this.proxy\n\t\tconst { data } = await this.$http.post(proxyURL, {\n\t\t\tclient_id: this.clientId,\n\t\t\tclient_secret: this.clientSecret,\n\n\t\t\tgrant_type: 'authorization_code',\n\n\t\t\tcode,\n\t\t\t/**\n\t\t\t * useless but mentioned in docs\n\t\t\t */\n\t\t\tredirect_uri: window.location.href,\n\t\t\t// state: this.state,\n\t\t\tresponse_type: 'code',\n\t\t\tscope: this.scope,\n\t\t}, {\n\n\t\t\theaders: {\n\t\t\t\t'Accept': 'application/json',\n\t\t\t},\n\n\t\t});\n\n\t\tconst { access_token } = data;\n\n\t\tthis.$http.defaults.data = this.$http.defaults.data || {};\n\t\tthis.$http.defaults.data.access_token = access_token;\n\n\t\tthis.$http.defaults.headers = this.$http.defaults.headers || {};\n\n\t\tthis.$http.defaults.headers['Authorization'] = `token ${access_token}`;\n\n\t\treturn access_token\n\t}\n\n\t/**\n\t * Get the logined user with access token.\n\t *\n\t * @param options.accessToken - User access token\n\t *\n\t * @return The user\n\t *\n\t * @see https://developer.github.com/v3/users/#get-the-authenticated-user\n\t */\n\t@logMethod\n\t@noticeError\n\tasync getUser({\n\t\taccessToken,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t}): Promise<VssueAPI.User>\n\t{\n\t\tconst { data } = await this.$http.request({\n\n\t\t\turl: 'user',\n\n\t\t\tparams: {\n\t\t\t\t//access_token: accessToken,\n\t\t\t},\n\n\t\t\tdata: {\n\t\t\t\taccess_token: accessToken,\n\t\t\t},\n\n\t\t\theaders: { 'Authorization': `token ${accessToken}` },\n\t\t})\n\t\treturn normalizeUser(data)\n\t}\n\n\tget _fullRepoPath()\n\t{\n\t\treturn `${this.owner}/${this.repo}`;\n\t}\n\n\t/**\n\t * Get issue of this page according to the issue id or the issue title\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.issueId - The id of issue\n\t * @param options.issueTitle - The title of issue\n\t *\n\t * @return The raw response of issue\n\t *\n\t * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n\t * @see https://developer.github.com/v3/issues/#get-a-single-issue\n\t * @see https://developer.github.com/v3/#pagination\n\t */\n\t@logMethod\n\t@noticeError\n\tasync getIssue({\n\t\taccessToken,\n\t\tissueId,\n\t\tissueTitle,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId?: string | number\n\t\tissueTitle?: string\n\t}): Promise<VssueAPI.Issue | null>\n\t{\n\t\tconst options: AxiosRequestConfig = {}\n\n\t\tconsole.log(`getIssue`, {\n\t\t\taccessToken,\n\t\t\tissueId,\n\t\t\tissueTitle,\n\t\t});\n\n\t\tif (accessToken)\n\t\t{\n\t\t\toptions.headers = {\n\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t}\n\t\t}\n\n\t\tthis._handleRequest(options, {\n\t\t\taccessToken,\n\t\t});\n\n\t\tif (issueId)\n\t\t{\n\t\t\ttry\n\t\t\t{\n\t\t\t\t// to avoid caching\n\t\t\t\toptions.params.timestamp = Date.now();\n\t\t\t\toptions.params.state = 'all';\n\n\t\t\t\tconst { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, options)\n\n\t\t\t\tlet issue = normalizeIssue(data)\n\n\t\t\t\tconsole.log(`getIssue`, 1, data, issue);\n\n\t\t\t\treturn issue\n\t\t\t}\n\t\t\tcatch (e)\n\t\t\t{\n\t\t\t\tif (e.response && e.response.status === 404)\n\t\t\t\t{\n\t\t\t\t\treturn null\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tthrow e\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse if (1)\n\t\t{\n\t\t\tlet labels = this.labels;\n\n\t\t\treturn await this.$http.get(`search/issues`, {\n\n\t\t\t\t\tparams: this._handleRequestPost({\n\n\t\t\t\t\t\trepo: this._fullRepoPath,\n\n\t\t\t\t\t\tq: issueTitle,\n\t\t\t\t\t}, {\n\t\t\t\t\t\tvssueData: {\n\t\t\t\t\t\t\taccessToken,\n\t\t\t\t\t\t\tissueId,\n\t\t\t\t\t\t\tissueTitle,\n\t\t\t\t\t\t},\n\t\t\t\t\t}),\n\n\t\t\t\t})\n\t\t\t\t.then(({ data }) =>\n\t\t\t\t{\n\t\t\t\t\tlet issue = (data as IIssues[])\n\t\t\t\t\t\t.filter((issue: IIssues) =>\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\treturn issue.title === issueTitle\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.sort((a, b) =>\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\treturn a.labels.filter(k => labels.includes(k)).length\n\t\t\t\t\t\t\t\t- b.labels.filter(k => labels.includes(k)).length\n\t\t\t\t\t\t})\n\t\t\t\t\t\t[0]\n\t\t\t\t\t;\n\n\t\t\t\t\tif (issue)\n\t\t\t\t\t{\n\t\t\t\t\t\treturn normalizeIssue(issue)\n\t\t\t\t\t}\n\n\t\t\t\t\treturn null\n\t\t\t\t})\n\t\t\t\t;\n\t\t}\n\t\telse\n\t\t{\n\t\t\toptions.params = {\n\t\t\t\t...options.params,\n\t\t\t\t//labels: this.labels.join(','),\n\t\t\t\tsort: 'created',\n\t\t\t\tdirection: 'asc',\n\t\t\t\tstate: 'all',\n\t\t\t\t// to avoid caching\n\t\t\t\ttimestamp: Date.now(),\n\t\t\t}\n\t\t\tconst { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues`, options);\n\n\t\t\tconsole.log(`getIssue`, 2.1, data, typeof data);\n\t\t\tconsole.log(this);\n\n\t\t\tconst issue = data\n\t\t\t\t.map(normalizeIssue)\n\t\t\t\t.filter((issue: IIssues) =>\n\t\t\t\t{\n\t\t\t\t\tconsole.log([issue.title, issue.title === issueTitle, issue]);\n\n\t\t\t\t\tconsole.log(issue.labels);\n\n\t\t\t\t\treturn issue.title === issueTitle\n\t\t\t\t})[0]\n\t\t\t;\n\n\t\t\treturn issue || null\n\t\t}\n\t}\n\n\tprotected _handleApiError(e: AxiosError)\n\t{\n\t\tif (e && e.response && e.response.data && e.response.data.html_url && e.response.data.action)\n\t\t{\n\t\t\tsetTimeout(() =>\n\t\t\t{\n\t\t\t\twindow.open(e.response.data.html_url, 'gitee')\n\t\t\t}, 1000);\n\t\t}\n\t}\n\n\t/**\n\t * Create a new issue\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.title - The title of issue\n\t * @param options.content - The content of issue\n\t *\n\t * @return The created issue\n\t *\n\t * @see https://developer.github.com/v3/issues/#create-an-issue\n\t */\n\t@logMethod\n\t@noticeError\n\tasync postIssue({\n\t\taccessToken,\n\t\ttitle,\n\t\tcontent,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\ttitle: string\n\t\tcontent: string\n\t}): Promise<VssueAPI.Issue>\n\t{\n\t\tconst { data } = await Bluebird.resolve(this.$http.post(`repos/${this.owner}/issues`, this._handleRequestPost({\n\t\t\t\ttitle,\n\t\t\t\tbody: content,\n\t\t\t\trepo: this.repo,\n\t\t\t\tlabels: this.labels.join(','),\n\t\t\t}, {\n\t\t\t\tvssueData: {\n\t\t\t\t\taccessToken,\n\t\t\t\t\ttitle,\n\t\t\t\t\tcontent,\n\t\t\t\t},\n\t\t\t}), {\n\t\t\t\theaders: { 'Authorization': `token ${accessToken}` },\n\t\t\t}))\n\t\t\t.tapCatch(this._handleApiError)\n\t\t;\n\n\t\treturn normalizeIssue(data)\n\t}\n\n\t/**\n\t * Get comments of this page according to the issue id\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.issueId - The id of issue\n\t * @param options.query - The query parameters\n\t *\n\t * @return The comments\n\t *\n\t * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n\t * @see https://developer.github.com/v3/#pagination\n\t *\n\t * @reamrks\n\t * Github V3 does not support sort for issue comments now.\n\t * Github V3 have to request the parent issue to get the count of comments.\n\t */\n\t@logMethod\n\t@noticeError\n\tasync getComments({\n\t\taccessToken,\n\t\tissueId,\n\t\tquery: {\n\t\t\tpage = 1,\n\t\t\tperPage = 10,\n\t\t\tsort = 'desc',\n\t\t} = {},\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tquery?: Partial<VssueAPI.Query>\n\t}): Promise<VssueAPI.Comments>\n\t{\n\t\tconst issueOptions: AxiosRequestConfig = {\n\t\t\tparams: {\n\t\t\t\t// to avoid caching\n\t\t\t\ttimestamp: Date.now(),\n\t\t\t},\n\t\t}\n\t\tconst commentsOptions: AxiosRequestConfig = {\n\t\t\tparams: {\n\t\t\t\t// pagination\n\t\t\t\t'page': page,\n\t\t\t\t'per_page': perPage,\n\t\t\t\t/**\n\t\t\t\t * github v3 api does not support sort for issue comments\n\t\t\t\t * have sent feedback to github support\n\t\t\t\t */\n\t\t\t\t// 'sort': 'created',\n\t\t\t\t// 'direction': sort,\n\t\t\t\t// to avoid caching\n\t\t\t\t'timestamp': Date.now(),\n\t\t\t},\n\t\t\theaders: {\n\t\t\t\t'Accept': [\n\t\t\t\t\t'application/vnd.github.v3.raw+json',\n\t\t\t\t\t'application/vnd.github.v3.html+json',\n\t\t\t\t\t'application/vnd.github.squirrel-girl-preview',\n\t\t\t\t],\n\t\t\t},\n\t\t}\n\t\tif (accessToken)\n\t\t{\n\t\t\tissueOptions.headers = {\n\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t}\n\t\t\tcommentsOptions.headers['Authorization'] = `token ${accessToken}`\n\t\t}\n\n\t\t// github v3 have to get the total count of comments by requesting the issue\n\t\tconst [issueRes, commentsRes] = await Promise.all([\n\t\t\tthis.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}`, issueOptions),\n\t\t\tthis.$http.get(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, commentsOptions),\n\t\t])\n\n\t\t// it's annoying that have to get the page and per_page from the `Link` header\n\t\tconst linkHeader = commentsRes.headers['link'] || null\n\n\t\t/* istanbul ignore next */\n\t\tconst thisPage = /rel=\"next\"/.test(linkHeader)\n\t\t\t? Number(linkHeader.replace(/^.*[^_]page=(\\d*).*rel=\"next\".*$/, '$1')) - 1\n\t\t\t: /rel=\"prev\"/.test(linkHeader)\n\t\t\t\t? Number(linkHeader.replace(/^.*[^_]page=(\\d*).*rel=\"prev\".*$/, '$1')) + 1\n\t\t\t\t: 1\n\n\t\t/* istanbul ignore next */\n\t\tconst thisPerPage = linkHeader ? Number(linkHeader.replace(/^.*per_page=(\\d*).*$/, '$1')) : perPage\n\n\t\treturn {\n\t\t\tcount: Number(issueRes.data.comments),\n\t\t\tpage: thisPage,\n\t\t\tperPage: thisPerPage,\n\t\t\tdata: commentsRes.data.map(normalizeComment),\n\t\t}\n\t}\n\n\t/**\n\t * Create a new comment\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.issueId - The id of issue\n\t * @param options.content - The content of comment\n\t *\n\t * @return The created comment\n\t *\n\t * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n\t */\n\t@logMethod\n\t@noticeError\n\tasync postComment({\n\t\taccessToken,\n\t\tissueId,\n\t\tcontent,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tcontent: string\n\t}): Promise<VssueAPI.Comment>\n\t{\n\t\tconst { data } = await Bluebird.resolve(this.$http.post(`repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {\n\t\t\t\tbody: content,\n\t\t\t}, {\n\t\t\t\theaders: {\n\t\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t\t\t'Accept': [\n\t\t\t\t\t\t'application/vnd.github.v3.raw+json',\n\t\t\t\t\t\t'application/vnd.github.v3.html+json',\n\t\t\t\t\t\t'application/vnd.github.squirrel-girl-preview',\n\t\t\t\t\t],\n\t\t\t\t},\n\t\t\t}))\n\t\t\t.tapCatch(this._handleApiError)\n\t\t;\n\t\treturn normalizeComment(data)\n\t}\n\n\t/**\n\t * Edit a comment\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.commentId - The id of comment\n\t * @param options.content - The content of comment\n\t *\n\t * @return The edited comment\n\t *\n\t * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n\t */\n\t@logMethod\n\t@noticeError\n\tasync putComment({\n\t\taccessToken,\n\t\tcommentId,\n\t\tcontent,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tcommentId: string | number\n\t\tcontent: string\n\t}): Promise<VssueAPI.Comment>\n\t{\n\t\tconst { data } = await this.$http.patch(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {\n\t\t\tbody: content,\n\t\t}, {\n\t\t\theaders: {\n\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t\t'Accept': [\n\t\t\t\t\t'application/vnd.github.v3.raw+json',\n\t\t\t\t\t'application/vnd.github.v3.html+json',\n\t\t\t\t\t'application/vnd.github.squirrel-girl-preview',\n\t\t\t\t],\n\t\t\t},\n\t\t})\n\t\treturn normalizeComment(data)\n\t}\n\n\t/**\n\t * Delete a comment\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.commentId - The id of comment\n\t *\n\t * @return `true` if succeed, `false` if failed\n\t *\n\t * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n\t */\n\t@logMethod\n\t@noticeError\n\tasync deleteComment({\n\t\taccessToken,\n\t\tcommentId,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tcommentId: string | number\n\t}): Promise<boolean>\n\t{\n\t\tconst { status } = await this.$http.delete(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {\n\t\t\theaders: { 'Authorization': `token ${accessToken}` },\n\t\t})\n\t\treturn status === 204\n\t}\n\n\t/**\n\t * Get reactions of a comment\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.commentId - The id of comment\n\t *\n\t * @return The comments\n\t *\n\t * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n\t * @see https://developer.github.com/v3/reactions/#list-reactions-for-an-issue-comment\n\t *\n\t * @remarks\n\t * The `List reactions for an issue comment` API also returns author of each reaction.\n\t * As we only need the count, use the `Get a single comment` API is much simpler.\n\t */\n\t@logMethod\n\t@noticeError\n\tasync getCommentReactions({\n\t\taccessToken,\n\t\tcommentId,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tcommentId: string | number\n\t}): Promise<VssueAPI.Reactions>\n\t{\n\t\tconst { data } = await this.$http.get(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}`, {\n\t\t\theaders: {\n\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t\t'Accept': 'application/vnd.github.squirrel-girl-preview',\n\t\t\t},\n\t\t})\n\t\treturn normalizeReactions(data.reactions)\n\t}\n\n\t/**\n\t * Create a new reaction of a comment\n\t *\n\t * @param options.accessToken - User access token\n\t * @param options.commentId - The id of comment\n\t * @param options.reaction - The reaction\n\t *\n\t * @return `true` if succeed, `false` if already token\n\t *\n\t * @see https://developer.github.com/v3/reactions/#create-reaction-for-an-issue-comment\n\t */\n\t@logMethod\n\t@noticeError\n\tasync postCommentReaction({\n\t\taccessToken,\n\t\tcommentId,\n\t\treaction,\n\t}: {\n\t\taccessToken: VssueAPI.AccessToken\n\t\tissueId: string | number\n\t\tcommentId: string | number\n\t\treaction: keyof VssueAPI.Reactions\n\t}): Promise<boolean>\n\t{\n\t\tconst response = await this.$http.post(`repos/${this.owner}/${this.repo}/issues/comments/${commentId}/reactions`, {\n\t\t\tcontent: mapReactionName(reaction),\n\t\t}, {\n\t\t\theaders: {\n\t\t\t\t'Authorization': `token ${accessToken}`,\n\t\t\t\t'Accept': 'application/vnd.github.squirrel-girl-preview',\n\t\t\t},\n\t\t})\n\t\treturn response.status === 201\n\t}\n\n}\n"]}