feat: Sort cards within list (#717)

Closes #390

client/src/actions/lists.js

@@ -60,6 +60,38 @@ const handleListUpdate = (list) => ({
   },
 });
 
+const sortList = (id, data) => ({
+  type: ActionTypes.LIST_SORT,
+  payload: {
+    id,
+    data,
+  },
+});
+
+sortList.success = (list, cards) => ({
+  type: ActionTypes.LIST_SORT__SUCCESS,
+  payload: {
+    list,
+    cards,
+  },
+});
+
+sortList.failure = (id, error) => ({
+  type: ActionTypes.LIST_SORT__FAILURE,
+  payload: {
+    id,
+    error,
+  },
+});
+
+const handleListSort = (list, cards) => ({
+  type: ActionTypes.LIST_SORT_HANDLE,
+  payload: {
+    list,
+    cards,
+  },
+});
+
 const deleteList = (id) => ({
   type: ActionTypes.LIST_DELETE,
   payload: {
@@ -94,6 +126,8 @@ export default {
   handleListCreate,
   updateList,
   handleListUpdate,
+  sortList,
+  handleListSort,
   deleteList,
   handleListDelete,
 };

client/src/api/lists.js

@@ -1,4 +1,5 @@
 import socket from './socket';
+import { transformCard } from './cards';
 
 /* Actions */
 
@@ -7,10 +8,33 @@ const createList = (boardId, data, headers) =>
 
 const updateList = (id, data, headers) => socket.patch(`/lists/${id}`, data, headers);
 
+const sortList = (id, data, headers) =>
+  socket.post(`/lists/${id}/sort`, data, headers).then((body) => ({
+    ...body,
+    included: {
+      ...body.included,
+      cards: body.included.cards.map(transformCard),
+    },
+  }));
+
 const deleteList = (id, headers) => socket.delete(`/lists/${id}`, undefined, headers);
 
+/* Event handlers */
+
+const makeHandleListSort = (next) => (body) => {
+  next({
+    ...body,
+    included: {
+      ...body.included,
+      cards: body.included.cards.map(transformCard),
+    },
+  });
+};
+
 export default {
   createList,
   updateList,
+  sortList,
   deleteList,
+  makeHandleListSort,
 };

client/src/components/List/ActionsStep.jsx

@@ -5,15 +5,17 @@ import { Menu } from 'semantic-ui-react';
 import { Popup } from '../../lib/custom-ui';
 
 import { useSteps } from '../../hooks';
+import ListSortStep from '../ListSortStep';
 import DeleteStep from '../DeleteStep';
 
 import styles from './ActionsStep.module.scss';
 
 const StepTypes = {
   DELETE: 'DELETE',
+  SORT: 'SORT',
 };
 
-const ActionsStep = React.memo(({ onNameEdit, onCardAdd, onDelete, onClose }) => {
+const ActionsStep = React.memo(({ onNameEdit, onCardAdd, onSort, onDelete, onClose }) => {
   const [t] = useTranslation();
   const [step, openStep, handleBack] = useSteps();
 
@@ -27,20 +29,41 @@ const ActionsStep = React.memo(({ onNameEdit, onCardAdd, onDelete, onClose }) =>
     onClose();
   }, [onCardAdd, onClose]);
 
+  const handleSortClick = useCallback(() => {
+    openStep(StepTypes.SORT);
+  }, [openStep]);
+
   const handleDeleteClick = useCallback(() => {
     openStep(StepTypes.DELETE);
   }, [openStep]);
 
-  if (step && step.type === StepTypes.DELETE) {
+  const handleSortTypeSelect = useCallback(
-    return (
+    (type) => {
-      <DeleteStep
+      onSort({
-        title="common.deleteList"
+        type,
-        content="common.areYouSureYouWantToDeleteThisList"
+      });
-        buttonContent="action.deleteList"
+
-        onConfirm={onDelete}
+      onClose();
-        onBack={handleBack}
+    },
-      />
+    [onSort, onClose],
-    );
+  );
+
+  if (step && step.type) {
+    switch (step.type) {
+      case StepTypes.SORT:
+        return <ListSortStep onTypeSelect={handleSortTypeSelect} onBack={handleBack} />;
+      case StepTypes.DELETE:
+        return (
+          <DeleteStep
+            title="common.deleteList"
+            content="common.areYouSureYouWantToDeleteThisList"
+            buttonContent="action.deleteList"
+            onConfirm={onDelete}
+            onBack={handleBack}
+          />
+        );
+      default:
+    }
   }
 
   return (
@@ -62,6 +85,11 @@ const ActionsStep = React.memo(({ onNameEdit, onCardAdd, onDelete, onClose }) =>
               context: 'title',
             })}
           </Menu.Item>
+          <Menu.Item className={styles.menuItem} onClick={handleSortClick}>
+            {t('action.sortList', {
+              context: 'title',
+            })}
+          </Menu.Item>
           <Menu.Item className={styles.menuItem} onClick={handleDeleteClick}>
             {t('action.deleteList', {
               context: 'title',
@@ -77,6 +105,7 @@ ActionsStep.propTypes = {
   onNameEdit: PropTypes.func.isRequired,
   onCardAdd: PropTypes.func.isRequired,
   onDelete: PropTypes.func.isRequired,
+  onSort: PropTypes.func.isRequired,
   onClose: PropTypes.func.isRequired,
 };
 

client/src/components/List/List.jsx

@@ -16,7 +16,18 @@ import { ReactComponent as PlusMathIcon } from '../../assets/images/plus-math-ic
 import styles from './List.module.scss';
 
 const List = React.memo(
-  ({ id, index, name, isPersisted, cardIds, canEdit, onUpdate, onDelete, onCardCreate }) => {
+  ({
+    id,
+    index,
+    name,
+    isPersisted,
+    cardIds,
+    canEdit,
+    onUpdate,
+    onDelete,
+    onSort,
+    onCardCreate,
+  }) => {
     const [t] = useTranslation();
     const [isAddCardOpened, setIsAddCardOpened] = useState(false);
 
@@ -114,6 +125,7 @@ const List = React.memo(
                     onNameEdit={handleNameEdit}
                     onCardAdd={handleCardAdd}
                     onDelete={onDelete}
+                    onSort={onSort}
                   >
                     <Button className={classNames(styles.headerButton, styles.target)}>
                       <Icon fitted name="pencil" size="small" />
@@ -159,6 +171,7 @@ List.propTypes = {
   cardIds: PropTypes.array.isRequired, // eslint-disable-line react/forbid-prop-types
   canEdit: PropTypes.bool.isRequired,
   onUpdate: PropTypes.func.isRequired,
+  onSort: PropTypes.func.isRequired,
   onDelete: PropTypes.func.isRequired,
   onCardCreate: PropTypes.func.isRequired,
 };

client/src/components/ListSortStep/ListSortStep.jsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useTranslation } from 'react-i18next';
+import { Menu } from 'semantic-ui-react';
+import { Popup } from '../../lib/custom-ui';
+import { ListSortTypes } from '../../constants/Enums';
+
+import styles from './ListSortStep.module.scss';
+
+const ListSortStep = React.memo(({ onTypeSelect, onBack }) => {
+  const [t] = useTranslation();
+
+  return (
+    <>
+      <Popup.Header onBack={onBack}>
+        {t('common.sortList', {
+          context: 'title',
+        })}
+      </Popup.Header>
+      <Popup.Content>
+        <Menu secondary vertical className={styles.menu}>
+          <Menu.Item
+            className={styles.menuItem}
+            onClick={() => onTypeSelect(ListSortTypes.NAME_ASC)}
+          >
+            {t('common.name')}
+          </Menu.Item>
+          <Menu.Item
+            className={styles.menuItem}
+            onClick={() => onTypeSelect(ListSortTypes.DUE_DATE_ASC)}
+          >
+            {t('common.dueDate')}
+          </Menu.Item>
+          <Menu.Item
+            className={styles.menuItem}
+            onClick={() => onTypeSelect(ListSortTypes.CREATED_AT_ASC)}
+          >
+            {t('common.oldestFirst')}
+          </Menu.Item>
+          <Menu.Item
+            className={styles.menuItem}
+            onClick={() => onTypeSelect(ListSortTypes.CREATED_AT_DESC)}
+          >
+            {t('common.newestFirst')}
+          </Menu.Item>
+        </Menu>
+      </Popup.Content>
+    </>
+  );
+});
+
+ListSortStep.propTypes = {
+  onTypeSelect: PropTypes.func.isRequired,
+  onBack: PropTypes.func,
+};
+
+ListSortStep.defaultProps = {
+  onBack: undefined,
+};
+
+export default ListSortStep;

client/src/components/ListSortStep/ListSortStep.module.scss

@@ -0,0 +1,11 @@
+:global(#app) {
+  .menu {
+    margin: -7px -12px -5px;
+    width: calc(100% + 24px);
+  }
+
+  .menuItem {
+    margin: 0;
+    padding-left: 14px;
+  }
+}

client/src/components/ListSortStep/index.js

@@ -0,0 +1,3 @@
+import ListSortStep from './ListSortStep';
+
+export default ListSortStep;

client/src/constants/ActionTypes.js

@@ -173,6 +173,10 @@ export default {
   LIST_UPDATE__SUCCESS: 'LIST_UPDATE__SUCCESS',
   LIST_UPDATE__FAILURE: 'LIST_UPDATE__FAILURE',
   LIST_UPDATE_HANDLE: 'LIST_UPDATE_HANDLE',
+  LIST_SORT: 'LIST_SORT',
+  LIST_SORT__SUCCESS: 'LIST_SORT__SUCCESS',
+  LIST_SORT__FAILURE: 'LIST_SORT__FAILURE',
+  LIST_SORT_HANDLE: 'LIST_SORT_HANDLE',
   LIST_DELETE: 'LIST_DELETE',
   LIST_DELETE__SUCCESS: 'LIST_DELETE__SUCCESS',
   LIST_DELETE__FAILURE: 'LIST_DELETE__FAILURE',

client/src/constants/EntryActionTypes.js

@@ -120,6 +120,8 @@ export default {
   LIST_MOVE: `${PREFIX}/LIST_MOVE`,
   LIST_DELETE: `${PREFIX}/LIST_DELETE`,
   LIST_DELETE_HANDLE: `${PREFIX}/LIST_DELETE_HANDLE`,
+  LIST_SORT: `${PREFIX}/LIST_SORT`,
+  LIST_SORT_HANDLE: `${PREFIX}/LIST_SORT_HANDLE`,
 
   /* Cards */
 

client/src/constants/Enums.js

@@ -8,6 +8,13 @@ export const BoardMembershipRoles = {
   VIEWER: 'viewer',
 };
 
+export const ListSortTypes = {
+  NAME_ASC: 'name_asc',
+  DUE_DATE_ASC: 'dueDate_asc',
+  CREATED_AT_ASC: 'createdAt_asc',
+  CREATED_AT_DESC: 'createdAt_desc',
+};
+
 export const ActivityTypes = {
   CREATE_CARD: 'createCard',
   MOVE_CARD: 'moveCard',

client/src/containers/ListContainer.js

@@ -33,6 +33,7 @@ const mapDispatchToProps = (dispatch, { id }) =>
   bindActionCreators(
     {
       onUpdate: (data) => entryActions.updateList(id, data),
+      onSort: (data) => entryActions.sortList(id, data),
       onDelete: () => entryActions.deleteList(id),
       onCardCreate: (data, autoOpen) => entryActions.createCard(id, data, autoOpen),
     },

client/src/entry-actions/lists.js

@@ -37,6 +37,24 @@ const moveList = (id, index) => ({
   },
 });
 
+const sortList = (id, data) => {
+  return {
+    type: EntryActionTypes.LIST_SORT,
+    payload: {
+      id,
+      data,
+    },
+  };
+};
+
+const handleListSort = (list, cards) => ({
+  type: EntryActionTypes.LIST_SORT_HANDLE,
+  payload: {
+    list,
+    cards,
+  },
+});
+
 const deleteList = (id) => ({
   type: EntryActionTypes.LIST_DELETE,
   payload: {
@@ -57,6 +75,8 @@ export default {
   updateList,
   handleListUpdate,
   moveList,
+  sortList,
+  handleListSort,
   deleteList,
   handleListDelete,
 };

client/src/locales/en/core.js

@@ -60,6 +60,7 @@ export default {
       currentPassword: 'Current password',
       dangerZone_title: 'Danger Zone',
       date: 'Date',
+      dueDate: 'Due date',
       dueDate_title: 'Due Date',
       deleteAttachment_title: 'Delete Attachment',
       deleteBoard_title: 'Delete Board',
@@ -113,6 +114,7 @@ export default {
       minutes: 'Minutes',
       moveCard_title: 'Move Card',
       name: 'Name',
+      newestFirst: 'Newest first',
       newEmail: 'New e-mail',
       newPassword: 'New password',
       newUsername: 'New username',
@@ -122,6 +124,7 @@ export default {
       noProjects: 'No projects',
       notifications: 'Notifications',
       noUnreadNotifications: 'No unread notifications.',
+      oldestFirst: 'Oldest first',
       openBoard_title: 'Open Board',
       optional_inline: 'optional',
       organization: 'Organization',
@@ -142,6 +145,7 @@ export default {
       selectPermissions_title: 'Select Permissions',
       selectProject: 'Select project',
       settings: 'Settings',
+      sortList_title: 'Sort List',
       stopwatch: 'Stopwatch',
       subscribeToMyOwnCardsByDefault: 'Subscribe to my own cards by default',
       taskActions_title: 'Task Actions',
@@ -229,6 +233,7 @@ export default {
       showAllAttachments: 'Show all attachments ({{hidden}} hidden)',
       showDetails: 'Show details',
       showFewerAttachments: 'Show fewer attachments',
+      sortList_title: 'Sort List',
       start: 'Start',
       stop: 'Stop',
       subscribe: 'Subscribe',

client/src/models/Card.js

@@ -164,6 +164,14 @@ export default class extends BaseModel {
           Card.withId(payload.cardLabel.cardId).labels.remove(payload.cardLabel.labelId);
         } catch {} // eslint-disable-line no-empty
 
+        break;
+      case ActionTypes.LIST_SORT__SUCCESS:
+      case ActionTypes.LIST_SORT_HANDLE:
+      case ActionTypes.NOTIFICATION_CREATE_HANDLE:
+        payload.cards.forEach((card) => {
+          Card.upsert(card);
+        });
+
         break;
       case ActionTypes.CARD_CREATE:
       case ActionTypes.CARD_UPDATE__SUCCESS:
@@ -282,12 +290,6 @@ export default class extends BaseModel {
 
         break;
       }
-      case ActionTypes.NOTIFICATION_CREATE_HANDLE:
-        payload.cards.forEach((card) => {
-          Card.upsert(card);
-        });
-
-        break;
       default:
     }
   }

client/src/models/List.js

@@ -50,6 +50,8 @@ export default class extends BaseModel {
       case ActionTypes.LIST_CREATE_HANDLE:
       case ActionTypes.LIST_UPDATE__SUCCESS:
       case ActionTypes.LIST_UPDATE_HANDLE:
+      case ActionTypes.LIST_SORT__SUCCESS:
+      case ActionTypes.LIST_SORT_HANDLE:
         List.upsert(payload.list);
 
         break;

client/src/sagas/core/services/lists.js

@@ -70,6 +70,30 @@ export function* moveList(id, index) {
   });
 }
 
+// TODO: sort locally
+export function* sortList(id, data) {
+  yield put(actions.sortList(id, data));
+
+  let list;
+  let cards;
+
+  try {
+    ({
+      item: list,
+      included: { cards },
+    } = yield call(request, api.sortList, id, data));
+  } catch (error) {
+    yield put(actions.sortList.failure(id, error));
+    return;
+  }
+
+  yield put(actions.sortList.success(list, cards));
+}
+
+export function* handleListSort(list, cards) {
+  yield put(actions.handleListSort(list, cards));
+}
+
 export function* deleteList(id) {
   yield put(actions.deleteList(id));
 
@@ -95,6 +119,8 @@ export default {
   updateList,
   handleListUpdate,
   moveList,
+  sortList,
+  handleListSort,
   deleteList,
   handleListDelete,
 };

client/src/sagas/core/watchers/lists.js

@@ -20,6 +20,12 @@ export default function* listsWatchers() {
     takeEvery(EntryActionTypes.LIST_MOVE, ({ payload: { id, index } }) =>
       services.moveList(id, index),
     ),
+    takeEvery(EntryActionTypes.LIST_SORT, ({ payload: { id, data } }) =>
+      services.sortList(id, data),
+    ),
+    takeEvery(EntryActionTypes.LIST_SORT_HANDLE, ({ payload: { list, cards } }) =>
+      services.handleListSort(list, cards),
+    ),
     takeEvery(EntryActionTypes.LIST_DELETE, ({ payload: { id } }) => services.deleteList(id)),
     takeEvery(EntryActionTypes.LIST_DELETE_HANDLE, ({ payload: { list } }) =>
       services.handleListDelete(list),

client/src/sagas/core/watchers/socket.js

@@ -84,6 +84,10 @@ const createSocketEventsChannel = () =>
       emit(entryActions.handleListUpdate(item));
     };
 
+    const handleListSort = api.makeHandleListSort(({ item, included: { cards } }) => {
+      emit(entryActions.handleListSort(item, cards));
+    });
+
     const handleListDelete = ({ item }) => {
       emit(entryActions.handleListDelete(item));
     };
@@ -198,6 +202,7 @@ const createSocketEventsChannel = () =>
 
     socket.on('listCreate', handleListCreate);
     socket.on('listUpdate', handleListUpdate);
+    socket.on('listSort', handleListSort);
     socket.on('listDelete', handleListDelete);
 
     socket.on('labelCreate', handleLabelCreate);
@@ -256,6 +261,7 @@ const createSocketEventsChannel = () =>
 
       socket.off('listCreate', handleListCreate);
       socket.off('listUpdate', handleListUpdate);
+      socket.off('listSort', handleListSort);
       socket.off('listDelete', handleListDelete);
 
       socket.off('labelCreate', handleLabelCreate);

server/api/controllers/lists/sort.js

@@ -0,0 +1,65 @@
+const Errors = {
+  NOT_ENOUGH_RIGHTS: {
+    notEnoughRights: 'Not enough rights',
+  },
+  LIST_NOT_FOUND: {
+    listNotFound: 'List not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+    type: {
+      type: 'string',
+      isIn: Object.values(List.SortTypes),
+    },
+  },
+
+  exits: {
+    notEnoughRights: {
+      responseType: 'forbidden',
+    },
+    listNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    const { list } = await sails.helpers.lists
+      .getProjectPath(inputs.id)
+      .intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
+
+    const boardMembership = await BoardMembership.findOne({
+      boardId: list.boardId,
+      userId: currentUser.id,
+    });
+
+    if (!boardMembership) {
+      throw Errors.LIST_NOT_FOUND;
+    }
+
+    if (boardMembership.role !== BoardMembership.Roles.EDITOR) {
+      throw Errors.NOT_ENOUGH_RIGHTS;
+    }
+
+    const cards = await sails.helpers.lists.sortOne.with({
+      record: list,
+      type: inputs.type,
+      request: this.req,
+    });
+
+    return {
+      item: list,
+      included: {
+        cards,
+      },
+    };
+  },
+};

server/api/helpers/lists/sort-one.js

@@ -0,0 +1,70 @@
+const List = require('../../models/List');
+
+module.exports = {
+  inputs: {
+    record: {
+      type: 'ref',
+      required: true,
+    },
+    type: {
+      type: 'string',
+      isIn: Object.values(List.SortTypes),
+      defaultsTo: List.SortTypes.NAME_ASC,
+    },
+    request: {
+      type: 'ref',
+    },
+  },
+
+  async fn(inputs) {
+    let cards = await sails.helpers.lists.getCards(inputs.record.id);
+
+    switch (inputs.type) {
+      case List.SortTypes.NAME_ASC:
+        cards.sort((a, b) => a.name.localeCompare(b.name));
+        break;
+      case List.SortTypes.DUE_DATE_ASC:
+        cards.sort((a, b) => {
+          if (a.dueDate === null) return 1;
+          if (b.dueDate === null) return -1;
+          return new Date(a.dueDate) - new Date(b.dueDate);
+        });
+        break;
+      case List.SortTypes.CREATED_AT_ASC:
+        cards.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+        break;
+      case List.SortTypes.CREATED_AT_DESC:
+        cards.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+        break;
+      default:
+        throw new Error('Invalid sort type specified');
+    }
+
+    const positions = cards.map((c) => c.position).sort((a, b) => a - b);
+
+    cards = await Promise.all(
+      cards.map(({ id }, index) =>
+        Card.updateOne({
+          id,
+          listId: inputs.record.id,
+        }).set({
+          position: positions[index],
+        }),
+      ),
+    );
+
+    sails.sockets.broadcast(
+      `board:${inputs.record.boardId}`,
+      'listSort',
+      {
+        item: inputs.record,
+        included: {
+          cards,
+        },
+      },
+      inputs.request,
+    );
+
+    return cards;
+  },
+};

server/api/models/List.js

@@ -5,7 +5,16 @@
  * @docs        :: https://sailsjs.com/docs/concepts/models-and-orm/models
  */
 
+const SortTypes = {
+  NAME_ASC: 'name_asc',
+  DUE_DATE_ASC: 'dueDate_asc',
+  CREATED_AT_ASC: 'createdAt_asc',
+  CREATED_AT_DESC: 'createdAt_desc',
+};
+
 module.exports = {
+  SortTypes,
+
   attributes: {
     //  ╔═╗╦═╗╦╔╦╗╦╔╦╗╦╦  ╦╔═╗╔═╗
     //  ╠═╝╠╦╝║║║║║ ║ ║╚╗╔╝║╣ ╚═╗

server/config/routes.js

@@ -50,6 +50,7 @@ module.exports.routes = {
 
   'POST /api/boards/:boardId/lists': 'lists/create',
   'PATCH /api/lists/:id': 'lists/update',
+  'POST /api/lists/:id/sort': 'lists/sort',
   'DELETE /api/lists/:id': 'lists/delete',
 
   'POST /api/lists/:listId/cards': 'cards/create',