io.parrots/fesm2015/io.parrots.js

Parrots.io App

import { DefaultConnectionManager, CONNECTION_DATA, BackgroundProcessManager, ConnectionManager, ObservableManager, PhloxAppInfoService, AbstractServerResource, DataSchema, DataField, DefaultDataEditorViewProvider, DefaultDataEditorActionProvider, ActionModel, TypeResolveService, DataUtils, APP_BASE_URLS, PhloxAppService, NeedFocusService, NotificationManager, PhloxAppInfo, AbstractSideSlidePanel, AbstractPage, AbstractRippleButton, AbstractNavMenu, Option, AbstractNavItem, AbstractDialogController, DateTimeUtils, I18N, ButtonModel, DefaultSelectItemModel, LanguageButtonModel, DialogService, AbstractComponentDataLangSelector, AbstractDataEditor, EventUtils, ComponentDialogModel, DATA_DESTROY_EVENT, DATA_PROMOTE_EVENT, DATA_QUERY_EVENT, DataEditorActionProvider, DataEditorViewProvider, DataServiceFactory, PhloxModule } from 'com.phloxui';
import { InjectionToken, Injectable, Inject, Component, HostListener, Input, ElementRef, Output, ViewChild, EventEmitter, NgModule } from '@angular/core';
import { Http, RequestOptions, Headers, RequestMethod, URLSearchParams, HttpModule, JsonpModule } from '@angular/http';
import { __decorate, __metadata } from 'tslib';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { RouterModule } from '@angular/router';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { LoadersCssModule } from 'angular2-loaders-css';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ParrotsDefaultConnectionManager extends DefaultConnectionManager {
    /**
     * @param {?} baseURLs
     * @param {?} http
     * @param {?} bgProcMgr
     * @param {?=} testMode
     * @param {?=} testData
     */
    constructor(baseURLs, http, bgProcMgr, testMode, testData) {
        super(baseURLs, http, bgProcMgr);
        this.testMode = testMode;
        this.testData = testData;
    }
    /**
     * @return {?}
     */
    isTestMode() {
        return this.testMode;
    }
    /**
     * @return {?}
     */
    getTestData() {
        return this.testData;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const /** @type {?} */ TEST_MODE = new InjectionToken("TEST_MODE");
const /** @type {?} */ TEST_DATA = new InjectionToken("TEST_DATA"); // value as {"className": []"array of data"}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const /** @type {?} */ RUNNING = 'RUNNING';
const /** @type {?} */ BASE_URL = 'http://10.1.0.22/api';
const /** @type {?} */ TEST_INSTANCE_ID = 'TEST';
/**
 * <p style="text-indent: 2em;">
 * A <code>ng</code> service class implementing [[InstanceConnectionManager]] service interface. Please see [[InstanceConnectionManager]] for more details.
 * </p>
 *
 * @author shiorin, tee4cute
 */
class InstanceConnectionManager {
    /**
     * @param {?} connectionManager
     * @param {?} http
     * @param {?} bgProcessMgr
     * @param {?} testMode
     * @param {?} testData
     */
    constructor(connectionManager, http, bgProcessMgr, testMode, testData) {
        this.seletedInstanceId = "";
        this.http = http;
        this.bgProcessMgr = bgProcessMgr;
        this.connectionManager = connectionManager;
        this.instanceConnectionManagerMap = {};
        this.testMode = testMode;
        this.testData = testData;
        // if (testMode) {
        this.seletedInstanceId = TEST_INSTANCE_ID;
        this.instanceConnectionManagerMap[this.seletedInstanceId] = new ParrotsDefaultConnectionManager(null, this.http, this.bgProcessMgr, testMode, testData);
        // }
    }
    /**
     * @param {?} instanceUUID
     * @return {?}
     */
    getNodes(instanceUUID) {
        if (this.connectionManager !== null && typeof this.connectionManager !== 'undefined') {
            let /** @type {?} */ url = BASE_URL + "/instance/" + instanceUUID + "/node";
            let /** @type {?} */ requestOptionsArgs = new RequestOptions();
            return this.connectionManager.getWithHttpInfo(url, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * ## setup instance: generate connectionManager by instanceUUID and cache in map
     * @param {?} instanceUUID
     * @param {?=} loginData
     * @return {?}
     */
    setUpInstance(instanceUUID, loginData) {
        return new Promise((resolve, reject) => {
            this.getNodes(instanceUUID).then((res) => {
                let /** @type {?} */ itemNodes = JSON.parse(res._body).items;
                let /** @type {?} */ runnintMode = false;
                for (let /** @type {?} */ itemNode of itemNodes) {
                    if (itemNode.status === RUNNING) {
                        runnintMode = true;
                        let /** @type {?} */ conMgr = new ParrotsDefaultConnectionManager(null, this.http, this.bgProcessMgr, this.testMode, this.testData);
                        conMgr.setName(itemNode._uuid);
                        //Set for test.
                        let /** @type {?} */ url = itemNode.serverNode.hostName == "localhost" ? "http://10.1.0.22" : itemNode.serverNode.hostName;
                        url += ":" + itemNode.servicePort + "/api";
                        conMgr.addBaseURLs(url);
                        if (loginData !== undefined) {
                            url += "/user/login";
                            this.connectionManager.postWithHttpInfo(url, loginData, new RequestOptions()).then((res) => {
                                let /** @type {?} */ sessionId = JSON.parse((/** @type {?} */ (res))._body).sessionId;
                                conMgr.setDefaultHeader('Session-Id', sessionId);
                                this.instanceConnectionManagerMap[instanceUUID] = conMgr;
                                resolve(itemNodes);
                            }).catch((error) => {
                                this.instanceConnectionManagerMap[instanceUUID] = conMgr;
                                reject(error);
                            });
                        }
                        else {
                            this.instanceConnectionManagerMap[instanceUUID] = conMgr;
                        }
                    }
                }
                if (loginData === undefined) {
                    if (runnintMode) {
                        resolve(itemNodes);
                    }
                    reject(itemNodes);
                }
            }).catch((error) => {
                reject(error);
            });
        });
    }
    /**
     * ## setup instances: generate connectionManager by instanceUUIDs and cache in map
     * @param {?} instances
     * @return {?}
     */
    setUpInstances(instances) {
        if (instances === undefined || instances === null) {
            return Promise.resolve([]);
        }
        let /** @type {?} */ proms = [];
        for (let /** @type {?} */ instanceUUID in instances) {
            if (instanceUUID === null || instanceUUID === undefined) {
                continue;
            }
            proms.push(this.setUpInstance(instanceUUID, instances[instanceUUID]));
        }
        return Promise.all(proms);
    }
    /**
     * ## remove instance by instanceUUID from map
     * @param {?} instanceUUID
     * @return {?}
     */
    tearDownInstance(instanceUUID) {
        delete this.instanceConnectionManagerMap[instanceUUID];
    }
    /**
     * ## remove instance instanceUUID from map
     * @param {?=} instanceUUID
     * @return {?}
     */
    getInstanceConnectionManager(instanceUUID) {
        if (instanceUUID !== undefined && instanceUUID !== null && instanceUUID !== '') {
            return this.instanceConnectionManagerMap[instanceUUID];
        }
        if (this.seletedInstanceId === undefined || this.seletedInstanceId === null) {
            return null;
        }
        return this.instanceConnectionManagerMap[this.seletedInstanceId];
    }
    /**
     * @param {?} instanceUUID
     * @return {?}
     */
    selectInstance(instanceUUID) {
        this.seletedInstanceId = instanceUUID;
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    get(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().get(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    getWithHttpInfo(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().getWithHttpInfo(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    post(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().post(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    postWithHttpInfo(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().postWithHttpInfo(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    put(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().put(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    putWithHttpInfo(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().putWithHttpInfo(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    delete(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().delete(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    deleteWithHttpInfo(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().deleteWithHttpInfo(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    patch(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().patch(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} body
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    patchWithHttpInfo(url, body, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().patchWithHttpInfo(url, body, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    head(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().head(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    headWithHttpInfo(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().headWithHttpInfo(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    options(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().options(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    optionsWithHttpInfo(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().optionsWithHttpInfo(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    request(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().request(url, requestOptionsArgs);
    }
    /**
     * @param {?} url
     * @param {?} requestOptionsArgs
     * @return {?}
     */
    requestWithHttpInfo(url, requestOptionsArgs) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            return Promise.reject('Connection Manager is not setup yet.');
        }
        return this.getInstanceConnectionManager().requestWithHttpInfo(url, requestOptionsArgs);
    }
    /**
     * @return {?}
     */
    getRunningProcessesCount() {
        if (this.seletedInstanceId === null || this.seletedInstanceId === undefined) {
            return null;
        }
        if (this.bgProcessMgr != null && typeof this.bgProcessMgr !== 'undefined') {
            this.bgProcessMgr.getRunningProcessesCount(CONNECTION_DATA, this.seletedInstanceId);
        }
        return 0;
    }
    /**
     * @return {?}
     */
    getRunningProcesses() {
        if (this.seletedInstanceId === null || this.seletedInstanceId === undefined) {
            return null;
        }
        if (this.bgProcessMgr != null && typeof this.bgProcessMgr !== 'undefined') {
            this.bgProcessMgr.getRunningProcesses(CONNECTION_DATA, this.seletedInstanceId);
        }
        return [];
    }
    /**
     * @return {?}
     */
    getConnectionQuality() {
        // TODO
        return this.connectionManager.getConnectionQuality();
    }
    /**
     * @param {?} urls
     * @return {?}
     */
    setBaseURLs(urls) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().setBaseURLs(urls);
    }
    /**
     * @return {?}
     */
    resetBaseURLs() {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().resetBaseURLs();
    }
    /**
     * @param {?} key
     * @param {?} value
     * @return {?}
     */
    setDefaultHeader(key, value) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().setDefaultHeader(key, value);
    }
    /**
     * @param {?} key
     * @return {?}
     */
    removeDefaultHeader(key) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().removeDefaultHeader(key);
    }
    /**
     * @return {?}
     */
    resetDefaultHeaders() {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().resetDefaultHeaders();
    }
    /**
     * @param {?} key
     * @param {?} value
     * @return {?}
     */
    setSearch(key, value) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().setSearch(key, value);
    }
    /**
     * @param {?} key
     * @return {?}
     */
    removeSearch(key) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().removeSearch(key);
    }
    /**
     * @return {?}
     */
    resetSearch() {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().resetSearch();
    }
    /**
     * @param {?} key
     * @param {?} value
     * @return {?}
     */
    setParam(key, value) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().setParam(key, value);
    }
    /**
     * @param {?} key
     * @return {?}
     */
    removeParam(key) {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().removeParam(key);
    }
    /**
     * @return {?}
     */
    resetParams() {
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().resetParams();
    }
    /**
     * @return {?}
     */
    getName() {
        return this.name;
    }
    /**
     * @param {?} name
     * @return {?}
     */
    setName(name) {
        this.name = name;
        if (this.getInstanceConnectionManager() === null || this.getInstanceConnectionManager() === undefined) {
            throw ('Connection Manager is not setup yet.');
        }
        this.getInstanceConnectionManager().setName(name);
    }
    /**
     * @template R
     * @param {?} type
     * @return {?}
     */
    createResource(type) {
        return this.getInstanceConnectionManager().createResource(type);
    }
}
InstanceConnectionManager.decorators = [
    { type: Injectable },
];
/** @nocollapse */
InstanceConnectionManager.ctorParameters = () => [
    { type: ConnectionManager, },
    { type: Http, },
    { type: BackgroundProcessManager, },
    { type: undefined, decorators: [{ type: Inject, args: [TEST_MODE,] },] },
    { type: undefined, decorators: [{ type: Inject, args: [TEST_DATA,] },] },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class JobScheduler {
    /**
     * @param {?} instanceConnectionManager
     */
    constructor(instanceConnectionManager) {
        this.instanceConnectionManager = instanceConnectionManager;
    }
    /**
     * @param {?} sessionId
     * @return {?}
     */
    setInstanceSessionId(sessionId) {
        sessionStorage.setItem(JobScheduler.SESSION_ID_KEY, sessionId);
    }
    /**
     * @return {?}
     */
    getInstanceSessionId() {
        return sessionStorage.getItem(JobScheduler.SESSION_ID_KEY);
    }
    /**
     * @param {?} options
     * @param {?} headerData
     * @param {?=} xmlType
     * @return {?}
     */
    addingHeaderRequestOptionsArgs(options, headerData, xmlType) {
        if (options === null || typeof options === 'undefined') {
            options = new RequestOptions();
        }
        if (headerData !== null && typeof headerData !== 'undefined') {
            if (options.headers !== null && typeof options.headers !== 'undefined') {
                for (let /** @type {?} */ key in headerData) {
                    options.headers.set(key, headerData[key]);
                }
            }
            else {
                options.headers = new Headers(headerData);
            }
        }
        let /** @type {?} */ sessionId = this.getInstanceSessionId();
        if (sessionId !== undefined && sessionId !== null) {
            options.headers.delete('Session-Id');
            options.headers.set('Session-Id', sessionId);
        }
        if (xmlType) {
            options.headers.set("Accept", "application/xml");
            options.headers.set("Content-Type", "application/xml");
        }
        else {
            options.headers.set("Content-Type", "application/json");
        }
        return options;
    }
    /**
     * @return {?}
     */
    getListJob() {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/query";
            let /** @type {?} */ body = {
                "filter": ""
            };
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} uuid
     * @return {?}
     */
    interruptJob(uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/" + uuid + "/interrupt";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            let /** @type {?} */ body = {};
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} body
     * @return {?}
     */
    createJob(body) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @return {?}
     */
    getListSchedule() {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/query";
            let /** @type {?} */ body = {
                "filter": ""
            };
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} body
     * @return {?}
     */
    createSchedule(body) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} body
     * @return {?}
     */
    editSchedule(body) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + body.uuid;
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.putWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} uuid
     * @return {?}
     */
    enableSchedule(uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + uuid + "/enable";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            let /** @type {?} */ body = {};
            return this.instanceConnectionManager.putWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} uuid
     * @return {?}
     */
    disableSchedule(uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + uuid + "/disable";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            let /** @type {?} */ body = {};
            return this.instanceConnectionManager.putWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} uuid
     * @return {?}
     */
    getTrigger(uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + uuid + "/trigger";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.getWithHttpInfo(url, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} body
     * @param {?} uuid
     * @return {?}
     */
    addTrigger(body, uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + uuid + "/trigger";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} _uuid
     * @param {?} uuidTrigger
     * @return {?}
     */
    removeTrigger(_uuid, uuidTrigger) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + _uuid + "/trigger/" + uuidTrigger;
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.deleteWithHttpInfo(url, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
    /**
     * @param {?} body
     * @param {?} uuid
     * @return {?}
     */
    createCron(body, uuid) {
        if (this.instanceConnectionManager !== null && typeof this.instanceConnectionManager !== 'undefined') {
            let /** @type {?} */ url = "admin/job/schedule/" + uuid + "/trigger/cron";
            //! for testing
            let /** @type {?} */ requestOptionsArgs = this.addingHeaderRequestOptionsArgs(new RequestOptions(), {
                "Increment-Version": "false",
            });
            return this.instanceConnectionManager.postWithHttpInfo(url, body, requestOptionsArgs);
        }
        else {
            return Promise.reject(null);
        }
    }
}
JobScheduler.SESSION_ID_KEY = 'Instance-Session-Id';
JobScheduler.decorators = [
    { type: Injectable },
];
/** @nocollapse */
JobScheduler.ctorParameters = () => [
    { type: InstanceConnectionManager, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const /** @type {?} */ TIMEOUT_TOPIC = 'user-service.session.timeout';
const /** @type {?} */ ERROR_TOPIC = 'user-service.session.error';
class UserService {
    /**
     * @param {?} obsMgr
     * @param {?} phloxAppInfoService
     */
    constructor(obsMgr, phloxAppInfoService) {
        this.obsMgr = obsMgr;
        if (phloxAppInfoService != null) {
            phloxAppInfoService.getAppInfo().then((result) => {
                this.phloxAppInfo = result;
            });
        }
    }
    /**
     * @return {?}
     */
    loadAccessibleApp() {
        // ! TODO: Edit this on PRODUCTION
        return null;
    }
    /**
     * @return {?}
     */
    validateConnectionTimeout() {
        this.timeout = setTimeout(() => {
            if (this.userSession !== null && this.userSession !== undefined) {
                this.userSession.checkTimeout().then((result) => {
                    if (!result) {
                        this.obsMgr.publish(UserService.TIMEOUT_TOPIC, result);
                    }
                    this.validateConnectionTimeout();
                }).catch((error) => {
                    this.obsMgr.publish(UserService.ERROR_TOPIC, error);
                    this.validateConnectionTimeout();
                });
            }
        }, this.phloxAppInfo.settings.DEFAULT_TIME_OUT_LOGIN_USER_SESSION);
    }
    /**
     * @return {?}
     */
    isLoggedOn() {
        if (this.userSession === null || this.userSession === undefined) {
            return Promise.resolve(false);
        }
        return this.userSession.load().then((result) => {
            if (this.userSession.getSessionId() === undefined || this.userSession.getSessionId() === null || this.userSession.getSessionId() === '') {
                return false;
            }
            else {
                return this.userSession.checkTimeout().then((res) => {
                    if (res) {
                        if (this.timeout === null || this.timeout === undefined) {
                            this.validateConnectionTimeout();
                        }
                        return true;
                    }
                    else {
                        return false;
                    }
                });
            }
        });
    }
    /**
     * @return {?}
     */
    reloadAccessibleApp() {
        this.accessibleApps = null;
        return this.getAccessibleApp();
    }
    /**
     * @return {?}
     */
    getAccessibleApp() {
        if (this.accessibleApps !== null && typeof this.accessibleApps !== 'undefined') {
            return Promise.resolve(this.accessibleApps);
        }
        else {
            let /** @type {?} */ prom = this.loadAccessibleApp();
            if (prom !== null && prom !== undefined) {
                return this.loadAccessibleApp().then((result) => {
                    this.accessibleApps = result;
                    return Promise.resolve(this.accessibleApps);
                });
            }
            else {
                return Promise.resolve(null);
            }
        }
    }
    /**
     * @param {?} requestData
     * @return {?}
     */
    login(requestData) {
        if (this.userSession === null || this.userSession === undefined) {
            return Promise.reject(null);
        }
        let /** @type {?} */ state = this.userSession.login(requestData);
        state.then((response) => {
            if (response.status === 200) {
                if (this.timeout !== null && this.timeout !== undefined) {
                    clearTimeout(this.timeout);
                    this.timeout = null;
                }
                this.validateConnectionTimeout();
                return Promise.resolve(response);
            }
            else {
                return Promise.reject(response);
            }
        });
        return state;
    }
    /**
     * @return {?}
     */
    logout() {
        if (this.userSession === null || this.userSession === undefined) {
            return Promise.reject(null);
        }
        let /** @type {?} */ state = this.userSession.logout();
        state.then((response) => {
            if (response.status === 200) {
                if (this.timeout !== null && this.timeout !== undefined) {
                    clearTimeout(this.timeout);
                    this.timeout = null;
                }
                return Promise.resolve(response);
            }
            else {
                return Promise.reject(response);
            }
        });
        return state;
    }
    /**
     * @return {?}
     */
    getObservableManager() {
        return this.obsMgr;
    }
    /**
     * @param {?} session
     * @return {?}
     */
    initialize(session) {
        if (this.timeout !== null && this.timeout !== undefined) {
            clearTimeout(this.timeout);
            this.timeout = null;
        }
        this.userSession = session;
    }
    /**
     * @return {?}
     */
    deinitialize() {
        if (this.timeout !== null && this.timeout !== undefined) {
            clearTimeout(this.timeout);
            this.timeout = null;
        }
        this.userSession = null;
    }
    /**
     * @return {?}
     */
    getUserSession() {
        return this.userSession;
    }
}
UserService.TIMEOUT_TOPIC = TIMEOUT_TOPIC;
UserService.ERROR_TOPIC = ERROR_TOPIC;
UserService.decorators = [
    { type: Injectable },
];
/** @nocollapse */
UserService.ctorParameters = () => [
    { type: ObservableManager, },
    { type: PhloxAppInfoService, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ParrotsEditorSettingService {
    /**
     * @param {?} className
     * @param {?} baseURL
     * @param {?} connectionManager
     */
    constructor(className, baseURL, connectionManager) {
        this.className = className;
        this.baseURL = baseURL;
        this.connectionManager = connectionManager;
    }
    /**
     * @return {?}
     */
    loadSettings() {
        // create versionHistoryModel from setting
        return Promise.resolve(null);
    }
    /**
     * @param {?} setting
     * @return {?}
     */
    saveSettings(setting) {
        return Promise.resolve(true);
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ParrotsEditorViewSetting {
    /**
     * @param {?} className
     * @param {?} baseURL
     * @param {?} userConfigResource
     * @param {?} viewType
     * @param {?} configName
     */
    constructor(className, baseURL, userConfigResource, viewType, configName) {
        this.className = className;
        this.baseURL = baseURL;
        this.userConfigResource = userConfigResource;
        this.viewType = viewType;
        this.configName = configName;
        this.VIEW_CONFIG_NAME = ((configName !== null && typeof configName !== 'undefined') ? configName : '') + '.' +
            ((viewType !== null && typeof viewType !== 'undefined') ? viewType : '');
        if (this.VIEW_CONFIG_NAME.endsWith(".")) {
            this.VIEW_CONFIG_NAME = this.VIEW_CONFIG_NAME.substring(0, this.VIEW_CONFIG_NAME.length - 1);
        }
    }
    /**
     * @return {?}
     */
    loadSettings() {
        if (this.VIEW_CONFIG_NAME !== undefined && this.VIEW_CONFIG_NAME !== '') {
            return new Promise((resolve, reject) => {
                this.userConfigResource.getUserConfigWithName(this.VIEW_CONFIG_NAME).then((result) => {
                    // result in pattern {"value":"..."}
                    // data is in value tag
                    let /** @type {?} */ resultJSON = JSON.parse(result);
                    resolve(resultJSON);
                }, (err) => {
                    reject(err);
                });
            }).catch((error) => {
                return Promise.reject(error);
            });
        }
        return Promise.resolve(null);
    }
    /**
     * @param {?} setting
     * @return {?}
     */
    saveSettings(setting) {
        // expected setting in pattern { "value" : { "...": "..."} }
        if (setting !== null && typeof setting !== 'undefined') {
            return new Promise((resolve, reject) => {
                this.userConfigResource.saveUserConfigWithName(this.VIEW_CONFIG_NAME, setting).then((result) => {
                    // data is in value tag
                    let /** @type {?} */ resultJSON = JSON.parse(result);
                    resolve(resultJSON);
                }, (err) => {
                    reject(err);
                });
            }).catch((error) => {
                return Promise.reject(error);
            });
        }
        return Promise.resolve(null);
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class UserConfigResource extends AbstractServerResource {
    /**
     * @param {?} connectionMgr
     */
    constructor(connectionMgr) {
        super(connectionMgr);
        this.basePath = './me/config';
        this.defaultHeaders = new Headers();
        this.defaultHeaders.set('Content-Type', 'application/json');
    }
    /**
     * @return {?}
     */
    getUserConfig() {
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Get,
            headers: headers
        });
        return this.connectionMgr.get(this.basePath, requestOptions);
    }
    /**
     * @param {?} configName
     * @return {?}
     */
    getUserConfigWithName(configName) {
        let /** @type {?} */ url = this.basePath + "/" + configName;
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Get,
            headers: headers
        });
        return this.connectionMgr.get(url, requestOptions);
    }
    /**
     * @param {?} configName
     * @return {?}
     */
    deleteUserConfigWithName(configName) {
        let /** @type {?} */ url = this.basePath + "/" + configName;
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Delete,
            headers: headers
        });
        return this.connectionMgr.delete(url, requestOptions);
    }
    /**
     * @param {?} configName
     * @param {?} value
     * @return {?}
     */
    saveUserConfigWithName(configName, value) {
        let /** @type {?} */ url = this.basePath + "/" + configName;
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Put,
            headers: headers
        });
        let /** @type {?} */ body = value;
        return this.connectionMgr.put(url, body, requestOptions);
    }
    /**
     * @param {?} configName
     * @return {?}
     */
    getUserConfigWithNameDefaultNull(configName) {
        let /** @type {?} */ url = this.basePath + "/" + configName + "/default";
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Get,
            headers: headers
        });
        return this.connectionMgr.get(url, requestOptions);
    }
    /**
     * @param {?} configName
     * @param {?} defaultValue
     * @return {?}
     */
    getUserConfigWithNameDefault(configName, defaultValue) {
        let /** @type {?} */ url = this.basePath + "/" + configName + "/default";
        let /** @type {?} */ headers = new Headers(this.defaultHeaders.toJSON());
        let /** @type {?} */ requestOptions = new RequestOptions({
            method: RequestMethod.Post,
            headers: headers
        });
        let /** @type {?} */ body = defaultValue;
        return this.connectionMgr.post(url, body, requestOptions);
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const /** @type {?} */ BASE_URL$1 = 'http://localhost:8080/hello/';
class ParrotsEditorSettingServiceFactory {
    /**
     * @param {?} connectionManager
     */
    constructor(connectionManager) {
        this.connectionManager = connectionManager;
        this.userConfigResource = new UserConfigResource(connectionManager);
    }
    /**
     * @param {?} editor
     * @param {?} viewType
     * @return {?}
     */
    createViewSettingService(editor, viewType) {
        if (editor === null || typeof editor === 'undefined') {
            return null;
        }
        if (editor.getDataClassName() === null || typeof editor.getDataClassName() === 'undefined') {
            return null;
        }
        let /** @type {?} */ configName = editor.getConfigName();
        if (configName === null || typeof configName === 'undefined') {
            return null;
        }
        // return setting by editor class
        let /** @type {?} */ service = new ParrotsEditorViewSetting(editor.getDataClassName(), BASE_URL$1 + editor.getDataClassName(), this.userConfigResource, viewType, configName);
        return Promise.resolve(service);
    }
    /**
     * @param {?} editor
     * @return {?}
     */
    createEditorSettingService(editor) {
        if (editor === null || typeof editor === 'undefined') {
            return null;
        }
        //! return setting by editor class
        let /** @type {?} */ service = new ParrotsEditorSettingService(editor.getDataClassName(), BASE_URL$1 + editor.getDataClassName(), this.connectionManager);
        return Promise.resolve(service);
    }
}
ParrotsEditorSettingServiceFactory.decorators = [
    { type: Injectable },
];
/** @nocollapse */
ParrotsEditorSettingServiceFactory.ctorParameters = () => [
    { type: ConnectionManager, },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class ParrotsDataSchema extends DataSchema {
    /**
     * @param {?} className
     * @param {?} label
     * @param {?} dataFields
     * @param {?} jsonSchema
     */
    constructor(className, label, dataFields, jsonSchema) {
        super(label, dataFields, jsonSchema);
        this.className = className;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
class AbstractParrotsServerResource extends AbstractServerResource {
    /**
     * @return {?}
     */
    isTestMode() {
        if (typeof this.connectionMgr["isTestMode"] === 'function') {
            return (/** @type {?} */ (this.connectionMgr)).isTestMode();
        }
        return false;
    }
    /**
     * @return {?}
     */
    getTestData() {
        if (typeof this.connectionMgr["getTestData"] === 'function') {
            return (/** @type {?} */ (this.connectionMgr)).getTestData();
        }
        return undefined;
    }
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
const /** @type {?} */ BASE_PATH = "./classes";
class ClassesResource extends AbstractParrotsServerResource {
    /**
     * @param {?} connectionMgr
     * @param {?=} basePath
     */
    constructor(connectionMgr, basePath) {
        super(connectionMgr);
        this.basePath = BASE_PATH;
        this.defaultHeaders = new Headers();
        if (basePath !== null && basePath !== undefined && basePath !== '') {
            this.basePath = basePath;
        }
    }
    /**
     * @return {?}
     */
    uuid4Generate() {
        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
            var /** @type {?} */ r = Math.random() * 16 | 0, /** @type {?} */ v = c == 'x' ? r : (r & 0x3 | 0x8);
            return v.toString(16);
        });
    }
    /**
     * @param {?} classname
     * @param {?} uuid
     * @return {?}
     */
    findTestData(classname, uuid) {
        let /** @type {?} */ testData = this.getTestData();
        let /** @type {?} */ testArray = (testData !== null && testData !== undefined) ? testData[classname] : [];
        for (let /** @type {?} */ item of testArray) {
            if (item._uuid === uuid) {
                return item;
            }
        }
        return null;
    }
    /**
     * @param {?} classname
     * @return {?}
     */
    findTestDataSchema(classname) {
        let /** @type {?} */ key = classname + "-schema";
        let /** @type {?} */ testData = this.getTestData();
        let /** @type {?} */ schemaResult = (testData !== null && testData !== undefined) ? testData[key] : {};
        return schemaResult;
    }
    /**
     * Configure the persisent class metadata.
     *
     * @param {?} body The metadata object to configure.
     * @param {?} classname The persistent class name.
     * @param {?=} langPreference The language preference used to perform the operation (especially in READ operations such as find/query).
     * @param {?=} extraHttpRequestParams
     * @return {?}
     */
    configure(body, classname, langPreference, extraHttpRequestParams) {
        return new Promise((resolve, reject) => {
            let /** @type {?} */ prom = this.configureWithHttpInfo(body, classname, langPreference, extraHttpRequestParams);
            prom.then((response) => {
                resolve(response.json());
            }, (error) => {
                reject(error);
            });
        });
    }
    /**
     * Create a new persistent object (insert new row).
     *
     * @param {?} body The object to be created.
     * @param {?} classname The persistent class name.
     * @param {?=} langPreference The language preference used to perform the operation (especially in READ operations such as find/query).
     * @param {?=} extraHttpRequestParams
     * @return {?}
     */
    create(body, classname, langPreference, extraHttpRequestParams) {
        if (this.isTestMode()) {
            if (body !== null && body !== undefined) {
                body._uuid = this.uuid4Generate();
                let /** @type {?} */ testData = this.getTestData();
                let /** @type {?} */ testResult = (testData !== null && testData !== undefined) ? testData[classname] : [];
                if (testResult.length == 0) {
                    testData[classname] = testResult;
                }
                testResult.push(body);
            }
            return Promise.resolve(body);
        }
        return new Promise((resolve, reject) => {
            let /** @type {?} */ prom = this.createWithHttpInfo(body, classname, langPreference, extraHttpRequestParams);
            prom.then((respons