jamespot-user-api 1.0.13 → 1.0.43

package/src/apis/application.ts

@@ -0,0 +1,132 @@
+import { JApplication, JApplicationStatus } from '../classes';
+import { ApiWrapper, BaseMessages } from '../types';
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+
+export interface TmpApplication {
+    idApp: string;
+    type: string;
+}
+
+export class JApplicationApi extends JBaseApi {
+    /**
+     * List applications
+     * @returns  {@link JApplication} objects, in light format
+     */
+    public list(): Promise<JApplication[]> {
+        return this.network.post<Array<TmpApplication>, BaseMessages>({ o: 'studio', f: 'list' }).then((res) => {
+            if (Array.isArray(res.result)) {
+                return res.result.map((entry) => {
+                    const nApp = new JApplication(entry.idApp);
+                    nApp.hydrate(entry);
+                    return nApp;
+                });
+            }
+            throw 'Bad response from backend';
+        });
+    }
+
+    private stdCall<T extends OF = OF>(parameters: T): Promise<JApplication> {
+        return this.network.post<TmpApplication, BaseMessages>(parameters).then((res) => {
+            const jApplication = new JApplication(res.result.idApp);
+            jApplication.hydrate(res.result);
+            return jApplication;
+        });
+    }
+
+    private stdCSRFCall<T extends OF = OF>(parameters: T): Promise<JApplication> {
+        return this.network.postCSRF<TmpApplication, BaseMessages>(parameters).then((res) => {
+            const jApplication = new JApplication(res.result.idApp);
+            jApplication.hydrate(res.result);
+            return jApplication;
+        });
+    }
+
+    /**
+     * Get one application
+     * @returns  {@link JApplication} object in full format
+     */
+    public get(idApp: string, status?: JApplicationStatus): Promise<JApplication> {
+        return this.stdCall({ o: 'studio', f: 'get', idApp, status });
+    }
+
+    /**
+     * Install this application.
+     * If everything is ok, remove previous saved and autosaved versions of this application.
+     * @param xmlBody: string XML file
+     * @returns  {@link JApplication} object in full format
+     */
+    public install(xmlBody: string): Promise<JApplication> {
+        return this.stdCSRFCall({ o: 'studio', f: 'install', value: xmlBody });
+    }
+
+    /**
+     * Suspend an installed application.
+     * @param idApp: application's id
+     * @returns  {@link JApplication} object in full format
+     */
+    public suspend(idApp: string): Promise<JApplication> {
+        return this.stdCSRFCall({ o: 'studio', f: 'suspend', idApp });
+    }
+
+    /**
+     * Restart an suspended application.
+     * @param idApp: application's id
+     * @returns  {@link JApplication} object in full format
+     */
+    public restart(idApp: string): Promise<JApplication> {
+        return this.stdCSRFCall({ o: 'studio', f: 'restart', idApp });
+    }
+
+    /**
+     * Save a 'local', 'saved' or 'autosaved' version of the application
+     * Returns a 'save' or 'autosaved' application.
+     * @param idApp: application's id
+     * @param value: data to be saved
+     * @param status:  must be either 'saved' or 'autosaved'.
+     * @returns  {@link JApplication} object in full format
+     */
+    public save(idApp: string, value: string, status: JApplicationStatus): Promise<JApplication> {
+        if (status === JApplicationStatus.saved || status === JApplicationStatus.autosaved) {
+            return this.stdCSRFCall({
+                o: 'studio',
+                f: 'save',
+                idApp,
+                value,
+                status,
+            });
+        } else {
+            throw 'Invalid status value';
+        }
+    }
+
+    /**
+     * Delete a selected status of the application
+     * @param idApp application id to delete
+     * @param status application status to select
+     * @returns message after delete execution
+     */
+    public async delete(idApp: string, status: JApplicationStatus): Promise<Array<string>> {
+        return this.network
+            .postCSRF<string>({
+                o: 'studio',
+                f: 'delete',
+                idApp,
+                status,
+            } as OF)
+            .then((res) => {
+                if (res.error === 0) {
+                    return res.messages;
+                } else {
+                    throw res.messages;
+                }
+            });
+    }
+
+    /**
+     * Get cssClass possible values.
+     */
+    public cssClassList(): Promise<ApiWrapper<Array<string>>> {
+        return this.network.post<Array<string>>({ o: 'studio', f: 'icons' });
+    }
+}

