@alfresco/js-api 7.3.0-1529 → 7.3.0

package/esm2020/authentication/oauth2Config.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2F1dGgyQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL2pzLWFwaS9zcmMvYXV0aGVudGljYXRpb24vb2F1dGgyQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjMgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBPYXV0aDJDb25maWcge1xuICAgIGNsaWVudElkOiBzdHJpbmc7XG4gICAgc2VjcmV0Pzogc3RyaW5nO1xuICAgIGhvc3Q6IHN0cmluZztcbiAgICBhdXRob3JpemF0aW9uVXJsPzogc3RyaW5nO1xuICAgIHRva2VuVXJsPzogc3RyaW5nO1xuICAgIHVzZXJpbmZvRW5kcG9pbnQ/OiBzdHJpbmc7XG4gICAgbG9nb3V0VXJsPzogc3RyaW5nO1xuICAgIHNjb3BlOiBzdHJpbmc7XG4gICAgaW1wbGljaXRGbG93PzogYm9vbGVhbjtcbiAgICByZWRpcmVjdFVyaTogc3RyaW5nO1xuICAgIHJlZnJlc2hUb2tlblRpbWVvdXQ/OiBudW1iZXI7XG4gICAgc2lsZW50TG9naW4/OiBib29sZWFuO1xuICAgIHJlZGlyZWN0VXJpTG9nb3V0Pzogc3RyaW5nO1xuICAgIHJlZGlyZWN0U2lsZW50SWZyYW1lVXJpPzogc3RyaW5nO1xuICAgIHB1YmxpY1VybHM/OiBzdHJpbmdbXTtcbn1cbiJdfQ==

package/esm2020/authentication/processAuth.mjs

