gallery.accords-library.com/client/js/models/user_token.js

'use strict';

const api = require('../api.js');
const uri = require('../util/uri.js');
const events = require('../events.js');

class UserToken extends events.EventTarget {
    constructor() {
        super();
        this._orig = {};
        this._updateFromResponse({});
    }

    get token() {
        return this._token;
    }

    get note() {
        return this._note;
    }

    get enabled() {
        return this._enabled;
    }

    get version() {
        return this._version;
    }

    get expirationTime() {
        return this._expirationTime;
    }

    get creationTime() {
        return this._creationTime;
    }

    get lastEditTime() {
        return this._lastEditTime;
    }

    get lastUsageTime() {
        return this._lastUsageTime;
    }

    set note(value) {
        this._note = value;
    }

    static fromResponse(response) {
        if (typeof response.results !== 'undefined') {
            let tokenList = [];
            for (let responseToken of response.results) {
                const token = new UserToken();
                token._updateFromResponse(responseToken);
                tokenList.push(token)
            }
            return tokenList;
        } else {
            const ret = new UserToken();
            ret._updateFromResponse(response);
            return ret;
        }
    }

    static get(userName) {
        return api.get(uri.formatApiLink('user-tokens', userName))
            .then(response => {
                return Promise.resolve(UserToken.fromResponse(response));
            });
    }

    static create(userName, note, expirationTime) {
        let userTokenRequest = {
            enabled: true
        };
        if (note) {
            userTokenRequest.note = note;
        }
        if (expirationTime) {
            userTokenRequest.expirationTime = expirationTime;
        }
        return api.post(uri.formatApiLink('user-token', userName), userTokenRequest)
            .then(response => {
                return Promise.resolve(UserToken.fromResponse(response))
            });
    }

    save(userName) {
        const detail = {version: this._version};

        if (this._note !== this._orig._note) {
            detail.note = this._note;
        }

        return api.put(
            uri.formatApiLink('user-token', userName, this._orig._token),
            detail)
            .then(response => {
                this._updateFromResponse(response);
                this.dispatchEvent(new CustomEvent('change', {
                    detail: {
                        userToken: this,
                    },
                }));
                return Promise.resolve(this);
            });
    }

    delete(userName) {
        return api.delete(
            uri.formatApiLink('user-token', userName, this._orig._token),
            {version: this._version})
            .then(response => {
                this.dispatchEvent(new CustomEvent('delete', {
                    detail: {
                        userToken: this,
                    },
                }));
                return Promise.resolve();
            });
    }

    _updateFromResponse(response) {
        const map = {
            _token: response.token,
            _note: response.note,
            _enabled: response.enabled,
            _expirationTime: response.expirationTime,
            _version: response.version,
            _creationTime: response.creationTime,
            _lastEditTime: response.lastEditTime,
            _lastUsageTime: response.lastUsageTime,
        };

        Object.assign(this, map);
        Object.assign(this._orig, map);
    }
}

module.exports = UserToken;