@edifice.io/client 2.0.0-develop-rc.26

package/dist/resources/interface.d.ts

@@ -0,0 +1,390 @@
+import { App, ID, ILinkedResource, ResourceType, RightRole, RightStringified } from '..';
+/**
+ * @deprecated Used by the internal linker ONLY
+ * Old-fashioned way of listing resources => `behaviours.loadResources()`
+ */
+export interface IBehaviourService {
+    /** App providing this service. */
+    getApplication(): App | string;
+    /** Type of resource this service can manage. */
+    getResourceType(): ResourceType;
+    /** Load resources. */
+    loadResources(parameters: GetContextParameters): Promise<ILinkedResource[]>;
+}
+/**
+ * Resources management service.
+ * Resources are assets created or imported in the whole solution (core and non-core apps)
+ */
+export interface IResourceService {
+    /** App providing this service. */
+    getApplication(): App | string;
+    /** Type of resource this service can manage. */
+    getResourceType(): ResourceType;
+    /** Create a new resource from common parameters. */
+    create<T extends CreateParameters>(parameters: T): Promise<CreateResult>;
+    /** Update an existing resource from common parameters. */
+    update<T extends UpdateParameters>(parameters: T): Promise<UpdateResult>;
+    /** Copy a resource from common parameters. */
+    copy<T extends CopyParameters>(parameters: T): Promise<CopyResult>;
+    /** Publish an resource */
+    publish(parameters: PublishParameters): Promise<PublishResult>;
+    /** Delete folders and/or resources. */
+    deleteAll(parameters: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    /** Trash folders and/or resources. */
+    trashAll(parameters: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    /** Restore folders and/or resources from trash. */
+    restoreAll(parameters: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    /** Create a search context and get the first results page. */
+    createContext(parameters: GetContextParameters): Promise<GetContextResult>;
+    /** Search / paginate within a search context. */
+    searchContext(parameters: GetContextParameters): Promise<ISearchResults>;
+    /** Search 1 resource by `id` */
+    searchResource(parameters: GetResourceParameters): Promise<IResource>;
+    /** Create a new folder. */
+    createFolder(parameters: CreateFolderParameters): Promise<CreateFolderResult>;
+    /** Update folder. */
+    updateFolder(parameters: UpdateFolderParameters): Promise<CreateFolderResult>;
+    /** Move resources/folders to a folder. */
+    moveToFolder(parameters: MoveParameters, useAssetId?: boolean): Promise<IActionResult>;
+    /** List subfolders of a parent folder. */
+    listSubfolders(folderId: ID): Promise<GetSubFoldersResult>;
+}
+/** FIXME */
+export interface IWebResourceService {
+    /** URL where to print a resource. */
+    getPrintUrl(resourceId: string): string;
+    /** URL where to view a resource. */
+    getViewUrl(resourceId: string): string;
+    /** URL where to edit a resource. */
+    getEditUrl(resourceId: string): string;
+    /** URL where to create a new resource. */
+    getFormUrl(folderId?: string): string;
+}
+/** Model of a searchable (indexed) resource. */
+export interface IResource {
+    application: App | string;
+    assetId: ID;
+    creatorId: ID;
+    creatorName: string;
+    comments?: number;
+    createdAt: string;
+    favorite?: boolean;
+    folderIds?: ID[];
+    id: ID;
+    modifiedAt: string;
+    modifierId: ID;
+    modifierName: string;
+    name: string;
+    slug?: string;
+    public?: boolean;
+    shared?: boolean;
+    thumbnail: string;
+    updatedAt: string;
+    views?: number;
+    trashed: boolean;
+    trashedBy?: ID[];
+    rights: RightStringified[];
+    description: string;
+}
+/**
+ * Core actions applicable on resources.
+ * Specific actions, which would depend on the running application,
+ * MUST BE typed and implemented in this application's agent.
+ */
+export declare const ACTION: {
+    readonly SEARCH: "search";
+    readonly CREATE: "create";
+    readonly CREATE_PUBLIC: "createPublic";
+    readonly OPEN: "open";
+    readonly EDIT: "edit";
+    readonly MANAGE: "manage";
+    readonly UPD_PROPS: "properties";
+    readonly COMMENT: "comment";
+    readonly DELETE: "delete";
+    readonly TRASH: "trash";
+    readonly RESTORE: "restore";
+    readonly MOVE: "move";
+    readonly COPY: "copy";
+    readonly EXPORT: "export";
+    readonly SHARE: "share";
+    readonly PRINT: "print";
+    readonly PAGES_LIST: "pages_list";
+    readonly DISTRIBUTE: "distribute";
+    readonly REGISTER: "register";
+    readonly PUBLISH: "publish";
+    readonly PUBLISH_MOODLE: "publish_moodle";
+};
+export type ActionType = (typeof ACTION)[keyof typeof ACTION];
+/** Constant folders IDs */
+export declare const FOLDER: {
+    /** Special ID of the bin, or trash folder. */
+    readonly BIN: "bin";
+    /** Special ID of the root folder. */
+    readonly DEFAULT: "default";
+};
+export type FolderType = (typeof FOLDER)[keyof typeof FOLDER];
+/** Constant search filters IDs, having a boolean type. */
+export declare const BOOLEAN_FILTER: {
+    readonly OWNER: "owner";
+    readonly SHARED: "shared";
+    readonly PUBLIC: "public";
+    readonly FAVORITE: "favorite";
+};
+export type BooleanFilterType = (typeof BOOLEAN_FILTER)[keyof typeof BOOLEAN_FILTER];
+/** Sort orders. */
+export declare const SORT_ORDER: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+export type SortOrderType = (typeof SORT_ORDER)[keyof typeof SORT_ORDER];
+/** Sortable fields. */
+export declare const SORT_BY: {
+    readonly NAME: "name";
+    readonly MODIFY_DATE: "updatedAt";
+    readonly CREATED_AT: "createdAt";
+    readonly APPLICATION: "application";
+    readonly RESOURCE_TYPE: "resourceType";
+};
+export type SortByType = (typeof SORT_BY)[keyof typeof SORT_BY];
+export type FilterValues = {
+    [B in BooleanFilterType]?: boolean;
+} & {
+    folder?: ID;
+};
+export type OrderValues = {
+    [O in SortByType]?: SortOrderType;
+};
+/**
+ * Model of actions the user can -or cannot- accomplish.
+ */
+export interface IAction {
+    id: ActionType;
+    /** Needed workflow right to accomplish this action. */
+    workflow: string;
+    /** Thruthy if the user owns the corresponding right. */
+    available?: boolean;
+    target?: 'actionbar' | 'tree';
+    right?: RightRole;
+}
+export interface IFolder {
+    id: ID;
+    parentId: ID;
+    name: string;
+    type: FolderType | ID;
+    childNumber: number;
+    trashed: boolean;
+    rights: string[];
+    ancestors: string[];
+}
+export interface IFilter {
+    id: BooleanFilterType;
+    defaultValue?: string | string[] | boolean | boolean[];
+}
+export interface IOrder {
+    id: SortByType;
+    defaultValue?: SortOrderType;
+    i18n: string;
+}
+export interface IPagination {
+    /** Index of the first available result. */
+    startIdx: number;
+    /** Number of actual results. */
+    pageSize: number;
+    /** Index of the last result (number of hits less 1). */
+    maxIdx?: number;
+}
+/** Base  */
+export interface IActionParameters {
+    application: App | string;
+}
+/**  */
+export interface IActionResult {
+}
+/** Parameters expected to create a resource */
+export interface CreateParameters extends IActionParameters {
+    name: string;
+    description: string;
+    thumbnail: string | Blob | File;
+    folder: number | undefined;
+    public?: boolean;
+    slug?: string;
+    commentType?: string;
+    publishType?: string;
+}
+/** Response when creating resource */
+export interface CreateResult {
+    'entId': string;
+    'thumbnail': string | undefined;
+    '_id'?: string;
+    'title'?: string;
+    'description'?: string;
+    'visibility'?: string;
+    'trashed'?: boolean;
+    'publish-type'?: string;
+    'comment-type'?: string;
+    'created'?: {
+        $date: string;
+    };
+    'modified'?: {
+        $date: string;
+    };
+    'author'?: {
+        userId: string;
+        username: string;
+        login: string;
+    };
+    'shared'?: Array<string>;
+}
+/** Parameters expected to copy a resource. */
+export interface CopyParameters extends IActionParameters {
+    resourceId: ID;
+}
+/** Response when copying a resource. */
+export interface CopyResult extends IActionResult {
+    duplicateId: ID;
+    message: string;
+}
+/** Parameters expected to publish a resource */
+export interface PublishParameters extends IActionParameters {
+    userId: string | undefined;
+    title: string;
+    cover: Blob;
+    language: string;
+    activityType: string[];
+    subjectArea: string[];
+    age: [string, string];
+    description: string;
+    keyWords: string;
+    licence: string;
+    teacherAvatar: Blob;
+    resourceId: string;
+    resourceEntId: string;
+    userStructureName: string;
+}
+/** Response when publishing a resource */
+export interface PublishResult extends IActionResult {
+    details: {
+        application: string;
+        created_at: string;
+        description: string;
+        front_url: string;
+        id: string;
+        title: string;
+    };
+    message: string;
+    reason: string;
+    success: boolean;
+}
+export interface IPreferences {
+    view: 'card' | 'list';
+}
+export interface ISearchParameters {
+    types: ResourceType[];
+    filters: FilterValues;
+    orders?: OrderValues;
+    pagination: IPagination;
+    search?: string;
+    trashed?: boolean;
+    id?: number;
+    asset_id?: string[];
+}
+export interface IResourceParameters {
+    id: string;
+}
+export interface ISearchResults {
+    folders: IFolder[];
+    pagination: IPagination;
+    resources: IResource[];
+    searchConfig?: {
+        minLength: number;
+    };
+}
+export interface IContext extends ISearchResults {
+    preferences: IPreferences;
+}
+/** Parameters expected to search for a resource */
+export type GetContextParameters = IActionParameters & ISearchParameters;
+/** Response when searching for a resource */
+export type GetContextResult = IActionResult & IContext;
+/** Parameters expected to create a folder */
+export interface CreateFolderParameters extends IActionParameters {
+    type?: ResourceType;
+    parentId: ID | 'default';
+    name: string;
+}
+/** Response when creating a folder */
+export interface CreateFolderResult extends IActionResult, IFolder {
+    createdAt: string;
+    creator_id?: string;
+}
+/** Parameters expected to update a folder */
+export interface UpdateFolderParameters extends IActionParameters {
+    folderId: ID;
+    type: ResourceType;
+    parentId: ID | 'default';
+    name: string;
+}
+/** Response when updating a folder */
+export interface UpdateFolderResult extends CreateFolderResult {
+    updatedAt: string;
+    parentId: ID | 'default';
+}
+/** Parameters expected to move folders and/or resources */
+export interface MoveParameters extends IActionParameters {
+    folderId: ID;
+    resourceIds: ID[];
+    folderIds: ID[];
+}
+/** Response when listing subfolders of a folder */
+export interface GetSubFoldersResult extends IActionResult {
+    folders: IFolder[];
+}
+/** Parameters expected to delete folders and/or resources */
+export interface DeleteParameters extends IActionParameters {
+    resourceType: string;
+    resourceIds: ID[];
+    folderIds: ID[];
+}
+export interface TrashParameters extends DeleteParameters {
+    trash: boolean;
+}
+export type GetResourceParameters = IActionParameters & IResourceParameters;
+export type GetResourcesParameters = IActionParameters & ISearchParameters;
+export type GetResourcesResult = IActionResult & ISearchResults;
+/** Parameters expected to update resource. */
+export interface UpdateParameters {
+    entId: string;
+    trashed: boolean;
+    name: string;
+    thumbnail: string | Blob | File;
+    description: string;
+    public: boolean;
+    slug: string;
+}
+/** Response when updating resource. */
+export interface UpdateResult {
+    entId: string;
+    thumbnail?: string;
+}
+export interface BlogUpdate extends UpdateParameters {
+    'publish-type'?: 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface BlogResource extends IResource {
+    'publish-type': 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface MindmapUpdate extends UpdateParameters {
+    'publish-type'?: 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface MindmapResource extends IResource {
+    'publish-type': 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface CollaborativewallUpdate extends UpdateParameters {
+    'publish-type'?: 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface CollaborativewallResource extends IResource {
+    'publish-type': 'RESTRAINT' | 'IMMEDIATE';
+}
+export interface ScrapbookUpdate extends UpdateParameters {
+}
+export interface ScrapbookResource extends IResource {
+}

package/dist/resources/services/ScrapbookResourceService.d.ts

@@ -0,0 +1,14 @@
+import { ResourceType } from '../..';
+import { CreateParameters, CreateResult, ScrapbookUpdate, UpdateResult } from '../interface';
+import { ResourceService } from '../ResourceService';
+export declare class ScrapbookResourceService extends ResourceService {
+    create<T extends CreateParameters>(parameters: T): Promise<CreateResult>;
+    update(parameters: ScrapbookUpdate): Promise<UpdateResult>;
+    getResourceType(): ResourceType;
+    getApplication(): string;
+    getFormUrl(folderId?: string): string;
+    getViewUrl(resourceId: string): string;
+    getPrintUrl(resourceId: string): string;
+    getEditUrl(resourceId: string): string;
+    getExportUrl(resourceId: string): string;
+}

package/dist/rights/Service.d.ts

@@ -0,0 +1,77 @@
+import { IOdeServices } from '../services/OdeServices';
+import { ResourceRight, RightRole, RightStringified } from './interface';
+export declare class RightService {
+    private context;
+    constructor(context: IOdeServices);
+    get session(): import('../session/Service').SessionService;
+    /**
+     * Parse right concat as "$TYPE:$ID:$RIGHT"
+     * $TYPE = user | group | creator
+     * $ID: id of the resource
+     * $RIGHT: read | contrib | manage
+     *
+     * @param right  a concat right
+     * @returns Right parsed
+     */
+    parseResourceRight(right: RightStringified): ResourceRight | undefined;
+    /**
+     * Parse an array of rights concat as "$TYPE:$ID:$RIGHT"
+     * $TYPE = user | group | creator
+     * $ID: id of the resource
+     * $RIGHT: read | contrib | manage
+     *
+     * @param rights  a list of concat rights
+     * @returns Array of Right parsed
+     */
+    parseResourceRights(rights: RightStringified[]): ResourceRight[];
+    /**
+     * Check wether a user has the expected right for a ressource
+     * @param user the userId and groupId concerned by the check
+     * @param expect the expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    hasResourceRight({ id, groupIds }: {
+        id: string;
+        groupIds: string[];
+    }, expect: RightRole, rights: ResourceRight[] | RightStringified[]): boolean;
+    /**
+     * Check wether the current user have resource right
+     * @param expect the expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    sessionHasResourceRight(expect: RightRole, rights: ResourceRight[] | RightStringified[]): Promise<boolean>;
+    /**
+     * Check wether the current user have at least one of resource right expected
+     * @param expects array of expected right to check
+     * @param rights array of Right for the resource
+     * @returns true if has rights
+     */
+    sessionHasAtLeastOneResourceRight(expects: RightRole[], rights: ResourceRight[] | RightStringified[]): Promise<boolean>;
+    /**
+     * Check wether the current user has resource right for each right list
+     * @param expect expected right to check
+     * @param rightsArray array of array of Right for multiple resources
+     * @returns true if has rights
+     */
+    sessionHasResourceRightForEachList(expect: RightRole, rightsArray: ResourceRight[][] | RightStringified[][]): Promise<boolean>;
+    /**
+     * Check wether the current user have at least one of resource right for each right list
+     * @param expects array of expected right to check
+     * @param rightsArray array of array of Right for multiple resources
+     * @returns true if has rights
+     */
+    sessionHasAtLeastOneResourceRightForEachList(expects: RightRole[], rightsArray: ResourceRight[][] | RightStringified[][]): Promise<boolean>;
+    hasWorkflowRight(expect: string, right: string[]): boolean;
+    /**
+     * @param expect a workflow right
+     * @returns true if current session has right on it
+     */
+    sessionHasWorkflowRight(expect: string): Promise<boolean>;
+    /**
+     * @param expect a workflow right
+     * @returns a record with right as key and boolean as value if current session has right on it
+     */
+    sessionHasWorkflowRights(expects: string[]): Promise<Record<string, boolean>>;
+}

package/dist/rights/interface.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Identify the type of "user"
+ */
+export type RightSubject = 'user' | 'group' | 'creator';
+/**
+ * Identify the role of the right
+ */
+export type RightRole = 'read' | 'contrib' | 'manager' | 'creator' | (string & {});
+/**
+ * Right of a resource
+ */
+export interface ResourceRight {
+    type: RightSubject;
+    id: string;
+    right: RightRole;
+}
+/** FIXME */
+export type RightStringified = string;

package/dist/services/OdeServices.d.ts

@@ -0,0 +1,72 @@
+import { CacheService } from '../cache/Service';
+import { ConfService } from '../configure/Service';
+import { DirectoryService } from '../directory/Service';
+import { HttpService } from '../transport/Service';
+import { RightService } from '../rights/Service';
+import { SessionService } from '../session/Service';
+import { ShareService } from '../share/Service';
+import { WorkspaceService } from '../workspace/Service';
+import { IdiomService } from '../idiom/Service';
+import { AnalyticsService } from '../analytics/Service';
+import { IAudienceService } from '../audience/interface';
+import { VideoService } from '../video/Service';
+import { App, ResourceType } from '../globals';
+import { IBehaviourService, IResourceService, IWebResourceService } from '../resources/interface';
+import { EmbedderService } from '../embedder/Service';
+import { INotifyFramework } from '../notify/interfaces';
+import { DataService } from '../data/Service';
+import { IDataService } from '../data/interface';
+export interface IOdeServices {
+    analytics(): AnalyticsService;
+    audience(application: App, resourceType: ResourceType): IAudienceService;
+    cache(): CacheService;
+    conf(): ConfService;
+    data(): IDataService;
+    directory(): DirectoryService;
+    http(): HttpService;
+    idiom(): IdiomService;
+    notify(): INotifyFramework;
+    resource(application: App, resourceType?: ResourceType): IResourceService & IWebResourceService;
+    behaviour(application: App, resourceType: ResourceType): IBehaviourService;
+    rights(): RightService;
+    session(): SessionService;
+    share(): ShareService;
+    video(): VideoService;
+    workspace(): WorkspaceService;
+    embedder(): EmbedderService;
+}
+export declare class OdeServices implements IOdeServices {
+    private _analytics;
+    private _cache;
+    private _conf;
+    private _data;
+    private _directory;
+    private _http;
+    private _idiom;
+    private _notify;
+    private _rights;
+    private _session;
+    private _share;
+    private _video;
+    private _workspace;
+    private _embedder;
+    constructor();
+    initialize(): OdeServices;
+    analytics(): AnalyticsService;
+    audience(application: App, resourceType: ResourceType): IAudienceService;
+    cache(): CacheService;
+    conf(): ConfService;
+    data(): DataService;
+    directory(): DirectoryService;
+    http(): HttpService;
+    idiom(): IdiomService;
+    notify(): INotifyFramework;
+    resource(application: App, resourceType?: ResourceType): IResourceService & IWebResourceService;
+    behaviour(application: App, resourceType: ResourceType): IBehaviourService;
+    rights(): RightService;
+    session(): SessionService;
+    share(): ShareService;
+    video(): VideoService;
+    workspace(): WorkspaceService;
+    embedder(): EmbedderService;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,10 @@
+import { IOdeServices } from './OdeServices';
+export declare const odeServices: IOdeServices;
+export * from '../directory/interface';
+export type { ILinkedResource } from '../resources/behaviours/AbstractBehaviourService';
+export * from '../resources/interface';
+export * from '../resources/ResourceService';
+export * from '../resources/SnipletsService';
+export * from '../rights/interface';
+export * from '../share/interface';
+export * from '../workspace/interface';

package/dist/session/Framework.d.ts

@@ -0,0 +1,10 @@
+import { ISessionFramework } from './interfaces';
+import { Session } from './Session';
+export declare class SessionFramework implements ISessionFramework {
+    session: Session;
+    initialize(): Promise<void>;
+    login(email: string, password: string, rememberMe?: boolean, secureLocation?: boolean): Promise<void>;
+    logout(): Promise<void>;
+}
+/** The whole framework is a singleton. */
+export declare const session: SessionFramework;

package/dist/session/Service.d.ts

@@ -0,0 +1,39 @@
+import { App } from '../globals';
+import { GetUserProfileOptions, IGetSession, IQuotaAndUsage, IUserInfo, IWebApp, UserProfile } from './interfaces';
+import { IOdeServices } from '../services/OdeServices';
+export declare class SessionService {
+    private context;
+    constructor(context: IOdeServices);
+    get http(): import('../transport/Service').HttpService;
+    get cache(): import('../cache/Service').CacheService;
+    private get conf();
+    /**
+     * Callback to call when user logout
+     */
+    onLogout(): void;
+    /**
+     * Callback to call when session change
+     */
+    onRefreshSession(): void;
+    getSession(): Promise<IGetSession>;
+    login(email: string, password: string, rememberMe?: boolean, secureLocation?: boolean): Promise<void>;
+    logout(): Promise<void>;
+    latestQuotaAndUsage(user: IUserInfo | undefined): Promise<IQuotaAndUsage>;
+    getCurrentLanguage(user: IUserInfo | undefined): Promise<string | undefined>;
+    private loadUserLanguage;
+    private loadDefaultLanguage;
+    getUser(): Promise<IUserInfo | undefined>;
+    hasWorkflow({ workflowName, user, }: {
+        workflowName: string;
+        user: IUserInfo;
+    }): boolean;
+    private loadDescription;
+    private getBookmarks;
+    getUserProfile(options?: Partial<GetUserProfileOptions>): Promise<UserProfile>;
+    isAdml(): Promise<boolean>;
+    /**
+     * Get details of an application if the user can access it.
+     * @return undefined if no access, or app not found
+     */
+    getWebApp(application: App): Promise<IWebApp | undefined>;
+}

package/dist/session/Session.d.ts

@@ -0,0 +1,34 @@
+import { IEmailValidationInfos, IEmailValidationState, IMfaCodeState, IMfaInfos, IMobileValidationInfos, IMobileValidationState, IQuotaAndUsage, ISession, IUserDescription, IUserInfo, UserProfile } from './interfaces';
+import { App } from '../globals';
+export declare class Session implements ISession {
+    private _me;
+    private _currentLanguage;
+    private _notLoggedIn;
+    private _description?;
+    private _profile?;
+    get currentLanguage(): string;
+    get notLoggedIn(): boolean;
+    get description(): IUserDescription;
+    get avatarUrl(): string;
+    get user(): IUserInfo;
+    get currentApp(): App | null;
+    initialize(): Promise<void>;
+    private setCurrentModel;
+    hasWorkflow(workflowName: string): boolean;
+    hasRight(resource: any, right: any): boolean;
+    get latestQuotaAndUsage(): Promise<IQuotaAndUsage>;
+    private setCurrentLanguage;
+    private loadDefaultLanguage;
+    private loadDescription;
+    get profile(): UserProfile;
+    getUserProfile(): Promise<UserProfile>;
+    private loadUserLanguage;
+    getEmailValidationInfos(): Promise<IEmailValidationInfos>;
+    checkEmail(email: String): Promise<void>;
+    tryEmailValidation(code: String): Promise<IEmailValidationState>;
+    getMobileValidationInfos(): Promise<IMobileValidationInfos>;
+    checkMobile(mobile: String): Promise<void>;
+    tryMobileValidation(code: String): Promise<IMobileValidationState>;
+    getMfaInfos(): Promise<IMfaInfos>;
+    tryMfaCode(code: String): Promise<IMfaCodeState>;
+}