@@ -0,0 +1,178 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import ee from 'event-emitter';
+import { AlfrescoApiClient } from '../alfrescoApiClient';
+import { Storage } from '../storage';
+import { isBrowser } from '../utils';
+export class ProcessAuth extends AlfrescoApiClient {
+    constructor(config, httpClient) {
+        super(undefined, httpClient);
+        this.authentications = {
+            basicAuth: { ticket: '' },
+            type: 'activiti'
+        };
+        this.storage = Storage.getInstance();
+        this.storage.setDomainPrefix(config.domainPrefix);
+        this.className = 'ProcessAuth';
+        if (!isBrowser()) {
+            this.defaultHeaders = {
+                'user-agent': 'alfresco-js-api'
+            };
+        }
+        this.setConfig(config);
+    }
+    setConfig(config) {
+        this.config = config;
+        this.ticket = undefined;
+        this.basePath = config.hostBpm + '/' + this.config.contextRootBpm; //Activiti Call
+        if (this.config.ticketBpm) {
+            this.setTicket(config.ticketBpm);
+        }
+        else if (this.storage.getItem('ticket-BPM')) {
+            this.setTicket(this.storage.getItem('ticket-BPM'));
+        }
+    }
+    changeHost() {
+        this.basePath = this.config.hostBpm + '/' + this.config.contextRootBpm; //Activiti Call
+        this.ticket = undefined;
+    }
+    changeCsrfConfig(disableCsrf) {
+        this.config.disableCsrf = disableCsrf;
+    }
+    saveUsername(username) {
+        if (this.storage.supportsStorage()) {
+            this.storage.setItem('APS_USERNAME', username);
+        }
+    }
+    /**
+     * login Activiti API
+     *
+     * @param username Username to login
+     * @param password Password to login
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    login(username, password) {
+        this.authentications.basicAuth.username = username;
+        this.authentications.basicAuth.password = password;
+        const headerParams = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Cache-Control': 'no-cache'
+        };
+        const formParams = {
+            j_username: this.authentications.basicAuth.username,
+            j_password: this.authentications.basicAuth.password,
+            _spring_security_remember_me: true,
+            submit: 'Login'
+        };
+        const contentTypes = ['application/x-www-form-urlencoded'];
+        const accepts = ['application/json'];
+        const promise = new Promise((resolve, reject) => {
+            this.callApi('/app/authentication', 'POST', {}, {}, headerParams, formParams, {}, contentTypes, accepts).then(() => {
+                this.saveUsername(username);
+                const ticket = this.basicAuth(this.authentications.basicAuth.username, this.authentications.basicAuth.password);
+                this.setTicket(ticket);
+                promise.emit('success');
+                this.emit('logged-in');
+                resolve(ticket);
+            }, (error) => {
+                this.saveUsername('');
+                if (error.status === 401) {
+                    promise.emit('unauthorized');
+                }
+                else if (error.status === 403) {
+                    promise.emit('forbidden');
+                }
+                else {
+                    promise.emit('error');
+                }
+                reject(error);
+            });
+        });
+        ee(promise); // jshint ignore:line
+        return promise;
+    }
+    /**
+     * logout Alfresco API
+     *
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    logout() {
+        this.saveUsername('');
+        const contentTypes = ['application/json'];
+        const accepts = ['application/json'];
+        const promise = new Promise((resolve, reject) => {
+            this.callApi('/app/logout', 'GET', {}, {}, {}, {}, {}, contentTypes, accepts).then(() => {
+                this.invalidateSession();
+                promise.emit('logout');
+                resolve();
+            }, (error) => {
+                if (error.status === 401) {
+                    promise.emit('unauthorized');
+                }
+                promise.emit('error');
+                reject(error);
+            });
+        });
+        ee(promise);
+        return promise;
+    }
+    /**
+     * Set the current Ticket
+     *
+     * @param ticket Ticket value
+     */
+    setTicket(ticket) {
+        this.authentications.basicAuth.ticket = ticket;
+        this.authentications.basicAuth.password = null;
+        this.config.ticketBpm = ticket;
+        this.storage.setItem('ticket-BPM', ticket);
+        this.ticket = ticket;
+    }
+    invalidateSession() {
+        this.storage.removeItem('ticket-BPM');
+        this.authentications.basicAuth.ticket = null;
+        this.authentications.basicAuth.password = null;
+        this.authentications.basicAuth.username = null;
+        this.config.ticketBpm = null;
+        this.ticket = null;
+    }
+    /**
+     * Get the current Ticket
+     *
+     * @returns ticket
+     */
+    getTicket() {
+        return this.ticket;
+    }
+    /**
+     * If the client is logged in return true
+     *
+     * @returns `true` if logged in, otherwise `false`
+     */
+    isLoggedIn() {
+        return !!this.ticket;
+    }
+    /**
+     * return the Authentication
+     *
+     * @returns authentication object
+     */
+    getAuthentication() {
+        return this.authentications;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processAuth.js","sourceRoot":"","sources":["../../../../../lib/js-api/src/authentication/processAuth.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport ee from 'event-emitter';\nimport { AlfrescoApiClient, AlfrescoApiClientPromise } from '../alfrescoApiClient';\nimport { AlfrescoApiConfig } from '../alfrescoApiConfig';\nimport { Authentication } from './authentication';\nimport { Storage } from '../storage';\nimport { HttpClient } from '../api-clients/http-client.interface';\nimport { isBrowser } from '../utils';\n\nexport class ProcessAuth extends AlfrescoApiClient {\n    ticket: string;\n\n    authentications: Authentication = {\n        basicAuth: { ticket: '' },\n        type: 'activiti'\n    };\n\n    constructor(config: AlfrescoApiConfig, httpClient?: HttpClient) {\n        super(undefined, httpClient);\n        this.storage = Storage.getInstance();\n        this.storage.setDomainPrefix(config.domainPrefix);\n\n        this.className = 'ProcessAuth';\n\n        if (!isBrowser()) {\n            this.defaultHeaders = {\n                'user-agent': 'alfresco-js-api'\n            };\n        }\n\n        this.setConfig(config);\n    }\n\n    setConfig(config: AlfrescoApiConfig) {\n        this.config = config;\n        this.ticket = undefined;\n\n        this.basePath = config.hostBpm + '/' + this.config.contextRootBpm; //Activiti Call\n\n        if (this.config.ticketBpm) {\n            this.setTicket(config.ticketBpm);\n        } else if (this.storage.getItem('ticket-BPM')) {\n            this.setTicket(this.storage.getItem('ticket-BPM'));\n        }\n    }\n\n    changeHost() {\n        this.basePath = this.config.hostBpm + '/' + this.config.contextRootBpm; //Activiti Call\n        this.ticket = undefined;\n    }\n\n    changeCsrfConfig(disableCsrf: boolean) {\n        this.config.disableCsrf = disableCsrf;\n    }\n\n    saveUsername(username: string) {\n        if (this.storage.supportsStorage()) {\n            this.storage.setItem('APS_USERNAME', username);\n        }\n    }\n\n    /**\n     * login Activiti API\n     *\n     * @param username Username to login\n     * @param password Password to login\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    login(username: string, password: string): AlfrescoApiClientPromise<string> {\n        this.authentications.basicAuth.username = username;\n        this.authentications.basicAuth.password = password;\n\n        const headerParams = {\n            'Content-Type': 'application/x-www-form-urlencoded',\n            'Cache-Control': 'no-cache'\n        };\n        const formParams = {\n            j_username: this.authentications.basicAuth.username,\n            j_password: this.authentications.basicAuth.password,\n            _spring_security_remember_me: true,\n            submit: 'Login'\n        };\n\n        const contentTypes = ['application/x-www-form-urlencoded'];\n        const accepts = ['application/json'];\n\n        const promise: any = new Promise<string>((resolve, reject) => {\n            this.callApi('/app/authentication', 'POST', {}, {}, headerParams, formParams, {}, contentTypes, accepts).then(\n                () => {\n                    this.saveUsername(username);\n                    const ticket = this.basicAuth(this.authentications.basicAuth.username, this.authentications.basicAuth.password);\n                    this.setTicket(ticket);\n                    promise.emit('success');\n                    this.emit('logged-in');\n                    resolve(ticket);\n                },\n                (error) => {\n                    this.saveUsername('');\n                    if (error.status === 401) {\n                        promise.emit('unauthorized');\n                    } else if (error.status === 403) {\n                        promise.emit('forbidden');\n                    } else {\n                        promise.emit('error');\n                    }\n                    reject(error);\n                }\n            );\n        });\n\n        ee(promise); // jshint ignore:line\n        return promise;\n    }\n\n    /**\n     * logout Alfresco API\n     *\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    logout(): AlfrescoApiClientPromise<void> {\n        this.saveUsername('');\n\n        const contentTypes = ['application/json'];\n        const accepts = ['application/json'];\n\n        const promise: any = new Promise<void>((resolve, reject) => {\n            this.callApi('/app/logout', 'GET', {}, {}, {}, {}, {}, contentTypes, accepts).then(\n                () => {\n                    this.invalidateSession();\n                    promise.emit('logout');\n                    resolve();\n                },\n                (error) => {\n                    if (error.status === 401) {\n                        promise.emit('unauthorized');\n                    }\n                    promise.emit('error');\n                    reject(error);\n                }\n            );\n        });\n\n        ee(promise);\n        return promise;\n    }\n\n    /**\n     * Set the current Ticket\n     *\n     * @param ticket Ticket value\n     */\n    setTicket(ticket: string) {\n        this.authentications.basicAuth.ticket = ticket;\n        this.authentications.basicAuth.password = null;\n        this.config.ticketBpm = ticket;\n        this.storage.setItem('ticket-BPM', ticket);\n        this.ticket = ticket;\n    }\n\n    invalidateSession() {\n        this.storage.removeItem('ticket-BPM');\n        this.authentications.basicAuth.ticket = null;\n        this.authentications.basicAuth.password = null;\n        this.authentications.basicAuth.username = null;\n        this.config.ticketBpm = null;\n        this.ticket = null;\n    }\n\n    /**\n     * Get the current Ticket\n     *\n     * @returns ticket\n     */\n    getTicket(): string {\n        return this.ticket;\n    }\n\n    /**\n     * If the client is logged in return true\n     *\n     * @returns `true` if logged in, otherwise `false`\n     */\n    isLoggedIn(): boolean {\n        return !!this.ticket;\n    }\n\n    /**\n     * return the Authentication\n     *\n     * @returns authentication object\n     */\n    getAuthentication(): Authentication {\n        return this.authentications;\n    }\n}\n"]}

package/esm2020/contentClient.mjs

@@ -0,0 +1,42 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AlfrescoApiClient } from './alfrescoApiClient';
+export class ContentClient extends AlfrescoApiClient {
+    constructor(config, servicePath, httpClient) {
+        super(undefined, httpClient);
+        this.className = 'ContentClient';
+        this.setConfig(config, servicePath);
+    }
+    setConfig(config, servicePath) {
+        this.config = config;
+        this.servicePath = servicePath;
+        this.changeHost();
+    }
+    changeHost() {
+        this.host = this.config.hostEcm;
+        this.basePath = `${this.config.hostEcm}/${this.config.contextRoot}${this.servicePath}`;
+    }
+    /**
+     * set the Authentications
+     *
+     * @param authentications authentications
+     */
+    setAuthentications(authentications) {
+        this.authentications = authentications;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/index.mjs

@@ -0,0 +1,40 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './api/content-rest-api';
+export * from './api/content-custom-api';
+export * from './api/discovery-rest-api';
+export * from './api/gs-classification-rest-api';
+export * from './api/gs-core-rest-api';
+export * from './api/auth-rest-api';
+export * from './api/activiti-rest-api';
+export * from './api/search-rest-api';
+export * from './api/model-rest-api';
+export * from './api/content-custom-api/api/content.api';
+export * from './authentication/contentAuth';
+export * from './authentication/processAuth';
+export * from './authentication/oauth2Auth';
+export * from './contentClient';
+export * from './processClient';
+export * from './storage';
+export * from './alfrescoApi';
+export * from './alfrescoApiClient';
+export * from './alfrescoApiConfig';
+export * from './to-deprecate/alfresco-api-type';
+export * from './api-clients/api-client';
+export * from './api-clients/http-client.interface';
+export * from './utils';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/processClient.mjs

@@ -0,0 +1,41 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AlfrescoApiClient } from './alfrescoApiClient';
+export class ProcessClient extends AlfrescoApiClient {
+    constructor(config, httpClient) {
+        super(undefined, httpClient);
+        this.className = 'ProcessClient';
+        this.setConfig(config);
+    }
+    setConfig(config) {
+        this.config = config;
+        this.changeHost();
+    }
+    changeHost() {
+        this.host = this.config.hostBpm;
+        this.basePath = `${this.config.hostBpm}/${this.config.contextRootBpm}`;
+    }
+    /**
+     * set the authentications
+     *
+     * @param authentications Authentications value
+     */
+    setAuthentications(authentications) {
+        this.authentications = authentications;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/storage.mjs

@@ -0,0 +1,59 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class Storage {
+    constructor() {
+        if (this.supportsStorage()) {
+            this._storage = window.localStorage;
+        }
+    }
+    static getInstance() {
+        if (!Storage.instance) {
+            Storage.instance = new Storage();
+        }
+        return Storage.instance;
+    }
+    supportsStorage() {
+        try {
+            return 'localStorage' in window && window.localStorage !== null;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    setDomainPrefix(prefix) {
+        this.prefix = prefix ? prefix + '_' : '';
+    }
+    setStorage(storage) {
+        this._storage = storage;
+    }
+    setItem(key, value) {
+        if (this.supportsStorage()) {
+            this._storage.setItem(this.prefix + key, value);
+        }
+    }
+    removeItem(key) {
+        if (this.supportsStorage()) {
+            this._storage.removeItem(this.prefix + key);
+        }
+    }
+    getItem(key) {
+        if (this.supportsStorage()) {
+            return this._storage.getItem(this.prefix + key);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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