package/src/apis/article.ts

@@ -0,0 +1,74 @@
+import { JBaseApi } from './base';
+import { ApiWrapper, BaseMessages, Filters, Little, Orders, PagingResults } from '../types';
+import { OF } from '../util/network';
+
+export type ArticleListConfig = {
+    type: string;
+    format: string;
+    query?: string;
+    limit?: number;
+    page?: number;
+    orders?: Orders;
+    filters?: Filters;
+};
+
+export type ArticleGetConfig = {
+    uri?: string;
+    idArticle?: number;
+    format?: string;
+};
+
+export type ArticleCreation = {
+    title: string;
+    description: string;
+};
+
+export type BaseArticle = {
+    id: number;
+    type: string;
+    dateCreation: string;
+    dateModified: string;
+    title: string;
+};
+
+export class JArticleApi extends JBaseApi {
+    public list(config: ArticleListConfig): Promise<ApiWrapper<PagingResults<{ title: string }>>> {
+        return this.network.post({
+            o: 'ObjectListJamespot',
+            f: 'ArticleQueryList',
+            ...config,
+        } as OF);
+    }
+
+    public get<T extends Little = Little>(config: ArticleGetConfig): Promise<ApiWrapper<T>> {
+        return this.network.post({
+            o: 'article',
+            f: 'get',
+            ...config,
+        } as OF);
+    }
+
+    public create<T>(article: ArticleCreation): Promise<ApiWrapper<BaseArticle & T>> {
+        return this.network.post({
+            o: 'article',
+            f: 'create',
+            ...article,
+        } as OF);
+    }
+
+    public update<T extends { uri: string }>(article: T): Promise<ApiWrapper<never, BaseMessages>> {
+        return this.network.post({
+            o: 'article',
+            f: 'update',
+            ...article,
+        } as OF);
+    }
+
+    public count(type: string): Promise<ApiWrapper<number>> {
+        return this.network.post({
+            o: 'article',
+            f: 'count',
+            type,
+        } as OF);
+    }
+}

package/src/apis/asei.ts

@@ -0,0 +1,73 @@
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+import { AseiGroups, AseiRights, AseiTicket, AseiTicketStatus, Filters, Orders } from '../types';
+import { JArticleApi } from './article';
+import { ApiWrapper, PagingResults } from '../types';
+
+export class JAseiApi extends JBaseApi {
+    /**
+     * List Asei Clearance Tickets
+     * @param page page number
+     * @param limit number of elements per page
+     * @param filters filter object
+     * @param orders order object
+     */
+    public list(
+        page: number,
+        limit: number,
+        filters?: Filters,
+        orders: Orders = [{ name: 'dateCreation', sort: 'DESC' }],
+    ): Promise<ApiWrapper<PagingResults<AseiTicket>>> {
+        const articleApi = new JArticleApi(this.network);
+        return articleApi.list({
+            type: 'aseiClearanceTicket',
+            format: 'raw-view',
+            limit,
+            page,
+            orders,
+            filters,
+        }) as Promise<ApiWrapper<PagingResults<AseiTicket>>>;
+    }
+
+    /**
+     * change status of an Asei Ticket
+     */
+    public requestStatus(
+        uri: string,
+        requestedStatus: AseiTicketStatus,
+        audience?: Array<string>,
+    ): Promise<AseiTicket> {
+        return this.network
+            .post<AseiTicket>({ o: 'asei', f: 'setStatus', uri, requestedStatus, audience } as OF)
+            .then((res) => {
+                if (res && res.result) {
+                    return res.result;
+                }
+                throw 'Bad response from backend';
+            });
+    }
+
+    /**
+     * Get asei dedicated groups (dsi, administrators)
+     */
+    public getDedicatedGroups(): Promise<AseiGroups> {
+        return this.network.post<AseiGroups>({ o: 'asei', f: 'getDedicatedGroups' } as OF).then((res) => {
+            if (res && res.result) {
+                return res.result;
+            }
+            throw 'Bad response from backend';
+        });
+    }
+
+    /**
+     * Get asei configuration (rights to access, rights to publish)
+     */
+    public getConfiguration(): Promise<AseiRights> {
+        return this.network.post<{ right: AseiRights }>({ o: 'asei', f: 'configuration' }).then((res) => {
+            if (res && res.result) {
+                return res.result.right;
+            }
+            throw 'Bad response from backend';
+        });
+    }
+}

