@marxlnfcs/wildduck-api/lib/api/components/users/users.service.js

Provides a client to interact with the wildduck api

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WildduckUsersService = void 0;
const client_component_1 = require("../../client-component");
const create_http_client_1 = require("../../../internals/create-http-client");
class WildduckUsersService extends client_component_1.WildduckClientComponent {
    deleteUser(id, options) {
        return new Promise(async (resolve, reject) => {
            this.http.delete('/users/{id}', { params: { id }, query: options })
                .then(r => {
                this.events.emitFromResponse(this.deleteUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.deleteUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    getUser(id) {
        return new Promise(async (resolve, reject) => {
            this.http.get('/users/{id}', { params: { id } })
                .then(r => {
                this.events.emitFromResponse(this.getUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.getUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    updateUser(id, dto) {
        return new Promise(async (resolve, reject) => {
            this.http.put('/users/{id}', { params: { id }, body: dto })
                .then(r => {
                this.events.emitFromResponse(this.updateUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.updateUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    getUpdates(id) {
        return new Promise(async (resolve, reject) => {
            try {
                resolve(this.sse.create('/users/{id}/updates', { id }));
            }
            catch (e) {
                reject(e);
            }
        });
    }
    resolveUserId(username) {
        return new Promise(async (resolve, reject) => {
            this.http.get('/users/resolve/{username}', { params: { username } })
                .then(r => {
                this.events.emitFromResponse(this.resolveUserId, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.resolveUserId, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    restoreUserInfo(id, options) {
        return new Promise(async (resolve, reject) => {
            this.http.get('/users/{id}/restore', { params: { id }, query: options })
                .then(r => {
                this.events.emitFromResponse(this.restoreUserInfo, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.restoreUserInfo, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    restoreUser(id, options) {
        return new Promise(async (resolve, reject) => {
            this.http.post('/users/{id}/restore', { params: { id }, body: options })
                .then(r => {
                this.events.emitFromResponse(this.restoreUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.restoreUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    getUsers(options) {
        return new Promise(async (resolve, reject) => {
            this.http.get('/users', { query: options })
                .then(r => {
                this.events.emitFromResponse(this.getUsers, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.getUsers, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    createUser(dto) {
        return new Promise(async (resolve, reject) => {
            this.http.post('/users', { body: dto })
                .then(r => {
                this.events.emitFromResponse(this.createUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.createUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    recalculateQuota(user) {
        return new Promise(async (resolve, reject) => {
            this.http.post('/users/{user}/quota/reset', { params: { user } })
                .then(r => {
                this.events.emitFromResponse(this.recalculateQuota, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.recalculateQuota, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    recalculateQuotaAllUsers() {
        return new Promise(async (resolve, reject) => {
            this.http.post('/users/reset')
                .then(r => {
                this.events.emitFromResponse(this.recalculateQuotaAllUsers, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.recalculateQuotaAllUsers, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    logoutUser(id, dto) {
        return new Promise(async (resolve, reject) => {
            this.http.put('/users/{id}/logout', { params: { id }, body: dto })
                .then(r => {
                this.events.emitFromResponse(this.logoutUser, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.logoutUser, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
    resetUserPassword(id, dto) {
        return new Promise(async (resolve, reject) => {
            this.http.post('/users/{id}/password/reset', { params: { id }, body: dto })
                .then(r => {
                this.events.emitFromResponse(this.resetUserPassword, r);
                resolve(r.data);
            })
                .catch((e) => {
                this.events.emitFromError(this.resetUserPassword, e);
                reject((0, create_http_client_1.createHttpException)(e));
            });
        });
    }
}
exports.WildduckUsersService = WildduckUsersService;