box-ui-elements 16.0.0-beta.8 → 16.0.0

package/src/api/APIFactory.js

@@ -17,6 +17,7 @@ import CommentsAPI from './Comments';
 import TasksNewAPI from './tasks/TasksNew';
 import TaskCollaboratorsAPI from './tasks/TaskCollaborators';
 import TaskLinksAPI from './tasks/TaskLinks';
+import ThreadedCommentsAPI from './ThreadedComments';
 import FileAccessStatsAPI from './FileAccessStats';
 import MarkerBasedGroupsAPI from './MarkerBasedGroups';
 import MarkerBasedUsersAPI from './MarkerBasedUsers';
@@ -91,6 +92,11 @@ class APIFactory {
      */
     commentsAPI: CommentsAPI;
 
+    /**
+     * @property {ThreadedCommentsAPI}
+     */
+    threadedCommentsAPI: ThreadedCommentsAPI;
+
     /**
      * @property {TasksNewAPI}
      */
@@ -280,6 +286,11 @@ class APIFactory {
             delete this.commentsAPI;
         }
 
+        if (this.threadedCommentsAPI) {
+            this.threadedCommentsAPI.destroy();
+            delete this.threadedCommentsAPI;
+        }
+
         if (this.markerBasedGroupsAPI) {
             this.markerBasedGroupsAPI.destroy();
             delete this.markerBasedGroupsAPI;
@@ -510,6 +521,21 @@ class APIFactory {
         return this.commentsAPI;
     }
 
+    /**
+     * API for threaded comments
+     *
+     * @param {boolean} shouldDestroy - true if the factory should destroy before returning the call
+     * @return {ThreadedCommentsAPI} ThreadedCommentsAPI instance
+     */
+    getThreadedCommentsAPI(shouldDestroy: boolean): ThreadedCommentsAPI {
+        if (shouldDestroy) {
+            this.destroy();
+        }
+
+        this.threadedCommentsAPI = new ThreadedCommentsAPI(this.options);
+        return this.threadedCommentsAPI;
+    }
+
     /**
      * API for tasks
      *

package/src/api/Annotations.js

@@ -2,16 +2,21 @@
 import merge from 'lodash/merge';
 import {
     ERROR_CODE_CREATE_ANNOTATION,
+    ERROR_CODE_CREATE_REPLY,
     ERROR_CODE_DELETE_ANNOTATION,
     ERROR_CODE_EDIT_ANNOTATION,
     ERROR_CODE_FETCH_ANNOTATION,
     ERROR_CODE_FETCH_ANNOTATIONS,
+    ERROR_CODE_FETCH_REPLIES,
     PERMISSION_CAN_CREATE_ANNOTATIONS,
     PERMISSION_CAN_DELETE,
     PERMISSION_CAN_EDIT,
     PERMISSION_CAN_VIEW_ANNOTATIONS,
+    PERMISSION_CAN_RESOLVE,
 } from '../constants';
 import MarkerBasedApi from './MarkerBasedAPI';
+import { formatComment } from './utils';
+
 import type {
     Annotation,
     AnnotationPermission,
@@ -20,8 +25,64 @@ import type {
 } from '../common/types/annotations';
 import type { BoxItemPermission } from '../common/types/core';
 import type { ElementsXhrError } from '../common/types/api';
+import type { Comment, FeedItemStatus, ThreadedComments } from '../common/types/feed';
 
 export default class Annotations extends MarkerBasedApi {
+    /**
+     * Formats annotation replies' comment data for use in components.
+     *
+     * @param {Annotation} annotation - An individual annotation entry from the API
+     * @return {Annotation} Updated annotation
+     */
+    formatReplies(annotation: Annotation): Annotation {
+        if (!annotation.replies || !annotation.replies.length) {
+            return annotation;
+        }
+
+        return {
+            ...annotation,
+            replies: annotation.replies.map(formatComment),
+        };
+    }
+
+    /**
+     * Formats the annotations api response to usable data
+     * @param {Object} data the api response data
+     */
+    successHandler = (data: Object): void => {
+        if (this.isDestroyed() || typeof this.successCallback !== 'function') {
+            return;
+        }
+
+        // There is no response data when deleting an annotation
+        if (!data) {
+            this.successCallback();
+            return;
+        }
+
+        // We don't have entries when updating/creating an annotation
+        if (!data.entries) {
+            // Check if the response is a comment (result of createAnnotationReply)
+            if (data.type && data.type === 'comment') {
+                this.successCallback(formatComment(data));
+                return;
+            }
+
+            this.successCallback(this.formatReplies(data));
+            return;
+        }
+
+        // Check if the response is the replies of an annotation (result of getAnnotationReplies)
+        if (data.entries.length && data.entries[0].type === 'comment') {
+            const replies = data.entries.map(formatComment);
+            this.successCallback({ ...data, entries: replies });
+            return;
+        }
+
+        const annotations = data.entries.map(this.formatReplies);
+        this.successCallback({ ...data, entries: annotations });
+    };
+
     getUrl() {
         return `${this.getBaseApiUrl()}/undoc/annotations`;
     }
@@ -30,6 +91,10 @@ export default class Annotations extends MarkerBasedApi {
         return `${this.getUrl()}/${annotationId}`;
     }
 
+    getUrlWithRepliesForId(annotationId: string) {
+        return `${this.getUrlForId(annotationId)}/replies`;
+    }
+
     createAnnotation(
         fileId: string,
         fileVersionId: string,
@@ -55,8 +120,6 @@ export default class Annotations extends MarkerBasedApi {
                 id: fileVersionId,
                 type: 'file_version',
             },
-            status: 'open',
-            type: 'annotation',
         };
 
         this.post({
@@ -74,24 +137,39 @@ export default class Annotations extends MarkerBasedApi {
         fileId: string,
         annotationId: string,
         permissions: AnnotationPermission,
-        message: string,
+        payload: { message?: string, status?: FeedItemStatus },
         successCallback: (annotation: Annotation) => void,
         errorCallback: (e: ElementsXhrError, code: string) => void,
     ): void {
         this.errorCode = ERROR_CODE_EDIT_ANNOTATION;
+        const { message, status } = payload;
 
-        try {
-            this.checkApiCallValidity(PERMISSION_CAN_EDIT, permissions, fileId);
-        } catch (e) {
-            errorCallback(e, this.errorCode);
-            return;
+        if (message) {
+            try {
+                this.checkApiCallValidity(PERMISSION_CAN_EDIT, permissions, fileId);
+            } catch (e) {
+                errorCallback(e, this.errorCode);
+                return;
+            }
         }
 
-        const requestData = { data: { description: { message } } };
+        if (status) {
+            try {
+                this.checkApiCallValidity(PERMISSION_CAN_RESOLVE, permissions, fileId);
+            } catch (e) {
+                errorCallback(e, this.errorCode);
+                return;
+            }
+        }
 
         this.put({
             id: fileId,
-            data: requestData,
+            data: {
+                data: {
+                    description: message ? { message } : undefined,
+                    status,
+                },
+            },
             errorCallback,
             successCallback,
             url: this.getUrlForId(annotationId),
@@ -128,6 +206,7 @@ export default class Annotations extends MarkerBasedApi {
         permissions: BoxItemPermission,
         successCallback: (annotation: Annotation) => void,
         errorCallback: (e: ElementsXhrError, code: string) => void,
+        shouldFetchReplies?: boolean,
     ): void {
         this.errorCode = ERROR_CODE_FETCH_ANNOTATION;
 
@@ -138,11 +217,14 @@ export default class Annotations extends MarkerBasedApi {
             return;
         }
 
+        const requestData = shouldFetchReplies ? { params: { fields: 'replies' } } : undefined;
+
         this.get({
             id: fileId,
             errorCallback,
             successCallback,
             url: this.getUrlForId(annotationId),
+            requestData,
         });
     }
 
@@ -154,6 +236,7 @@ export default class Annotations extends MarkerBasedApi {
         errorCallback: (e: ElementsXhrError, code: string) => void,
         limit?: number,
         shouldFetchAll?: boolean,
+        shouldFetchReplies?: boolean,
     ): void {
         this.errorCode = ERROR_CODE_FETCH_ANNOTATIONS;
 
@@ -164,16 +247,69 @@ export default class Annotations extends MarkerBasedApi {
             return;
         }
 
+        const requestData = {
+            file_id: fileId,
+            file_version_id: fileVersionId,
+            ...(shouldFetchReplies ? { fields: 'replies' } : null),
+        };
+
         this.markerGet({
             id: fileId,
             errorCallback,
             limit,
-            requestData: {
-                file_id: fileId,
-                file_version_id: fileVersionId,
-            },
+            requestData,
             shouldFetchAll,
             successCallback,
         });
     }
+
+    getAnnotationReplies(
+        fileId: string,
+        annotationId: string,
+        permissions: BoxItemPermission,
+        successCallback: (comments: ThreadedComments) => void,
+        errorCallback: (e: ElementsXhrError, code: string) => void,
+    ): void {
+        this.errorCode = ERROR_CODE_FETCH_REPLIES;
+
+        try {
+            this.checkApiCallValidity(PERMISSION_CAN_VIEW_ANNOTATIONS, permissions, fileId);
+        } catch (e) {
+            errorCallback(e, this.errorCode);
+            return;
+        }
+
+        this.get({
+            id: fileId,
+            errorCallback,
+            successCallback,
+            url: this.getUrlWithRepliesForId(annotationId),
+        });
+    }
+
+    createAnnotationReply(
+        fileId: string,
+        annotationId: string,
+        permissions: BoxItemPermission,
+        message: string,
+        successCallback: (comment: Comment) => void,
+        errorCallback: (e: ElementsXhrError, code: string) => void,
+    ): void {
+        this.errorCode = ERROR_CODE_CREATE_REPLY;
+
+        try {
+            this.checkApiCallValidity(PERMISSION_CAN_CREATE_ANNOTATIONS, permissions, fileId);
+        } catch (e) {
+            errorCallback(e, this.errorCode);
+            return;
+        }
+
+        this.post({
+            id: fileId,
+            data: { data: { message } },
+            errorCallback,
+            successCallback,
+            url: this.getUrlWithRepliesForId(annotationId),
+        });
+    }
 }

package/src/api/Comments.js

@@ -17,6 +17,7 @@ import {
 } from '../constants';
 import type { ElementsXhrError, ElementsErrorCallback } from '../common/types/api';
 import type { BoxItem, BoxItemPermission } from '../common/types/core';
+import type { BoxCommentPermission } from '../common/types/feed';
 
 class Comments extends OffsetBasedAPI {
     /**
@@ -144,7 +145,7 @@ class Comments extends OffsetBasedAPI {
      * @param {BoxItem} file - File object for which we are updating a comment
      * @param {string} commentId - Comment to be edited
      * @param {string} message - Comment message
-     * @param {BoxItemPermission} permissions - The known permissions of the comment we're updating
+     * @param {BoxCommentPermission} permissions - The known permissions of the comment we're updating
      * @param {Function} successCallback - Success callback
      * @param {Function} errorCallback - Error callback
      * @return {void}
@@ -162,7 +163,7 @@ class Comments extends OffsetBasedAPI {
         errorCallback: ElementsErrorCallback,
         file: BoxItem,
         message: string,
-        permissions: BoxItemPermission,
+        permissions: BoxCommentPermission,
         successCallback: Function,
         tagged_message?: string,
     }): void {
@@ -194,7 +195,7 @@ class Comments extends OffsetBasedAPI {
      *
      * @param {BoxItem} file - File object for which we are deleting a comment
      * @param {string} commentId - Id of the comment we are deleting
-     * @param {BoxItemPermission} permissions - The known permissions of the comment we're deleting
+     * @param {BoxCommentPermission} permissions - The known permissions of the comment we're deleting
      * @param {Function} successCallback - Success callback
      * @param {Function} errorCallback - Error callback
      * @return {void}
@@ -209,7 +210,7 @@ class Comments extends OffsetBasedAPI {
         commentId: string,
         errorCallback: ElementsErrorCallback,
         file: BoxItem,
-        permissions: BoxItemPermission,
+        permissions: BoxCommentPermission,
         successCallback: Function,
     }): void {
         this.errorCode = ERROR_CODE_DELETE_COMMENT;