package/src/apis/audience.ts

@@ -0,0 +1,18 @@
+import { AudienceAutocomplete } from '../types/autocomplete';
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+
+export class JAudienceApi extends JBaseApi {
+    /**
+     * autocomplete
+     * return the list of user and Spot
+     */
+    public autocomplete(query: string): Promise<AudienceAutocomplete[]> {
+        return this.network.post({ o: 'autocomplete', f: 'audience', q: query } as OF).then((res) => {
+            if (Array.isArray(res.result)) {
+                return res.result;
+            }
+            throw 'Bad response from backend';
+        });
+    }
+}

package/src/apis/base.ts

@@ -0,0 +1,9 @@
+import { Network } from '../util/network';
+
+export class JBaseApi {
+    public network: Network;
+
+    public constructor(network: Network) {
+        this.network = network;
+    }
+}

package/src/apis/bookmark.ts

@@ -0,0 +1,110 @@
+import { ApiWrapper, BaseMessagesOne } from '../types';
+import { JBaseApi } from './base';
+import { JBookmark } from '../classes/JBookmark';
+import { ListWrapper } from '../types/listWrapper';
+import { OF } from '../util/network';
+
+export interface ListFilterSpec {
+    query?: string;
+    page?: number;
+    limit?: number;
+    orders?: {
+        name: string;
+        sort: string;
+    }[];
+}
+
+type Bookmark = Record<string, object>;
+
+type BookmarkList = {
+    page: number;
+    cnt: number;
+    limit: number;
+    data: Bookmark[];
+};
+
+export class JBookmarkApi extends JBaseApi {
+    public getList(filterSpecs: ListFilterSpec): Promise<ListWrapper<JBookmark>> {
+        return this.network
+            .post<BookmarkList>({
+                o: 'object',
+                f: 'list',
+                namespace: 'bookmarks',
+                view: 'list',
+                ...filterSpecs,
+            } as OF)
+            .then((res) => {
+                const result = res.result;
+
+                if (Array.isArray(result.data)) {
+                    const data: JBookmark[] = result.data.map((entry) => JBookmark.createFromObject(entry));
+                    return { page: result.page, cnt: result.cnt, limit: result.limit, data };
+                }
+
+                throw {
+                    error: res.error,
+                    messages: res.messages,
+                };
+            });
+    }
+
+    public addLink(targetId: number, targetType: string): Promise<JBookmark> {
+        return this.network
+            .post<Bookmark>({
+                o: 'custom',
+                f: 'actionAdd',
+                type: 'bookmarkLink',
+                targetId,
+                targetType,
+                format: 'list',
+            } as OF)
+            .then((res) => {
+                const result = res.result;
+                return JBookmark.createFromObject(result);
+            });
+    }
+
+    public addBookmark(bookmark: JBookmark): Promise<JBookmark> {
+        return this.network
+            .postCSRF<Bookmark, BaseMessagesOne>({
+                o: 'bookmarks',
+                f: 'add',
+                ...bookmark,
+            } as OF)
+            .then((res) => {
+                const result = res.result;
+                return JBookmark.createFromObject(result);
+            });
+    }
+
+    public delete(bookmark: JBookmark): Promise<ApiWrapper<null, BaseMessagesOne>> {
+        return this.network.postCSRF<null, BaseMessagesOne>({
+            o: 'bookmarks',
+            f: 'delete',
+            bookmarkID: bookmark.id,
+        } as OF);
+    }
+
+    public rename(bookmark: JBookmark): Promise<ApiWrapper<null, BaseMessagesOne>> {
+        return this.network.postCSRF<null, BaseMessagesOne>({
+            o: 'bookmarks',
+            f: 'rename',
+            bookmarkID: bookmark.id,
+            bookmarkLabel: bookmark.bookmarkLabel,
+        } as OF);
+    }
+
+    public move(
+        bookmark: JBookmark,
+        bookmarkReference: JBookmark,
+        position: 'before' | 'after',
+    ): Promise<ApiWrapper<null, BaseMessagesOne>> {
+        return this.network.postCSRF<null, BaseMessagesOne>({
+            o: 'bookmarks',
+            f: 'move',
+            bookmarkID: bookmark.id,
+            bookmarkReference: bookmarkReference.id,
+            bookmarkPosition: position,
+        } as OF);
+    }
+}

