skapi-js 0.2.0-alpha.0 → 0.2.1

package/esm/methods/subscription.js

@@ -1,273 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import SkapiError from '../main/error';
-import validator from '../utils/validator';
-import { request } from './request';
-function subscriptionGroupCheck(option) {
-    option = validator.Params(option, {
-        user_id: (v) => validator.UserId(v, '"user_id"'),
-        group: (v) => {
-            if (v === '*') {
-                return v;
-            }
-            if (typeof v !== 'number') {
-                throw new SkapiError('"group" should be type: number.', { code: 'INVALID_PARAMETER' });
-            }
-            else if (v < 1 && v > 99) {
-                throw new SkapiError('"group" should be within range 1 ~ 99.', { code: 'INVALID_PARAMETER' });
-            }
-            return v;
-        }
-    }, ['user_id', 'group']);
-    if (this.__user && option.user_id === this.__user.user_id) {
-        throw new SkapiError(`"user_id" cannot be the user's own ID.`, { code: 'INVALID_PARAMETER' });
-    }
-    return option;
-}
-;
-export function getSubscriptions(params, fetchOptions, _mapper) {
-    return __awaiter(this, void 0, void 0, function* () {
-        params = validator.Params(params, {
-            subscriber: (v) => validator.UserId(v, 'User ID in "subscriber"'),
-            group: 'number',
-            subscription: (v) => validator.UserId(v, 'User ID in "subscription"'),
-            blocked: 'boolean'
-        });
-        if (!params.subscriber && !params.subscription) {
-            throw new SkapiError('At least either "subscriber" or "subscription" should have a value.', { code: 'INVALID_PARAMETER' });
-        }
-        let response = yield request.bind(this)('get-subscription', params, Object.assign({ auth: true }, { fetchOptions }));
-        response.list = response.list.map(_mapper || ((s) => {
-            let subscription = {};
-            let subSplit = s.sub.split('#');
-            subscription.subscriber = subSplit[2];
-            subscription.subscription = subSplit[0];
-            subscription.group = parseInt(subSplit[1]);
-            subscription.timestamp = s.stmp;
-            subscription.blocked = s.grp.substring(0, 1) === 'N';
-            return subscription;
-        }));
-        return response;
-    });
-}
-export function subscribe(option) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-        if (typeof group !== 'number') {
-            throw new SkapiError('"group" should be type: number.', { code: 'INVALID_PARAMETER' });
-        }
-        return yield request.bind(this)('subscription', {
-            subscribe: user_id,
-            group
-        }, { auth: true });
-    });
-}
-export function unsubscribe(option) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-        return yield request.bind(this)('subscription', {
-            unsubscribe: user_id,
-            group
-        }, { auth: true });
-    });
-}
-export function blockSubscriber(option) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-        return yield request.bind(this)('subscription', { block: user_id, group }, { auth: true });
-    });
-}
-export function unblockSubscriber(option) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-        return yield request.bind(this)('subscription', { unblock: user_id, group }, { auth: true });
-    });
-}
-export function getSubscribedTo(option, fetchOptions) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        option = validator.Params(option, {
-            user_id: (v) => validator.UserId(v, '"user_id"'),
-            group: 'number',
-            blocked: 'boolean'
-        }) || {};
-        return getSubscriptions.bind(this)({
-            subscriber: option.user_id || ((_a = this.__user) === null || _a === void 0 ? void 0 : _a.user_id),
-            group: option.group,
-            blocked: option.blocked
-        }, fetchOptions);
-    });
-}
-;
-export function getSubscribers(option, fetchOptions) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        option = validator.Params(option, {
-            user_id: (v) => validator.UserId(v, '"user_id"'),
-            group: 'number',
-            blocked: 'boolean'
-        }) || {};
-        let subParams = {
-            subscription: option.user_id || ((_a = this.__user) === null || _a === void 0 ? void 0 : _a.user_id),
-            group: option.group,
-            blocked: option.blocked
-        };
-        return getSubscriptions.bind(this)(subParams, fetchOptions);
-    });
-}
-;
-export function getNewsletterSubscription(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let isAdmin = yield this.checkAdmin();
-        params = validator.Params(params, {
-            user_id: v => {
-                if (v !== this.__user.user_id && !isAdmin) {
-                    throw new SkapiError(`No access.`, { code: 'INVALID_REQUEST' });
-                }
-                return v;
-            },
-            group: 'number'
-        });
-        let list = yield request.bind(this)('get-newsletter-subscription', params, { auth: true });
-        let result = [];
-        for (let sub of list) {
-            let subt = sub['subt'].split('#');
-            let active = true;
-            if (subt[0].charAt(0) === '@') {
-                active = false;
-                subt[0] = subt[0].substring(1);
-            }
-            let group = parseInt(subt[0]);
-            result.push({
-                timestamp: sub['stmp'],
-                group,
-                subscribed_email: subt[1],
-                active
-            });
-        }
-        return result;
-    });
-}
-export function subscribeNewsletter(form, callbacks) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        let params = validator.Params(form || {}, {
-            email: (v) => validator.Email(v),
-            group: ['number', 'public', 'authorized'],
-            redirect: (v) => validator.Url(v)
-        }, this.__user ? ['group'] : ['email', 'group']);
-        return request.bind(this)(`subscribe-${this.__user ? '' : 'public-'}newsletter`, params, { fetchOptions: callbacks, auth: !!this.__user });
-    });
-}
-export function unsubscribeNewsletter(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield this.__connection;
-        params = validator.Params(params, {
-            group: ['number', 'public', 'authorized']
-        }, ['group']);
-        let param_send = Object.assign({
-            action: 'unsubscribe'
-        }, params);
-        return request.bind(this)('subscribe-newsletter', param_send, { auth: true });
-    });
-}
-export function getNewsletters(params, fetchOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let isAdmin = yield this.checkAdmin();
-        let searchType = {
-            'message_id': 'string',
-            'timestamp': 'number',
-            'read': 'number',
-            'complaint': 'number',
-            'subject': 'string'
-        };
-        if (!params) {
-            if (!fetchOptions) {
-                fetchOptions = {};
-            }
-            fetchOptions.ascending = false;
-        }
-        let _params = params || {
-            searchFor: 'timestamp',
-            value: 0,
-            condition: '>'
-        };
-        params = validator.Params(_params, {
-            searchFor: ['message_id', 'timestamp', 'read', 'complaint', 'group', 'subject'],
-            value: (v) => {
-                if (typeof v !== searchType[_params.searchFor]) {
-                    throw new SkapiError(`"value" type does not match the type of "${_params.searchFor}" index.`, { code: 'INVALID_PARAMETER' });
-                }
-                else if (typeof v === 'string' && !v) {
-                    throw new SkapiError('"value" should not be empty string.', { code: 'INVALID_PARAMETER' });
-                }
-                return v;
-            },
-            range: (v) => {
-                if (!_params.hasOwnProperty('value') || typeof v !== typeof _params.value) {
-                    throw new SkapiError('"range" should match type of "value".', { code: 'INVALID_PARAMETER' });
-                }
-                return v;
-            },
-            condition: ['>', '>=', '=', '<', '<=', 'gt', 'gte', 'eq', 'lt', 'lte', () => '='],
-            group: (x) => {
-                if (!this.session) {
-                    throw new SkapiError('User should be logged in.', { code: 'INVALID_REQUEST' });
-                }
-                if (x === 'public') {
-                    return 0;
-                }
-                else if (x === 'authorized') {
-                    return 1;
-                }
-                else if (typeof x === 'number') {
-                    if (!isAdmin && x > parseInt(this.session.idToken.payload.access_group)) {
-                        throw new SkapiError('User has no access.', { code: 'INVALID_REQUEST' });
-                    }
-                }
-                return x;
-            }
-        }, ['searchFor', 'value', 'group']);
-        let mails = yield request.bind(this)(params.group === 0 ? 'get-public-newsletters' : 'get-newsletters', params, Object.assign({ method: 'get', auth: params.group !== 0 }, { fetchOptions }));
-        let remap = {
-            'message_id': 'mid',
-            'timestamp': 'stmp',
-            'complaint': 'cmpl',
-            'read': 'read',
-            'subject': 'subj',
-            'bounced': 'bnce',
-            'url': 'url'
-        };
-        let defaults = {
-            'message_id': '',
-            'timestamp': 0,
-            'complaint': 0,
-            'read': 0,
-            'subject': '',
-            'bounced': 0,
-            'url': ''
-        };
-        mails.list = mails.list.map(m => {
-            let remapped = {};
-            for (let k in remap) {
-                remapped[k] = m[remap[k]] || defaults[remap[k]];
-            }
-            return remapped;
-        });
-        return mails;
-    });
-}