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

package/src/api/FileCollaborators.js

@@ -87,6 +87,36 @@ class FileCollaborators extends MarkerBasedAPI {
             requestData,
         });
     }
+
+    /**
+     * Fetches file @mention's
+     *
+     * @oaram {string} fileId
+     * @param {Function} successCallback
+     * @param {Function} errorCallback
+     * @param {string} searchStr - Search string to filter file collaborators by
+     * @param {Object} [options]
+     * @param {boolean} [options.includeGroups] - return groups as well as users
+     * @return {void}
+     */
+    getCollaboratorsWithQuery = (
+        fileId: string,
+        successCallback: ({ entries: Array<SelectorItem<UserMini | GroupMini>>, next_marker: ?string }) => void,
+        errorCallback: ElementsErrorCallback,
+        searchStr: string,
+        { includeGroups = false }: { includeGroups: boolean } = {},
+    ) => {
+        // Do not fetch without filter
+        if (!searchStr || searchStr.trim() === '') {
+            return;
+        }
+
+        this.getFileCollaborators(fileId, successCallback, errorCallback, {
+            filter_term: searchStr,
+            include_groups: includeGroups,
+            include_uploader_collabs: false,
+        });
+    };
 }
 
 export default FileCollaborators;

package/src/api/ThreadedComments.js

@@ -17,19 +17,26 @@ import {
     ERROR_CODE_FETCH_REPLIES,
     ERROR_CODE_CREATE_REPLY,
 } from '../constants';
+import { formatComment } from './utils';
 
-import type { ThreadedCommentPermission, ThreadedCommentStatus } from '../common/types/threadedComments';
 import type { ElementsXhrError, ElementsErrorCallback } from '../common/types/api';
 import type { BoxItem, BoxItemPermission } from '../common/types/core';
