cozy-sharing 40.1.6 → 40.1.8

package/src/helpers/contacts.js

@@ -1,5 +1,10 @@
+import { models } from 'cozy-client'
+import flag from 'cozy-flags'
+
 import { validateEmail } from '../helpers/email'
 
+const ContactModel = models.contact
+
 // Return the contact object if present
 // Else check if a contact exist with this email address, if yes return it
 // if not create it
@@ -59,3 +64,81 @@ export const getContactsFromGroupId = (contacts = [], groupId) => {
 export const isContactToBeCreated = contact => {
   return !contact._id
 }
+
+const isCurrentUser = contact => contact.me === true
+
+/**
+ * Computes the contacts and groups to suggest when adding recipients to a
+ * sharing. The unreachable contacts only count in the members of the groups,
+ * when flag sharing.show-recipient-groups is enabled.
+ *
+ * @param {object} params
+ * @param {object[]} params.reachableContacts - Contacts that can be shared with
+ * @param {object[]} params.unreachableContactsWithGroups - Contacts that cannot be shared with but belong to a group
+ * @param {object[]} params.contactGroups - Groups of contacts
+ * @param {object[]} params.currentRecipients - Recipients already in the sharing
+ * @param {object[]} params.pendingRecipients - Recipients picked but not yet shared with
+ * @returns {object[]} The contacts, then the groups with their members
+ */
+export const computeContactsAndGroups = ({
+  reachableContacts,
+  unreachableContactsWithGroups,
+  contactGroups,
+  currentRecipients,
+  pendingRecipients
+}) => {
+  const suggestedContacts = reachableContacts.filter(
+    contact =>
+      !isCurrentUser(contact) &&
+      // We do not want contact already in the sharing
+      !currentRecipients.find(
+        r => r.email === ContactModel.getPrimaryEmail(contact)
+      ) &&
+      // We do not want contact currently in pending contacts (in chips)
+      !pendingRecipients.find(r => r._id === contact._id)
+  )
+
+  const unreachableContacts = unreachableContactsWithGroups.filter(
+    contact => !isCurrentUser(contact)
+  )
+  const currentRecipientGroups = currentRecipients
+    .map(({ id }) => id)
+    .filter(Boolean)
+  const suggestedGroups = contactGroups
+    .filter(
+      ({ _id }) =>
+        !flag('sharing.show-recipient-groups') ||
+        !currentRecipientGroups.includes(_id)
+    )
+    .map(contactGroup => {
+      const reachableMembers = getContactsFromGroupId(
+        suggestedContacts,
+        contactGroup.id
+      ).map(contact => ({
+        ...contact,
+        isReachable: true
+      }))
+
+      if (flag('sharing.show-recipient-groups') !== true) {
+        return {
+          ...contactGroup,
+          members: reachableMembers
+        }
+      }
+
+      const unreachableMembers = getContactsFromGroupId(
+        unreachableContacts,
+        contactGroup.id
+      ).map(contact => ({
+        ...contact,
+        isReachable: false
+      }))
+
+      return {
+        ...contactGroup,
+        members: [...reachableMembers, ...unreachableMembers]
+      }
+    })
+
+  return [...suggestedContacts, ...suggestedGroups]
+}

package/src/helpers/contacts.spec.js

@@ -1,4 +1,11 @@
-import { getOrCreateFromArray } from './contacts'
+import flag from 'cozy-flags'
+
+import { computeContactsAndGroups, getOrCreateFromArray } from './contacts'
+
+jest.mock('cozy-flags', () => ({
+  __esModule: true,
+  default: jest.fn(() => null)
+}))
 
 const findMock = jest
   .fn()
@@ -51,3 +58,73 @@ describe('getOrCreateFromArray', () => {
     ])
   })
 })
+
+describe('computeContactsAndGroups', () => {
+  const group = { id: 'friends', _id: 'friends', name: 'Friends' }
+  const inGroup = { relationships: { groups: { data: [{ _id: 'friends' }] } } }
+  const alice = {
+    _id: 'alice',
+    email: [{ address: 'alice@cozy.cc', primary: true }],
+    ...inGroup
+  }
+  const bob = { _id: 'bob', email: [{ address: 'bob@cozy.cc' }], ...inGroup }
+  const me = { _id: 'me', me: true, ...inGroup }
+  const carol = { _id: 'carol', ...inGroup }
+
+  const setup = ({
+    currentRecipients = [],
+    pendingRecipients = [],
+    showRecipientGroups = null
+  } = {}) => {
+    flag.mockReturnValue(showRecipientGroups)
+    return computeContactsAndGroups({
+      reachableContacts: [alice, bob, me],
+      unreachableContactsWithGroups: [carol, me],
+      contactGroups: [group],
+      currentRecipients,
+      pendingRecipients
+    })
+  }
+
+  it('suggests the contacts, then the groups with their reachable members', () => {
+    const [first, second, friends] = setup()
+
+    expect([first._id, second._id, friends._id]).toEqual([
+      'alice',
+      'bob',
+      'friends'
+    ])
+    expect(friends.members.map(m => [m._id, m.isReachable])).toEqual([
+      ['alice', true],
+      ['bob', true]
+    ])
+  })
+
+  it('does not suggest the recipients already shared with or picked', () => {
+    const contactsAndGroups = setup({
+      currentRecipients: [{ email: 'alice@cozy.cc' }],
+      pendingRecipients: [bob]
+    })
+
+    expect(contactsAndGroups.map(c => c._id)).toEqual(['friends'])
+  })
+
+  it('adds the unreachable members when flag sharing.show-recipient-groups is enabled', () => {
+    const [, , friends] = setup({ showRecipientGroups: true })
+
+    expect(friends.members.map(m => [m._id, m.isReachable])).toEqual([
+      ['alice', true],
+      ['bob', true],
+      ['carol', false]
+    ])
+  })
+
+  it('does not suggest the groups already in the sharing when flag sharing.show-recipient-groups is enabled', () => {
+    const contactsAndGroups = setup({
+      currentRecipients: [{ id: 'friends' }],
+      showRecipientGroups: true
+    })
+
+    expect(contactsAndGroups.map(c => c._id)).toEqual(['alice', 'bob'])
+  })
+})

package/src/helpers/recipients.js

@@ -99,3 +99,47 @@ export const getGroupRecipientSecondaryText = ({
     (isUserInsideMembers ? ` (${t('GroupRecipient.secondary_you')})` : '')
   )
 }
+
+const isInstance = (recipient, instanceUri) =>
+  recipient.instance !== undefined && recipient.instance === instanceUri
+
+/**
+ * Flags with `isCurrentUser` the recipients, and the members of group
+ * recipients, whose instance is the current user's one
+ *
+ * @param {object[]} recipients - Recipients of a sharing
+ * @param {string} instanceUri - URI of the current user's instance
+ * @returns {object[]} The recipients with their `isCurrentUser` flag
+ */
+export const markCurrentUser = (recipients, instanceUri) =>
+  recipients.map(recipient => ({
+    ...recipient,
+    isCurrentUser: isInstance(recipient, instanceUri),
+    ...(recipient.members && {
+      members: recipient.members.map(member => ({
+        ...member,
+        isCurrentUser: isInstance(member, instanceUri)
+      }))
+    })
+  }))
+
+/**
+ * @param {object} params
+ * @param {string} params.status - Status of the member in the sharing
+ * @param {boolean} params.isCurrentUser - Whether the member is the current user
+ * @param {boolean} params.isOwner - Whether the current user owns the sharing
+ * @param {boolean} params.canManageSharing - Whether the current user can manage the sharing
+ * @param {boolean} params.canManageMembers - Whether the members can be managed
+ * @returns {boolean} Whether the current user can change the member's
+ * permission type or revoke them
+ */
+export const hasMemberActions = ({
+  status,
+  isCurrentUser,
+  isOwner,
+  canManageSharing,
+  canManageMembers
+}) =>
+  canManageMembers &&
+  status !== 'owner' &&
+  ((isCurrentUser && !isOwner) || canManageSharing)

package/src/helpers/recipients.spec.js

@@ -0,0 +1,82 @@
+import { hasMemberActions, markCurrentUser } from './recipients'
+
+const instanceUri = 'https://alice.cozy.cc'
+
+describe('markCurrentUser', () => {
+  it('flags the recipient whose instance is the current one', () => {
+    const recipients = [
+      { email: 'alice@cozy.cc', instance: instanceUri },
+      { email: 'bob@cozy.cc', instance: 'https://bob.cozy.cc' },
+      { email: 'carol@cozy.cc' }
+    ]
+
+    expect(
+      markCurrentUser(recipients, instanceUri).map(r => r.isCurrentUser)
+    ).toEqual([true, false, false])
+  })
+
+  it('does not flag a recipient without instance when the instance is unknown', () => {
+    expect(markCurrentUser([{ email: 'carol@cozy.cc' }], undefined)).toEqual([
+      { email: 'carol@cozy.cc', isCurrentUser: false }
+    ])
+  })
+
+  it('flags the members of group recipients', () => {
+    const recipients = [
+      {
+        name: 'Team',
+        members: [
+          { instance: 'https://bob.cozy.cc' },
+          { instance: instanceUri }
+        ]
+      }
+    ]
+
+    const [group] = markCurrentUser(recipients, instanceUri)
+
+    expect(group.isCurrentUser).toBe(false)
+    expect(group.members.map(m => m.isCurrentUser)).toEqual([false, true])
+  })
+})
+
+describe('hasMemberActions', () => {
+  const ownerRights = {
+    isOwner: true,
+    canManageSharing: true,
+    canManageMembers: true
+  }
+  const memberRights = {
+    isOwner: false,
+    canManageSharing: false,
+    canManageMembers: true
+  }
+
+  it('gives actions on the members to whom can manage the sharing', () => {
+    expect(hasMemberActions({ ...ownerRights, status: 'ready' })).toBe(true)
+  })
+
+  it('gives no action on the owner', () => {
+    expect(hasMemberActions({ ...ownerRights, status: 'owner' })).toBe(false)
+  })
+
+  it('gives no action when the members cannot be managed', () => {
+    expect(
+      hasMemberActions({
+        ...ownerRights,
+        canManageMembers: false,
+        status: 'ready'
+      })
+    ).toBe(false)
+  })
+
+  it('gives actions on themselves to a member who cannot manage the sharing', () => {
+    expect(
+      hasMemberActions({
+        ...memberRights,
+        status: 'ready',
+        isCurrentUser: true
+      })
+    ).toBe(true)
+    expect(hasMemberActions({ ...memberRights, status: 'ready' })).toBe(false)
+  })
+})

package/src/hooks/useMemberPermissionType.js

@@ -0,0 +1,110 @@
+import { useCallback } from 'react'
+
+import { useClient } from 'cozy-client'
+import flag from 'cozy-flags'
+
+import { useFetchDocumentPath } from './useFetchDocumentPath'
+import { useResolveRecipients } from './useResolveRecipients'
+import { useSharingContext } from './useSharingContext'
+import { getSharingDocIds } from '../state'
+
+/**
+ * Gives what is needed to change the permission type of the members
+ * of a document's sharing
+ *
+ * @param {object} document - Shared document
+ * @param {object} [options]
+ * @param {boolean} [options.shouldFetchPath] - Whether to fetch the document
+ * path, needed to know the shared parent
+ * @returns {{ isInsideSharedParent: boolean, sharedParentName: string|null, setMemberType: Function }}
+ * `setMemberType({ sharingId, memberIndex, type, recipient }, newType, { withAncestors })`
+ * also downgrades the member on the read-write ancestor sharings when `withAncestors` is set
+ */
+export const useMemberPermissionType = (
+  document,
+  { shouldFetchPath = true } = {}
+) => {
+  const client = useClient()
+  const {
+    hasSharedParent,
+    getSharedParentPath,
+    updateSharingMemberType,
+    getSharingById,
+    share
+  } = useSharingContext()
+  const resolveRecipients = useResolveRecipients()
+
+  const documentPath = useFetchDocumentPath(
+    client,
+    shouldFetchPath ? document : null
+  )
+  const isInsideSharedParent =
+    Boolean(documentPath) && Boolean(hasSharedParent?.(documentPath))
+  const sharedParentPath = documentPath
+    ? getSharedParentPath?.(documentPath)
+    : null
+
+  const setMemberType = useCallback(
+    async (
+      { sharingId, memberIndex, type, recipient },
+      newType,
+      { withAncestors = false } = {}
+    ) => {
+      if (withAncestors) {
+        // Ancestors first: only the target's own update refetches its
+        // effective recipients, which must already see them downgraded.
+        const ancestors = (recipient?.sources || []).filter(
+          s => s.kind === 'ancestor' && !s.read_only
+        )
+        for (const ancestor of ancestors) {
+          await updateSharingMemberType(
+            ancestor.sharing_id,
+            ancestor.member_index,
+            newType
+          )
+        }
+      }
+
+      const documentId = document?._id || document?.id
+      if (
+        flag('drive.federated-shared-folder.enabled') &&
+        type === 'one-way' &&
+        newType === 'two-way' &&
+        documentId
+      ) {
+        const sourceSharing = getSharingById(sharingId)
+        if (
+          sourceSharing &&
+          !getSharingDocIds(sourceSharing).includes(documentId)
+        ) {
+          const { recipients } = await resolveRecipients([recipient])
+          if (!recipients[0]) throw new Error('Recipient contact not found')
+          await share({
+            document: { ...document, id: documentId },
+            description: document.name,
+            recipients,
+            readOnlyRecipients: [],
+            sharedDrive: true,
+            openSharing: false
+          })
+          return
+        }
+      }
+
+      await updateSharingMemberType(sharingId, memberIndex, newType, document)
+    },
+    [
+      document,
+      getSharingById,
+      resolveRecipients,
+      share,
+      updateSharingMemberType
+    ]
+  )
+
+  return {
+    isInsideSharedParent,
+    sharedParentName: sharedParentPath?.split('/').pop() ?? null,
+    setMemberType
+  }
+}

package/src/hooks/useResolveRecipients.js

@@ -0,0 +1,38 @@
+import { useCallback } from 'react'
+
+import { useClient } from 'cozy-client'
+
+import { getOrCreateFromArray } from '../helpers/contacts'
+import { DOCTYPE_CONTACTS } from '../models'
+
+/**
+ * Turns the recipients picked in a sharing form into contacts, creating the
+ * missing ones, and splits them by the selected sharing right.
+ *
+ * @returns {Function} `resolveRecipients(pendingRecipients, selectedOption, createContact?)`
+ * resolving to `{ recipients, readOnlyRecipients }`, ready to be passed to `share`
+ */
+export const useResolveRecipients = () => {
+  const client = useClient()
+
+  return useCallback(
+    async (
+      pendingRecipients,
+      selectedOption = 'readWrite',
+      createContact = contact => client.create(DOCTYPE_CONTACTS, contact)
+    ) => {
+      const contacts = await getOrCreateFromArray(
+        client,
+        pendingRecipients,
+        createContact
+      )
+      const isReadOnly = selectedOption === 'readOnly'
+
+      return {
+        recipients: isReadOnly ? [] : contacts,
+        readOnlyRecipients: isReadOnly ? contacts : []
+      }
+    },
+    [client]
+  )
+}

package/src/hooks/useResolveRecipients.spec.js

@@ -0,0 +1,70 @@
+import { renderHook } from '@testing-library/react-hooks'
+
+import { useResolveRecipients } from './useResolveRecipients'
+import { getOrCreateFromArray } from '../helpers/contacts'
+
+const mockClient = { create: jest.fn() }
+
+jest.mock('cozy-client', () => ({
+  useClient: () => mockClient
+}))
+
+jest.mock('../helpers/contacts', () => ({
+  getOrCreateFromArray: jest.fn()
+}))
+
+const contacts = [{ _id: 'alice' }, { _id: 'bob' }]
+
+describe('useResolveRecipients', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    getOrCreateFromArray.mockResolvedValue(contacts)
+  })
+
+  it('gives read-write rights by default', async () => {
+    const { result } = renderHook(() => useResolveRecipients())
+
+    const resolved = await result.current([{ email: 'alice@cozy.cc' }])
+
+    expect(resolved).toEqual({ recipients: contacts, readOnlyRecipients: [] })
+  })
+
+  it('gives read-only rights when the read-only option is selected', async () => {
+    const { result } = renderHook(() => useResolveRecipients())
+
+    const resolved = await result.current([], 'readOnly')
+
+    expect(resolved).toEqual({ recipients: [], readOnlyRecipients: contacts })
+  })
+
+  it('creates missing contacts with the client by default', async () => {
+    const { result } = renderHook(() => useResolveRecipients())
+    const pendingRecipients = [{ email: 'alice@cozy.cc' }]
+
+    await result.current(pendingRecipients)
+    const createContact = getOrCreateFromArray.mock.calls[0][2]
+    createContact({ email: [{ address: 'alice@cozy.cc' }] })
+
+    expect(getOrCreateFromArray).toHaveBeenCalledWith(
+      mockClient,
+      pendingRecipients,
+      expect.any(Function)
+    )
+    expect(mockClient.create).toHaveBeenCalledWith('io.cozy.contacts', {
+      email: [{ address: 'alice@cozy.cc' }]
+    })
+  })
+
+  it('creates missing contacts with the given function', async () => {
+    const { result } = renderHook(() => useResolveRecipients())
+    const createContact = jest.fn()
+
+    await result.current([], 'readWrite', createContact)
+
+    expect(getOrCreateFromArray).toHaveBeenCalledWith(
+      mockClient,
+      [],
+      createContact
+    )
+  })
+})

package/src/index.jsx

@@ -36,7 +36,7 @@ export { ShareButtonWithRecipients } from './ShareButtonWithRecipients'
 export { DOCUMENT_TYPE } from './helpers/documentType'
 export { getRecipientsFromSharing } from './state'
 export { default as OpenSharingLinkButton } from './OpenSharingLinkButton'
-export { PermissionTypeMenu } from './components/Recipient/PermissionTypeMenu'
+export { default as PermissionTypeMenu } from './components/Recipient/PermissionTypeMenuWrapper'
 export { default as OpenSharingLinkFabButton } from './OpenSharingLinkFabButton'
 export {
   NativeFileSharingProvider,

package/dist/components/Recipient/OwnerRecipientDefault.js

@@ -1,27 +0,0 @@
-import React from 'react';
-import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client';
-import MemberRecipient from './MemberRecipient';
-import { buildInstanceSettingsQuery } from '../../queries/queries'; // When the owner is not part of a sharing's members (eg. the folder only has
-// a link), there is no per-sharing avatar to reference. The instance's public
-// avatar still holds the owner's picture. fallback=initials makes the stack
-// serve a generated initials avatar (instead of the app icon) when no picture
-// has been uploaded, matching how avatars are rendered everywhere else.
-
-var OWNER_PUBLIC_AVATAR_PATH = '/public/avatar?fallback=initials';
-
-var OwnerRecipientDefault = function OwnerRecipientDefault() {
-  var _instanceSettingsResu;
-
-  var client = useClient();
-  var instanceSettingsQuery = buildInstanceSettingsQuery();
-  var instanceSettingsResult = useQuery(instanceSettingsQuery.definition, instanceSettingsQuery.options);
-  return hasQueryBeenLoaded(instanceSettingsResult) && /*#__PURE__*/React.createElement(MemberRecipient, {
-    isOwner: true,
-    status: "owner",
-    instance: client.options.uri,
-    avatarPath: OWNER_PUBLIC_AVATAR_PATH,
-    public_name: instanceSettingsResult === null || instanceSettingsResult === void 0 || (_instanceSettingsResu = instanceSettingsResult.data) === null || _instanceSettingsResu === void 0 || (_instanceSettingsResu = _instanceSettingsResu.attributes) === null || _instanceSettingsResu === void 0 ? void 0 : _instanceSettingsResu.public_name
-  });
-};
-
-export default OwnerRecipientDefault;

package/dist/components/Recipient/OwnerRecipientDefault.stories.js

@@ -1,10 +0,0 @@
-import OwnerRecipientDefault from './OwnerRecipientDefault';
-var meta = {
-  component: OwnerRecipientDefault,
-  args: {}
-};
-export default meta;
-export var Default = {
-  name: 'Default',
-  args: {}
-};

package/src/components/Recipient/OwnerRecipientDefault.jsx

@@ -1,37 +0,0 @@
-import React from 'react'
-
-import { useClient, useQuery, hasQueryBeenLoaded } from 'cozy-client'
-
-import MemberRecipient from './MemberRecipient'
-import { buildInstanceSettingsQuery } from '../../queries/queries'
-
-// When the owner is not part of a sharing's members (eg. the folder only has
-// a link), there is no per-sharing avatar to reference. The instance's public
-// avatar still holds the owner's picture. fallback=initials makes the stack
-// serve a generated initials avatar (instead of the app icon) when no picture
-// has been uploaded, matching how avatars are rendered everywhere else.
-const OWNER_PUBLIC_AVATAR_PATH = '/public/avatar?fallback=initials'
-
-const OwnerRecipientDefault = () => {
-  const client = useClient()
-
-  const instanceSettingsQuery = buildInstanceSettingsQuery()
-  const instanceSettingsResult = useQuery(
-    instanceSettingsQuery.definition,
-    instanceSettingsQuery.options
-  )
-
-  return (
-    hasQueryBeenLoaded(instanceSettingsResult) && (
-      <MemberRecipient
-        isOwner={true}
-        status="owner"
-        instance={client.options.uri}
-        avatarPath={OWNER_PUBLIC_AVATAR_PATH}
-        public_name={instanceSettingsResult?.data?.attributes?.public_name}
-      />
-    )
-  )
-}
-
-export default OwnerRecipientDefault

package/src/components/Recipient/OwnerRecipientDefault.stories.jsx

@@ -1,13 +0,0 @@
-import OwnerRecipientDefault from './OwnerRecipientDefault'
-
-const meta = {
-  component: OwnerRecipientDefault,
-  args: {}
-}
-
-export default meta
-
-export const Default = {
-  name: 'Default',
-  args: {}
-}