package/src/apis/community.ts

@@ -0,0 +1,20 @@
+import { ApiWrapper, CommunityAutocomplete } from '../types';
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+
+export class JCommunityApi extends JBaseApi {
+    public sendRequest(message: string, idUserTo: number): Promise<ApiWrapper<boolean, { code: number; msg: string }>> {
+        return this.network.post<boolean, { code: number; msg: string }>({
+            o: 'community',
+            f: 'sendRequest',
+            message,
+            idUserTo,
+        } as OF);
+    }
+
+    public autocomplete(q: string): Promise<CommunityAutocomplete[]> {
+        return this.network
+            .post<CommunityAutocomplete[]>({ o: 'autocomplete', f: 'community', q } as OF)
+            .then((res) => res.result);
+    }
+}

package/src/apis/concept.ts

@@ -0,0 +1,31 @@
+import { JBaseApi } from './base';
+import { JConcept } from '../classes';
+import { OF } from '../util/network';
+
+export class JConceptApi extends JBaseApi {
+    /**
+     * autocomplete return a list of tags
+     * @param idTaxonomy taxonomy id
+     * @param query search characters
+     */
+    public autocomplete(idTaxonomy: string, query: string): Promise<JConcept[]> {
+        return this.network
+            .post<Array<{ id: string; type: string }>>({
+                o: 'autocomplete',
+                f: 'taxonomy',
+                q: query,
+                idTaxonomy,
+                idToUri: false,
+            } as OF)
+            .then((res) => {
+                if (Array.isArray(res.result)) {
+                    return res.result.map((concept) => {
+                        const jConcept = new JConcept(concept.id, concept.type);
+                        jConcept.hydrate(concept);
+                        return jConcept;
+                    });
+                }
+                throw 'Bad response from backend';
+            });
+    }
+}

package/src/apis/diapazone.ts

@@ -0,0 +1,65 @@
+import { JBaseApi } from './base';
+import { ListWrapper } from '../types/listWrapper';
+import { ApiWrapper } from '../types';
+import { OF } from '../util/network';
+
+import { JDiapazone } from '../classes/JDiapazone';
+
+type Diapazone = Record<string, object>;
+
+type DiapazoneList = {
+    page: number;
+    cnt: number;
+    limit: number;
+    data: Diapazone[];
+};
+
+export class JDiapazoneApi extends JBaseApi {
+    public create(
+        type: string,
+        token: string,
+        title: string,
+        dateStart: string,
+        publishTo: Array<any>,
+    ): Promise<ApiWrapper<string>> {
+        return this.network.post({
+            o: 'article',
+            f: 'create',
+            type,
+            token,
+            title,
+            dateStart,
+            publishTo,
+        } as OF);
+    }
+    public getList(
+        query = '',
+        filters: Array<any> = [],
+        orders: Array<any> = [],
+        page = 1,
+        format = 'list',
+    ): Promise<ListWrapper<JDiapazone>> {
+        return this.network
+            .post<DiapazoneList>({
+                o: 'objectList',
+                f: 'diapazoneQueryList',
+                query,
+                filters,
+                orders,
+                page,
+                format,
+            } as OF)
+            .then((res) => {
+                const result = res.result;
+                if (Array.isArray(result.data)) {
+                    const data: JDiapazone[] = result.data.map((entry) => JDiapazone.createFromObject(entry));
+                    return { page: result.page, cnt: result.cnt, limit: result.limit, data };
+                }
+
+                throw {
+                    error: res.error,
+                    messages: res.messages,
+                };
+            });
+    }
+}