+import type {
+    BoxCommentPermission,
+    Comment,
+    FeedItemStatus,
+    ThreadedComments as ThreadedCommentsType,
+} from '../common/types/feed';
 
 class ThreadedComments extends MarkerBasedApi {
     /**
      * API URL for comments
      *
+     * @param {string} [fileId]
      * @return {string} base url for comments
      */
-    getUrl(): string {
-        return `${this.getBaseApiUrl()}/undoc/comments`;
+    getUrl(fileId?: string): string {
+        return `${this.getBaseApiUrl()}/undoc/comments${fileId ? `?file_id=${fileId}` : ''}`;
     }
 
     /**
@@ -45,13 +52,39 @@ class ThreadedComments extends MarkerBasedApi {
     /**
      * API URL for specific comment
      *
-     * @param {string} [commentId]
+     * @param {string} commentId
+     * @param {string} [fileId]
      * @return {string}  base url for specific comment replies
      */
-    getUrlWithRepliesForId(commentId: string): string {
-        return `${this.getUrlForId(commentId)}/replies`;
+    getUrlWithRepliesForId(commentId: string, fileId?: string): string {
+        return `${this.getUrlForId(commentId)}/replies${fileId ? `?file_id=${fileId}` : ''}`;
     }
 
+    /**
+     * Formats the threaded comments 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 a comment
+        if (!data) {
+            this.successCallback();
+            return;
+        }
+
+        // We don't have entries when updating/creating a comment
+        if (!data.entries) {
+            this.successCallback(formatComment(data));
+            return;
+        }
+
+        const comments = data.entries.map(formatComment);
+        this.successCallback({ ...data, entries: comments });
+    };
+
     /**
      * API for creating a comment on a file
      *
@@ -70,10 +103,10 @@ class ThreadedComments extends MarkerBasedApi {
         errorCallback: ElementsErrorCallback,
         file: BoxItem,
         message?: string,
-        successCallback: Function,
+        successCallback: (comment: Comment) => void,
     }): void {
         this.errorCode = ERROR_CODE_CREATE_COMMENT;
-        const { id, permissions, type } = file;
+        const { id, permissions } = file;
 
         try {
             this.checkApiCallValidity(PERMISSION_CAN_COMMENT, permissions, id);
@@ -84,15 +117,9 @@ class ThreadedComments extends MarkerBasedApi {
 
         this.post({
             id,
-            url: this.getUrl(),
+            url: this.getUrl(id),
             data: {
-                data: {
-                    item: {
-                        id,
-                        type,
-                    },
-                    message,
-                },
+                data: { message },
             },
             successCallback,
             errorCallback,
@@ -104,9 +131,9 @@ class ThreadedComments extends MarkerBasedApi {
      *
      * @param {string} fileId - File id for which we are updating a comment
      * @param {string} commentId - Comment to be edited
-     * @param {ThreadedCommentStatus} status - Comment status
+     * @param {FeedItemStatus} status - Comment status
      * @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}
@@ -124,9 +151,9 @@ class ThreadedComments extends MarkerBasedApi {
         errorCallback: ElementsErrorCallback,
         fileId: string,
         message?: string,
-        permissions: ThreadedCommentPermission,
-        status?: ThreadedCommentStatus,
-        successCallback: Function,
+        permissions: BoxCommentPermission,
+        status?: FeedItemStatus,
+        successCallback: (comment: Comment) => void,
     }): void {
         this.errorCode = ERROR_CODE_UPDATE_COMMENT;
 
@@ -166,7 +193,7 @@ class ThreadedComments extends MarkerBasedApi {
      *
      * @param {string} fileId - Id of an object for which we are deleting a comment
      * @param {string} commentId - Id of the comment we are deleting
-     * @param {ThreadedCommentPermission} 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}
@@ -181,7 +208,7 @@ class ThreadedComments extends MarkerBasedApi {
         commentId: string,
         errorCallback: ElementsErrorCallback,
         fileId: string,
-        permissions: ThreadedCommentPermission,
+        permissions: BoxCommentPermission,
         successCallback: Function,
     }): void {
         this.errorCode = ERROR_CODE_DELETE_COMMENT;
@@ -232,7 +259,7 @@ class ThreadedComments extends MarkerBasedApi {
         permissions: BoxItemPermission,
         repliesCount?: number,
         shouldFetchAll?: boolean,
-        successCallback: Function,
+        successCallback: (threadedComments: ThreadedCommentsType) => void,
     }): void {
         this.errorCode = ERROR_CODE_FETCH_COMMENTS;
         try {
@@ -249,7 +276,6 @@ class ThreadedComments extends MarkerBasedApi {
             marker,
             limit,
             requestData: {
-                file_id: fileId,
                 ...(repliesCount ? { replies_count: repliesCount } : null),
             },
             shouldFetchAll,
@@ -274,7 +300,7 @@ class ThreadedComments extends MarkerBasedApi {
         errorCallback: (e: ElementsXhrError, code: string) => void,
         fileId: string,
         permissions: BoxItemPermission,
-        successCallback: Function,
+        successCallback: (comments: ThreadedCommentsType) => void,
     }): void {
         this.errorCode = ERROR_CODE_FETCH_REPLIES;
 
@@ -314,8 +340,7 @@ class ThreadedComments extends MarkerBasedApi {
         fileId: string,
         message: string,
         permissions: BoxItemPermission,
-        shouldFetchReplies?: boolean,
-        successCallback: Function,
+        successCallback: (comment: Comment) => void,
     }): void {
         this.errorCode = ERROR_CODE_CREATE_REPLY;
 
@@ -331,7 +356,7 @@ class ThreadedComments extends MarkerBasedApi {
             data: { data: { message } },
             errorCallback,
             successCallback,
-            url: this.getUrlWithRepliesForId(commentId),
+            url: this.getUrlWithRepliesForId(commentId, fileId),
         });
     }
 }

package/src/api/__tests__/Annotations.test.js

@@ -1,11 +1,23 @@
+import cloneDeep from 'lodash/cloneDeep';
 import Annotations from '../Annotations';
 import {
     ERROR_CODE_CREATE_ANNOTATION,
+    ERROR_CODE_CREATE_REPLY,
+    ERROR_CODE_FETCH_REPLIES,
     ERROR_CODE_DELETE_ANNOTATION,
     ERROR_CODE_EDIT_ANNOTATION,
     ERROR_CODE_FETCH_ANNOTATION,
     ERROR_CODE_FETCH_ANNOTATIONS,
 } from '../../constants';
+import { formatComment } from '../utils';
+import {
+    annotations as mockAnnotations,
+    threadedComments as mockThreadedComments,
+    threadedCommentsFormatted as mockThreadedCommentsFormatted,
+} from '../fixtures';
+
+const mockFormattedReply = cloneDeep(mockThreadedCommentsFormatted[1]);
+jest.mock('../utils', () => ({ formatComment: jest.fn(() => mockFormattedReply) }));
 
 describe('api/Annotations', () => {
     let annotations;
@@ -36,6 +48,14 @@ describe('api/Annotations', () => {
         });
     });
 
+    describe('getUrlWithRepliesForId()', () => {
+        test('should return the correct url for replies for given annotation id', () => {
+            expect(annotations.getUrlWithRepliesForId('test')).toBe(
+                'https://api.box.com/2.0/undoc/annotations/test/replies',
+            );
+        });
+    });
+
     describe('createAnnotation()', () => {
         const payload = {
             description: {
@@ -79,9 +99,7 @@ describe('api/Annotations', () => {
                             id: '67890',
                             type: 'file_version',
                         },
-                        status: 'open',
                         target: payload.target,
-                        type: 'annotation',
                     },
                 },
                 errorCallback,
@@ -102,34 +120,57 @@ describe('api/Annotations', () => {
     });
 
     describe('updateAnnotation()', () => {
-        const message = 'hello';
-
-        test('should format its parameters and call the update method for a given id', () => {
+        test('should format its parameters and call the update method for a given id and mesaage', () => {
             const errorCallback = jest.fn();
             const successCallback = jest.fn();
-            annotations.updateAnnotation('12345', 'abc', { can_edit: true }, message, successCallback, errorCallback);
+            const payload = { message: 'hello' };
+            annotations.updateAnnotation('12345', 'abc', { can_edit: true }, payload, successCallback, errorCallback);
 
             expect(annotations.put).toBeCalledWith({
                 id: '12345',
-                data: { data: { description: { message } } },
+                data: { data: { description: { message: 'hello' } } },
                 errorCallback,
                 successCallback,
                 url: 'https://api.box.com/2.0/undoc/annotations/abc',
             });
         });
 
-        test('should reject with an error code for calls with invalid permissions', () => {
+        test('should format its parameters and call the update method for a given id and status', () => {
             const errorCallback = jest.fn();
             const successCallback = jest.fn();
+            const payload = { status: 'resolved' };
             annotations.updateAnnotation(
                 '12345',
-                '67890',
-                { can_edit: false },
-                message,
+                'abc',
+                { can_resolve: true },
+                payload,
                 successCallback,
                 errorCallback,
             );
 
+            expect(annotations.put).toBeCalledWith({
+                id: '12345',
+                data: {
+                    data: {
+                        description: undefined,
+                        status: 'resolved',
+                    },
+                },
+                errorCallback,
+                successCallback,
+                url: 'https://api.box.com/2.0/undoc/annotations/abc',
+            });
+        });
+
+        test.each([
+            { can_resolve: true, can_edit: false },
+            { can_resolve: false, can_edit: true },
+        ])('should reject with an error code for calls with invalid permissions %s', permissions => {
+            const errorCallback = jest.fn();
+            const successCallback = jest.fn();
+            const payload = { message: 'hello', status: 'resolved' };
+            annotations.updateAnnotation('12345', '67890', permissions, payload, successCallback, errorCallback);
+
             expect(errorCallback).toBeCalledWith(expect.any(Error), ERROR_CODE_EDIT_ANNOTATION);
             expect(annotations.put).not.toBeCalled();
         });
@@ -175,6 +216,24 @@ describe('api/Annotations', () => {
                 errorCallback,
                 successCallback,
                 url: 'https://api.box.com/2.0/undoc/annotations/abc',
+                requestData: undefined,
+            });
+        });
+
+        test('should format its parameters and call the get method with replies', () => {
+            const permissions = {
+                can_create_annotations: true,
+                can_view_annotations: true,
+            };
+
+            annotations.getAnnotation('12345', 'abc', permissions, successCallback, errorCallback, true);
+
+            expect(annotations.get).toBeCalledWith({
+                id: '12345',
+                errorCallback,
+                successCallback,
+                url: 'https://api.box.com/2.0/undoc/annotations/abc',
+                requestData: { params: { fields: 'replies' } },
             });
         });
 
@@ -212,6 +271,28 @@ describe('api/Annotations', () => {
             });
         });
 
+        test('should format its parameters and call the underlying markerGet with additional requestData', () => {
+            const permissions = {
+                can_create_annotations: true,
+                can_view_annotations: true,
+            };
+
+            annotations.getAnnotations('12345', '67890', permissions, successCallback, errorCallback, 100, false, true);
+
+            expect(annotations.markerGet).toBeCalledWith({
+                id: '12345',
+                errorCallback,
+                successCallback: expect.any(Function),
+                limit: 100,
+                shouldFetchAll: false,
+                requestData: {
+                    file_id: '12345',
+                    file_version_id: '67890',
+                    fields: 'replies',
+                },
+            });
+        });
+
         test.each([
             { can_create_annotations: true, can_view_annotations: false },
             { can_create_annotations: false, can_view_annotations: false },
@@ -219,7 +300,132 @@ describe('api/Annotations', () => {
             annotations.getAnnotations('12345', '67890', permissions, successCallback, errorCallback);
 
             expect(errorCallback).toBeCalledWith(expect.any(Error), ERROR_CODE_FETCH_ANNOTATIONS);
+            expect(annotations.markerGet).not.toBeCalled();
+        });
+    });
+
+    describe('getAnnotationReplies()', () => {
+        const errorCallback = jest.fn();
+        const successCallback = jest.fn();
+
+        test('should format its parameters and call the get method', () => {
+            const permissions = {
+                can_create_annotations: true,
+                can_view_annotations: true,
+            };
+
+            annotations.getAnnotationReplies('12345', '67890', permissions, successCallback, errorCallback);
+
+            expect(annotations.get).toBeCalledWith({
+                id: '12345',
+                errorCallback,
+                successCallback,
+                url: 'https://api.box.com/2.0/undoc/annotations/67890/replies',
+            });
+        });
+
+        test.each([
+            { can_create_annotations: true, can_view_annotations: false },
+            { can_create_annotations: false, can_view_annotations: false },
+        ])('should reject with an error code for calls with invalid permissions %s', permissions => {
+            annotations.getAnnotationReplies('12345', '67890', permissions, successCallback, errorCallback);
+
+            expect(errorCallback).toBeCalledWith(expect.any(Error), ERROR_CODE_FETCH_REPLIES);
             expect(annotations.get).not.toBeCalled();
         });
     });
+
+    describe('createAnnotationReply()', () => {
+        const errorCallback = jest.fn();
+        const successCallback = jest.fn();
+        const message = 'Hello';
+
+        test('should format its parameters and call the post method', () => {
+            const permissions = {
+                can_create_annotations: true,
+            };
+            annotations.createAnnotationReply('12345', '67890', permissions, message, successCallback, errorCallback);
+            expect(annotations.post).toBeCalledWith({
+                id: '12345',
+                data: { data: { message } },
+                errorCallback,
+                successCallback,
+                url: 'https://api.box.com/2.0/undoc/annotations/67890/replies',
+            });
+        });
+        test.each([
+            { can_create_annotations: false, can_view_annotations: false },
+            { can_create_annotations: false, can_view_annotations: true },
+        ])('should reject with an error code for calls with invalid permissions %s', permissions => {
+            annotations.createAnnotationReply('12345', '67890', permissions, message, successCallback, errorCallback);
+            expect(errorCallback).toBeCalledWith(expect.any(Error), ERROR_CODE_CREATE_REPLY);
+            expect(annotations.post).not.toBeCalled();
+        });
+    });
+
+    describe('successHandler()', () => {
+        beforeEach(() => {
+            annotations.formatReplies = jest.fn();
+            annotations.successCallback = jest.fn();
+        });
+
+        test('should call the success callback with no data if none provided from API', () => {
+            annotations.successHandler();
+            expect(annotations.successCallback).toBeCalledWith();
+        });
+
+        test('should call formatReplies method and call the success callback if the response does not contain entries property', () => {
+            const response = cloneDeep(mockAnnotations[0]);
+            annotations.successHandler(response);
+            expect(annotations.formatReplies).toBeCalledWith(response);
+            expect(annotations.successCallback).toBeCalled();
+        });
+
+        test('should call formatComment util and call the success callback if the response does not contain entries property and has type = comment', () => {
+            const response = cloneDeep(mockThreadedComments[0]);
+            annotations.successHandler(response);
+            expect(formatComment).toBeCalledWith(response);
+            expect(annotations.successCallback).toBeCalled();
+        });
+
+        test('should call formatComment util, not call the formatReplies method and should call the success callback if the response contains comments (replies)', () => {
+            const response = {
+                entries: cloneDeep(mockThreadedComments),
+                limit: 1000,
+                next_marker: null,
+            };
+            annotations.successHandler(response);
+            expect(formatComment).toBeCalled();
+            expect(annotations.formatReplies).not.toBeCalled();
+            expect(annotations.successCallback).toBeCalled();
+        });
+
+        test('should call formatReplies method and call the success callback if the response contains annotations', () => {
+            const response = {
+                entries: cloneDeep(mockAnnotations),
+                limit: 1000,
+                next_marker: null,
+            };
+            annotations.successHandler(response);
+            expect(annotations.formatReplies).toBeCalled();
+            expect(annotations.successCallback).toBeCalled();
+        });
+    });
+
+    describe('formatReplies()', () => {
+        test('should return annotation with formatted replies when replies are present', () => {
+            const annotation = { id: '1234', replies: [{ id: '567' }] };
+            const expectedUpdatedAnnotation = { ...annotation, replies: [mockFormattedReply] };
+            const updatedAnnotation = annotations.formatReplies(annotation);
+
+            expect(updatedAnnotation).toMatchObject(expectedUpdatedAnnotation);
+        });
+
+        test('should return given annotation when replies are not present', () => {
+            const annotation = { id: '1234' };
+            const updatedAnnotation = annotations.formatReplies(annotation);
+
+            expect(updatedAnnotation).toMatchObject(annotation);
+        });
+    });
 });