2971362371

Committed 01 Sep 2022 11:54AM UTC coverage: 42.192% (+0.6%) from 41.604%

Build Type

github

Committed by GitHub

Commit Message

Merge f8d72584b into 449ec7df8

Pull Request Pull Request #4054: Release/3.30.0

Run Details

1784 of 5210 branches covered (34.24%)

Branch coverage included in aggregate %.

101 of 272 new or added lines in 23 files covered. (37.13%)

41 existing lines in 3 files now uncovered.

4773 of 10331 relevant lines covered (46.2%)

39.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

19.48

/src/routes/safe/components/Apps/hooks/permissions/useSafePermissions.ts

import { Methods } from '@gnosis.pm/safe-apps-sdk'
import { Permission, PermissionCaveat, PermissionRequest } from '@gnosis.pm/safe-apps-sdk/dist/src/types/permissions'
import { useState, useCallback } from 'react'
import { PermissionStatus } from '../../types'
import { usePermissions } from './usePermissions'

const SAFE_PERMISSIONS = 'SAFE_PERMISSIONS'
const USER_RESTRICTED = 'userRestricted'

type SafePermissions = { [origin: string]: Permission[] }

type SafePermissionsRequest = {
  origin: string
  requestId: string
  request: PermissionRequest[]
}

type SafePermissionChangeSet = { capability: string; selected: boolean }[]

type UseSafePermissionsReturnType = {
  permissions: SafePermissions
  getPermissions: (origin: string) => Permission[]
  updatePermission: (origin: string, changeset: SafePermissionChangeSet) => void
  removePermissions: (origin: string) => void
  permissionsRequest: SafePermissionsRequest | undefined
  setPermissionsRequest: (permissionsRequest?: SafePermissionsRequest) => void
  confirmPermissionRequest: (result: PermissionStatus) => Permission[]
  hasPermission: (origin: string, permission: Methods) => boolean
  isUserRestricted: (caveats?: PermissionCaveat[]) => boolean
}

const useSafePermissions = (): UseSafePermissionsReturnType => {
  const [permissions, setPermissions] = usePermissions<SafePermissions>(SAFE_PERMISSIONS)
  const [permissionsRequest, setPermissionsRequest] = useState<SafePermissionsRequest | undefined>()

  const getPermissions = useCallback(
    (origin: string) => {
      return permissions[origin] || []
    },
    [permissions],
  )

  const updatePermission = useCallback(
    (origin: string, changeset: SafePermissionChangeSet) => {
      setPermissions({
        ...permissions,
        [origin]: permissions[origin].map((permission) => {
          const change = changeset.find((change) => change.capability === permission.parentCapability)

          if (change) {
            if (change.selected) {
              permission.caveats = permission.caveats?.filter((caveat) => caveat.type !== USER_RESTRICTED) || []
            } else if (!isUserRestricted(permission.caveats)) {
              permission.caveats = [
                ...(permission.caveats || []),
                {
                  type: USER_RESTRICTED,
                  value: true,
                },
              ]
            }
          }

          return permission
        }),
      })
    },
    [permissions, setPermissions],
  )

  const removePermissions = useCallback(
    (origin: string) => {
      delete permissions[origin]
      setPermissions({ ...permissions })
    },
    [permissions, setPermissions],
  )

  const hasPermission = useCallback(
    (origin: string, permission: Methods) => {
      return permissions[origin]?.some((p) => p.parentCapability === permission && !isUserRestricted(p.caveats))
    },
    [permissions],
  )

  const hasCapability = useCallback(
    (origin: string, permission: Methods) => {
      return permissions[origin]?.some((p) => p.parentCapability === permission)
    },
    [permissions],
  )

  const confirmPermissionRequest = useCallback(
    (result) => {
      if (!permissionsRequest) return []

      const updatedPermissionsByOrigin = [...(permissions[permissionsRequest.origin] || [])]

      permissionsRequest.request.forEach((requestedPermission) => {
        const capability = Object.keys(requestedPermission)[0]

        if (hasCapability(permissionsRequest.origin, capability as Methods)) {
          updatedPermissionsByOrigin.map((permission) => {
            if (permission.parentCapability === capability) {
              if (isUserRestricted(permission.caveats)) {
                if (result === PermissionStatus.GRANTED) {
                  permission.caveats = permission.caveats?.filter((caveat) => caveat.type !== USER_RESTRICTED) || []
                }
              } else {
                if (result === PermissionStatus.DENIED) {
                  permission.caveats?.push({
                    type: USER_RESTRICTED,
                    value: true,
                  })
                }
              }
            }
          })
        } else {
          updatedPermissionsByOrigin.push({
            invoker: permissionsRequest.origin,
            parentCapability: capability,
            date: new Date().getTime(),
            caveats:
              result === PermissionStatus.DENIED
                ? [
                    {
                      type: USER_RESTRICTED,
                      value: true,
                    },
                  ]
                : [],
          })
        }
      })

      setPermissions({
        ...permissions,
        [permissionsRequest.origin]: updatedPermissionsByOrigin,
      })
      setPermissionsRequest(undefined)

      return updatedPermissionsByOrigin
    },
    [permissionsRequest, permissions, setPermissions, hasCapability],
  )

  const isUserRestricted = (caveats?: PermissionCaveat[]) =>
    !!caveats?.some((caveat) => caveat.type === USER_RESTRICTED && caveat.value === true)

  return {
    permissions,
    isUserRestricted,
    getPermissions,
    updatePermission,
    removePermissions,
    permissionsRequest,
    setPermissionsRequest,
    confirmPermissionRequest,
    hasPermission,
  }
}