package/src/apis/file.ts

@@ -0,0 +1,14 @@
+import { FileOption } from '../util/network';
+import { JBaseApi } from './base';
+
+export class JFileApi extends JBaseApi {
+    // FIXME when doing the first file upload
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public create(token: string, attrName: 'attachment' | 'image', file: File, options: FileOption): Promise<any> {
+        const body = new FormData();
+        body.append('token', token);
+        body.append('attrName', attrName);
+        body.append(attrName, file);
+        return this.network.postFile(body, options);
+    }
+}

package/src/apis/filebank.ts

@@ -0,0 +1,50 @@
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+import { ListWrapper } from '../types/listWrapper';
+import { Little, Rights } from '../types';
+
+export interface RootFolderProps {
+    id: number;
+    title: string;
+    uri: string;
+    type: string;
+    mainType: string;
+    folderColor?: string;
+}
+
+export interface SpotProps {
+    id: number;
+    title: string;
+    uri: string;
+    type: string;
+    mainType: string;
+    folderColor?: string;
+}
+
+export interface FileBankProps {
+    recents: any[];
+    rootFolder: RootFolderProps;
+    spot: SpotProps;
+}
+
+export interface FolderProps extends Little {
+    mainType: string;
+    folderColor?: string;
+    parentURI?: string;
+    _right: Rights;
+}
+
+export class JFilebankApi extends JBaseApi {
+    public getBanks(format = 'list'): Promise<Array<FileBankProps>> {
+        return this.network.post<Array<FileBankProps>>({ o: 'fileBank', f: 'getBanks', format } as OF).then((res) => {
+            return res.result;
+        });
+    }
+    public getFolders(parentURI: string): Promise<ListWrapper<FolderProps>> {
+        return this.network
+            .post<Array<FolderProps>>({ o: 'fileBank', f: 'getFolders', parentURI } as OF)
+            .then((res) => {
+                return { data: res.result };
+            });
+    }
+}

package/src/apis/group.ts

@@ -0,0 +1,48 @@
+import { ApiWrapper, Category, CreateGroup, GroupWidgets, Little, PagingResults } from '../types';
+import { JBaseApi } from './base';
+import { OF } from '../util/network';
+
+export class JGroupApi extends JBaseApi {
+    public create({ type, widgets, ...group }: CreateGroup): Promise<ApiWrapper<string>> {
+        return this.network.post({
+            o: 'spot',
+            f: 'create',
+            ...group,
+            type: type || 'spot',
+            widgets: JSON.stringify(widgets),
+        } as OF);
+    }
+
+    public getApplications(): Promise<ApiWrapper<GroupWidgets>> {
+        return this.network.post({ o: 'spot', f: 'get-available-widget' });
+    }
+
+    public getCategories(): Promise<ApiWrapper<Category[]>> {
+        return this.network.post<Category[]>({ o: 'spot', f: 'get-categories' });
+    }
+
+    /**
+     * Get the members of a group
+     * @param idSpot spot id
+     * @param query query string to search within user names
+     * @param limit limit per page
+     * @param page page number
+     * @return array of User
+     */
+    public getObjectListJamespotSpotMembers(
+        idSpot: number | string,
+        query?: string,
+        limit?: number,
+        page = 1,
+    ): Promise<ApiWrapper<PagingResults<Little>>> {
+        return this.network.post<PagingResults<Little>>({
+            o: 'objectListJamespot',
+            f: 'SpotMembers',
+            idSpot,
+            limit,
+            page,
+            format: 'raw-little',
+            query,
+        } as OF);
+    }
+}

package/src/apis/index.ts

@@ -0,0 +1,17 @@
+export * from './application';
+export * from './article';
+export * from './audience';
+export * from './base';
+export * from './community';
+export * from './concept';
+export * from './file';
+export * from './filebank';
+export * from './group';
+export * from './jamespotUserApi';
+export * from './jland';
+export * from './messenger';
+export * from './search';
+export * from './bookmark';
+export * from './user';
+export * from './diapazone';
+export * from './wedoc';