export { useSafePermissions }

1	import { Methods } from '@gnosis.pm/safe-apps-sdk'
2	import { Permission, PermissionCaveat, PermissionRequest } from '@gnosis.pm/safe-apps-sdk/dist/src/types/permissions'
3	import { useState, useCallback } from 'react'
4	import { PermissionStatus } from '../../types'
5	import { usePermissions } from './usePermissions'
6
7	const SAFE_PERMISSIONS = 'SAFE_PERMISSIONS'	4✔
8	const USER_RESTRICTED = 'userRestricted'	4✔
9
10	type SafePermissions = { [origin: string]: Permission[] }
11
12	type SafePermissionsRequest = {
13	origin: string
14	requestId: string
15	request: PermissionRequest[]
16	}
17
18	type SafePermissionChangeSet = { capability: string; selected: boolean }[]
19
20	type UseSafePermissionsReturnType = {
21	permissions: SafePermissions
22	getPermissions: (origin: string) => Permission[]
23	updatePermission: (origin: string, changeset: SafePermissionChangeSet) => void
24	removePermissions: (origin: string) => void
25	permissionsRequest: SafePermissionsRequest \| undefined
26	setPermissionsRequest: (permissionsRequest?: SafePermissionsRequest) => void
27	confirmPermissionRequest: (result: PermissionStatus) => Permission[]
28	hasPermission: (origin: string, permission: Methods) => boolean
29	isUserRestricted: (caveats?: PermissionCaveat[]) => boolean
30	}
31
32	const useSafePermissions = (): UseSafePermissionsReturnType => {	4✔
33	const [permissions, setPermissions] = usePermissions<SafePermissions>(SAFE_PERMISSIONS)	272✔
34	const [permissionsRequest, setPermissionsRequest] = useState<SafePermissionsRequest \| undefined>()	272✔
35
36	const getPermissions = useCallback(	272✔
37	(origin: string) => {
NEW 38	return permissions[origin] \|\| []	×
39	},
40	[permissions],
41	)
42
43	const updatePermission = useCallback(	272✔
44	(origin: string, changeset: SafePermissionChangeSet) => {
NEW 45	setPermissions({	×
46	...permissions,
47	[origin]: permissions[origin].map((permission) => {
NEW 48	const change = changeset.find((change) => change.capability === permission.parentCapability)	×
49
NEW 50	if (change) {	×
NEW 51	if (change.selected) {	×
NEW 52	permission.caveats = permission.caveats?.filter((caveat) => caveat.type !== USER_RESTRICTED) \|\| []	×
NEW 53	} else if (!isUserRestricted(permission.caveats)) {	×
NEW 54	permission.caveats = [	×
55	...(permission.caveats \|\| []),	×
56	{
57	type: USER_RESTRICTED,
58	value: true,
59	},
60	]
61	}
62	}
63
NEW 64	return permission	×
65	}),
66	})
67	},
68	[permissions, setPermissions],
69	)
70
71	const removePermissions = useCallback(	272✔
72	(origin: string) => {
73	delete permissions[origin]	1✔
74	setPermissions({ ...permissions })	1✔
75	},
76	[permissions, setPermissions],
77	)
78
79	const hasPermission = useCallback(	272✔
80	(origin: string, permission: Methods) => {
NEW 81	return permissions[origin]?.some((p) => p.parentCapability === permission && !isUserRestricted(p.caveats))	×
82	},
83	[permissions],
84	)
85
86	const hasCapability = useCallback(	272✔
87	(origin: string, permission: Methods) => {
NEW 88	return permissions[origin]?.some((p) => p.parentCapability === permission)	×
89	},
90	[permissions],
91	)
92
93	const confirmPermissionRequest = useCallback(	272✔
94	(result) => {
NEW 95	if (!permissionsRequest) return []	×
96
NEW 97	const updatedPermissionsByOrigin = [...(permissions[permissionsRequest.origin] \|\| [])]	×
98
NEW 99	permissionsRequest.request.forEach((requestedPermission) => {	×
NEW 100	const capability = Object.keys(requestedPermission)[0]	×
101
NEW 102	if (hasCapability(permissionsRequest.origin, capability as Methods)) {	×
NEW 103	updatedPermissionsByOrigin.map((permission) => {	×
NEW 104	if (permission.parentCapability === capability) {	×
NEW 105	if (isUserRestricted(permission.caveats)) {	×
NEW 106	if (result === PermissionStatus.GRANTED) {	×
NEW 107	permission.caveats = permission.caveats?.filter((caveat) => caveat.type !== USER_RESTRICTED) \|\| []	×
108	}
109	} else {
NEW 110	if (result === PermissionStatus.DENIED) {	×
NEW 111	permission.caveats?.push({	×
112	type: USER_RESTRICTED,
113	value: true,
114	})
115	}
116	}
117	}
118	})
119	} else {
NEW 120	updatedPermissionsByOrigin.push({	×
121	invoker: permissionsRequest.origin,
122	parentCapability: capability,
123	date: new Date().getTime(),
124	caveats:
125	result === PermissionStatus.DENIED	×
126	? [
127	{
128	type: USER_RESTRICTED,
129	value: true,
130	},
131	]
132	: [],
133	})
134	}
135	})
136
NEW 137	setPermissions({	×
138	...permissions,
139	[permissionsRequest.origin]: updatedPermissionsByOrigin,
140	})
NEW 141	setPermissionsRequest(undefined)	×
142
NEW 143	return updatedPermissionsByOrigin	×
144	},
145	[permissionsRequest, permissions, setPermissions, hasCapability],
146	)
147
148	const isUserRestricted = (caveats?: PermissionCaveat[]) =>	272✔
NEW 149	!!caveats?.some((caveat) => caveat.type === USER_RESTRICTED && caveat.value === true)	×
150
151	return {	272✔
152	permissions,
153	isUserRestricted,
154	getPermissions,
155	updatePermission,
156	removePermissions,
157	permissionsRequest,
158	setPermissionsRequest,
159	confirmPermissionRequest,
160	hasPermission,
161	}
162	}
163
164	export { useSafePermissions }

safe-global / safe-react / 2971362371

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous