{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TemplateHaskell #-}

-- This file is part of the Wire Server implementation.
--
-- Copyright (C) 2022 Wire Swiss GmbH <opensource@wire.com>
--
-- This program is free software: you can redistribute it and/or modify it under
-- the terms of the GNU Affero General Public License as published by the Free
-- Software Foundation, either version 3 of the License, or (at your option) any
-- later version.
--
-- This program is distributed in the hope that it will be useful, but WITHOUT
-- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-- details.
--
-- You should have received a copy of the GNU Affero General Public License along
-- with this program. If not, see <https://www.gnu.org/licenses/>.

module Wire.API.Team.Member
  ( -- * TeamMember
    TeamMember,
    newTeamMember,
    mkTeamMember,
    userId,
    permissions,
    invitation,
    legalHoldStatus,
    ntmNewTeamMember,
    setOptionalPerms,
    setOptionalPermsMany,
    teamMemberObjectSchema,

    -- * TeamMemberList
    TeamMemberList,
    TeamMemberListOptPerms,
    TeamMembersPage (..),
    TeamMembersPagingState,
    teamMemberPagingState,
    newTeamMemberList,
    teamMembers,
    teamMemberListType,
    HardTruncationLimit,
    hardTruncationLimit,
    NewListType (..),
    toNewListType,
    ListType (..),

    -- * NewTeamMember
    NewTeamMember,
    TeamMemberOptPerms,
    mkNewTeamMember,
    nUserId,
    nPermissions,
    optionalPermissions,
    nInvitation,

    -- * TeamMemberDeleteData
    TeamMemberDeleteData,
    newTeamMemberDeleteData,
    tmdAuthPassword,

    -- * Permissions
    isAdminOrOwner,
    permissionsRole,
    rolePermissions,
    IsPerm (..),
    HiddenPerm (..),
  )
where

import Cassandra (PageWithState (..))
import Cassandra qualified as C
import Control.Lens (Lens, Lens', makeLenses, (%~), (?~), (^.))
import Data.Aeson (FromJSON (..), ToJSON (..), Value (..))
import Data.ByteString.Lazy qualified as LBS
import Data.Id (UserId)
import Data.Json.Util
import Data.Kind
import Data.LegalHold (UserLegalHoldStatus (..), defUserLegalHoldStatus)
import Data.Misc (PlainTextPassword6)
import Data.OpenApi (ToParamSchema (..))
import Data.OpenApi.Schema qualified as S
import Data.Proxy
import Data.Schema
import Data.Set qualified as Set
import Imports
import Wire.API.Error.Galley
import Wire.API.Routes.MultiTablePaging (MultiTablePage (..))
import Wire.API.Routes.MultiTablePaging.State
import Wire.API.Team.HardTruncationLimit
import Wire.API.Team.Permission
import Wire.API.Team.Role
import Wire.Arbitrary (Arbitrary, GenericUniform (..))

data PermissionTag = Required | Optional

type family PermissionType (tag :: PermissionTag) = (t :: Type) | t -> tag where
  PermissionType 'Required = Permissions
  PermissionType 'Optional = Maybe Permissions

--------------------------------------------------------------------------------
-- TeamMember

type TeamMember = TeamMember' 'Required

type TeamMemberOptPerms = TeamMember' 'Optional

data TeamMember' (tag :: PermissionTag) = TeamMember
  { forall (tag :: PermissionTag).
TeamMember' tag -> NewTeamMember' tag
_newTeamMember :: NewTeamMember' tag,
    forall (tag :: PermissionTag).
TeamMember' tag -> UserLegalHoldStatus
_legalHoldStatus :: UserLegalHoldStatus
  }
  deriving stock ((forall x. TeamMember' tag -> Rep (TeamMember' tag) x)
-> (forall x. Rep (TeamMember' tag) x -> TeamMember' tag)
-> Generic (TeamMember' tag)
forall x. Rep (TeamMember' tag) x -> TeamMember' tag
forall x. TeamMember' tag -> Rep (TeamMember' tag) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (tag :: PermissionTag) x.
Rep (TeamMember' tag) x -> TeamMember' tag
forall (tag :: PermissionTag) x.
TeamMember' tag -> Rep (TeamMember' tag) x
$cfrom :: forall (tag :: PermissionTag) x.
TeamMember' tag -> Rep (TeamMember' tag) x
from :: forall x. TeamMember' tag -> Rep (TeamMember' tag) x
$cto :: forall (tag :: PermissionTag) x.
Rep (TeamMember' tag) x -> TeamMember' tag
to :: forall x. Rep (TeamMember' tag) x -> TeamMember' tag
Generic)

ntmNewTeamMember :: NewTeamMember' tag -> TeamMember' tag
ntmNewTeamMember :: forall (tag :: PermissionTag).
NewTeamMember' tag -> TeamMember' tag
ntmNewTeamMember NewTeamMember' tag
ntm = NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
forall (tag :: PermissionTag).
NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
TeamMember NewTeamMember' tag
ntm UserLegalHoldStatus
defUserLegalHoldStatus

deriving instance (Eq (PermissionType tag)) => Eq (TeamMember' tag)

deriving instance (Ord (PermissionType tag)) => Ord (TeamMember' tag)

deriving instance (Show (PermissionType tag)) => Show (TeamMember' tag)

deriving via (GenericUniform TeamMember) instance Arbitrary TeamMember

deriving via (GenericUniform (TeamMember' 'Optional)) instance Arbitrary (TeamMember' 'Optional)

deriving via
  (Schema (TeamMember' tag))
  instance
    (ToSchema (TeamMember' tag)) =>
    ToJSON (TeamMember' tag)

deriving via
  (Schema (TeamMember' tag))
  instance
    (ToSchema (TeamMember' tag)) =>
    FromJSON (TeamMember' tag)

deriving via
  (Schema (TeamMember' tag))
  instance
    (ToSchema (TeamMember' tag), Typeable tag) =>
    S.ToSchema (TeamMember' tag)

mkTeamMember ::
  UserId ->
  PermissionType tag ->
  Maybe (UserId, UTCTimeMillis) ->
  UserLegalHoldStatus ->
  TeamMember' tag
mkTeamMember :: forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> UserLegalHoldStatus
-> TeamMember' tag
mkTeamMember UserId
uid PermissionType tag
perms Maybe (UserId, UTCTimeMillis)
inv = NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
forall (tag :: PermissionTag).
NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
TeamMember (UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' tag
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' tag
NewTeamMember UserId
uid PermissionType tag
perms Maybe (UserId, UTCTimeMillis)
inv)

instance ToSchema TeamMember where
  schema :: ValueSchema NamedSwaggerDoc TeamMember
schema = Text
-> SchemaP SwaggerDoc Object [Pair] TeamMember TeamMember
-> ValueSchema NamedSwaggerDoc TeamMember
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"TeamMember" SchemaP SwaggerDoc Object [Pair] TeamMember TeamMember
teamMemberObjectSchema

teamMemberObjectSchema :: ObjectSchema SwaggerDoc TeamMember
teamMemberObjectSchema :: SchemaP SwaggerDoc Object [Pair] TeamMember TeamMember
teamMemberObjectSchema =
  NewTeamMember -> UserLegalHoldStatus -> TeamMember
forall (tag :: PermissionTag).
NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
TeamMember
    (NewTeamMember -> UserLegalHoldStatus -> TeamMember)
-> SchemaP SwaggerDoc Object [Pair] TeamMember NewTeamMember
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMember
     (UserLegalHoldStatus -> TeamMember)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMember -> NewTeamMember
forall (tag :: PermissionTag).
TeamMember' tag -> NewTeamMember' tag
_newTeamMember
      (TeamMember -> NewTeamMember)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
-> SchemaP SwaggerDoc Object [Pair] TeamMember NewTeamMember
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
newTeamMemberSchema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamMember
  (UserLegalHoldStatus -> TeamMember)
-> SchemaP SwaggerDoc Object [Pair] TeamMember UserLegalHoldStatus
-> SchemaP SwaggerDoc Object [Pair] TeamMember TeamMember
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamMember (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamMember a
-> SchemaP SwaggerDoc Object [Pair] TeamMember b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamMember -> UserLegalHoldStatus
forall (tag :: PermissionTag).
TeamMember' tag -> UserLegalHoldStatus
_legalHoldStatus
      (TeamMember -> UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc Object [Pair] UserLegalHoldStatus UserLegalHoldStatus
-> SchemaP SwaggerDoc Object [Pair] TeamMember UserLegalHoldStatus
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= (UserLegalHoldStatus
-> Maybe UserLegalHoldStatus -> UserLegalHoldStatus
forall a. a -> Maybe a -> a
fromMaybe UserLegalHoldStatus
defUserLegalHoldStatus (Maybe UserLegalHoldStatus -> UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UserLegalHoldStatus
     (Maybe UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc Object [Pair] UserLegalHoldStatus UserLegalHoldStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc Value Value UserLegalHoldStatus UserLegalHoldStatus
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UserLegalHoldStatus
     (Maybe UserLegalHoldStatus)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"legalhold_status" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
lhDesc) SchemaP
  NamedSwaggerDoc Value Value UserLegalHoldStatus UserLegalHoldStatus
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

instance ToSchema (TeamMember' 'Optional) where
  schema :: ValueSchema NamedSwaggerDoc (TeamMember' 'Optional)
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ObjectSchema SwaggerDoc (TeamMember' 'Optional)
-> ValueSchema NamedSwaggerDoc (TeamMember' 'Optional)
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier Text
"TeamMember" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"team member data") (ObjectSchema SwaggerDoc (TeamMember' 'Optional)
 -> ValueSchema NamedSwaggerDoc (TeamMember' 'Optional))
-> ObjectSchema SwaggerDoc (TeamMember' 'Optional)
-> ValueSchema NamedSwaggerDoc (TeamMember' 'Optional)
forall a b. (a -> b) -> a -> b
$
      NewTeamMember' 'Optional
-> UserLegalHoldStatus -> TeamMember' 'Optional
forall (tag :: PermissionTag).
NewTeamMember' tag -> UserLegalHoldStatus -> TeamMember' tag
TeamMember
        (NewTeamMember' 'Optional
 -> UserLegalHoldStatus -> TeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMember' 'Optional)
     (NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMember' 'Optional)
     (UserLegalHoldStatus -> TeamMember' 'Optional)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMember' 'Optional -> NewTeamMember' 'Optional
forall (tag :: PermissionTag).
TeamMember' tag -> NewTeamMember' tag
_newTeamMember
          (TeamMember' 'Optional -> NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMember' 'Optional)
     (NewTeamMember' 'Optional)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ( UserId
-> Maybe Permissions
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' 'Optional
UserId
-> PermissionType 'Optional
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' 'Optional
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' tag
NewTeamMember
                 (UserId
 -> Maybe Permissions
 -> Maybe (UserId, UTCTimeMillis)
 -> NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe Permissions
      -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember' 'Optional)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NewTeamMember' 'Optional -> UserId
forall (tag :: PermissionTag). NewTeamMember' tag -> UserId
_nUserId
                   (NewTeamMember' 'Optional -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP
     SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) UserId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"user" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"user ID") SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
                 SchemaP
  SwaggerDoc
  Object
  [Pair]
  (NewTeamMember' 'Optional)
  (Maybe Permissions
   -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe Permissions)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe (UserId, UTCTimeMillis) -> NewTeamMember' 'Optional)
forall a b.
SchemaP
  SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) a
-> SchemaP SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewTeamMember' 'Optional -> Maybe Permissions
NewTeamMember' 'Optional -> PermissionType 'Optional
forall (tag :: PermissionTag).
NewTeamMember' tag -> PermissionType tag
_nPermissions
                   (NewTeamMember' 'Optional -> Maybe Permissions)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe Permissions) (Maybe Permissions)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe Permissions)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Permissions (Maybe Permissions)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe Permissions) (Maybe Permissions)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Permissions Permissions
-> SchemaP SwaggerDoc Object [Pair] Permissions (Maybe Permissions)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"permissions" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
permissionsDesc) SchemaP NamedSwaggerDoc Value Value Permissions Permissions
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
                 SchemaP
  SwaggerDoc
  Object
  [Pair]
  (NewTeamMember' 'Optional)
  (Maybe (UserId, UTCTimeMillis) -> NewTeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe (UserId, UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (NewTeamMember' 'Optional)
forall a b.
SchemaP
  SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) a
-> SchemaP SwaggerDoc Object [Pair] (NewTeamMember' 'Optional) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewTeamMember' 'Optional -> Maybe (UserId, UTCTimeMillis)
forall (tag :: PermissionTag).
NewTeamMember' tag -> Maybe (UserId, UTCTimeMillis)
_nInvitation
                   (NewTeamMember' 'Optional -> Maybe (UserId, UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe (UserId, UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (NewTeamMember' 'Optional)
     (Maybe (UserId, UTCTimeMillis))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  (Maybe (UserId, UTCTimeMillis))
  (Maybe (UserId, UTCTimeMillis))
invitedSchema'
             )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (TeamMember' 'Optional)
  (UserLegalHoldStatus -> TeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMember' 'Optional)
     UserLegalHoldStatus
-> ObjectSchema SwaggerDoc (TeamMember' 'Optional)
forall a b.
SchemaP SwaggerDoc Object [Pair] (TeamMember' 'Optional) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (TeamMember' 'Optional) a
-> SchemaP SwaggerDoc Object [Pair] (TeamMember' 'Optional) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamMember' 'Optional -> UserLegalHoldStatus
forall (tag :: PermissionTag).
TeamMember' tag -> UserLegalHoldStatus
_legalHoldStatus
          (TeamMember' 'Optional -> UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc Object [Pair] UserLegalHoldStatus UserLegalHoldStatus
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMember' 'Optional)
     UserLegalHoldStatus
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= (UserLegalHoldStatus
-> Maybe UserLegalHoldStatus -> UserLegalHoldStatus
forall a. a -> Maybe a -> a
fromMaybe UserLegalHoldStatus
defUserLegalHoldStatus (Maybe UserLegalHoldStatus -> UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UserLegalHoldStatus
     (Maybe UserLegalHoldStatus)
-> SchemaP
     SwaggerDoc Object [Pair] UserLegalHoldStatus UserLegalHoldStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc Value Value UserLegalHoldStatus UserLegalHoldStatus
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UserLegalHoldStatus
     (Maybe UserLegalHoldStatus)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"legalhold_status" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
lhDesc) SchemaP
  NamedSwaggerDoc Value Value UserLegalHoldStatus UserLegalHoldStatus
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    where
      permissionsDesc :: Text
permissionsDesc =
        Text
"The permissions this user has in the given team \
        \ (only visible with permission `GetMemberPermissions`)."

lhDesc :: Text
lhDesc :: Text
lhDesc = Text
"The state of Legal Hold compliance for the member"

setPerm :: Bool -> Permissions -> Maybe Permissions
setPerm :: Bool -> Permissions -> Maybe Permissions
setPerm Bool
True = Permissions -> Maybe Permissions
forall a. a -> Maybe a
Just
setPerm Bool
False = Maybe Permissions -> Permissions -> Maybe Permissions
forall a b. a -> b -> a
const Maybe Permissions
forall a. Maybe a
Nothing

--------------------------------------------------------------------------------
-- TeamMemberList

data TeamMembersTable = TeamMembersTable
  deriving (TeamMembersTable -> TeamMembersTable -> Bool
(TeamMembersTable -> TeamMembersTable -> Bool)
-> (TeamMembersTable -> TeamMembersTable -> Bool)
-> Eq TeamMembersTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamMembersTable -> TeamMembersTable -> Bool
== :: TeamMembersTable -> TeamMembersTable -> Bool
$c/= :: TeamMembersTable -> TeamMembersTable -> Bool
/= :: TeamMembersTable -> TeamMembersTable -> Bool
Eq, Int -> TeamMembersTable -> ShowS
[TeamMembersTable] -> ShowS
TeamMembersTable -> String
(Int -> TeamMembersTable -> ShowS)
-> (TeamMembersTable -> String)
-> ([TeamMembersTable] -> ShowS)
-> Show TeamMembersTable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamMembersTable -> ShowS
showsPrec :: Int -> TeamMembersTable -> ShowS
$cshow :: TeamMembersTable -> String
show :: TeamMembersTable -> String
$cshowList :: [TeamMembersTable] -> ShowS
showList :: [TeamMembersTable] -> ShowS
Show, (forall x. TeamMembersTable -> Rep TeamMembersTable x)
-> (forall x. Rep TeamMembersTable x -> TeamMembersTable)
-> Generic TeamMembersTable
forall x. Rep TeamMembersTable x -> TeamMembersTable
forall x. TeamMembersTable -> Rep TeamMembersTable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeamMembersTable -> Rep TeamMembersTable x
from :: forall x. TeamMembersTable -> Rep TeamMembersTable x
$cto :: forall x. Rep TeamMembersTable x -> TeamMembersTable
to :: forall x. Rep TeamMembersTable x -> TeamMembersTable
Generic)

instance PagingTable TeamMembersTable where
  encodePagingTable :: TeamMembersTable -> Word8
encodePagingTable TeamMembersTable
TeamMembersTable = Word8
0

  decodePagingTable :: forall (m :: * -> *). MonadFail m => Word8 -> m TeamMembersTable
decodePagingTable Word8
0 = TeamMembersTable -> m TeamMembersTable
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TeamMembersTable
TeamMembersTable
  decodePagingTable Word8
x = String -> m TeamMembersTable
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m TeamMembersTable) -> String -> m TeamMembersTable
forall a b. (a -> b) -> a -> b
$ String
"Expected 0 while parsing TeamMembersTable, got: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Word8 -> String
forall a. Show a => a -> String
show Word8
x

type TeamMembersPagingName = "TeamMembers"

type TeamMembersPage' = MultiTablePage TeamMembersPagingName "members" TeamMembersTable TeamMemberOptPerms

newtype TeamMembersPage = TeamMembersPage {TeamMembersPage -> TeamMembersPage'
unTeamMembersPage :: TeamMembersPage'}
  deriving stock (TeamMembersPage -> TeamMembersPage -> Bool
(TeamMembersPage -> TeamMembersPage -> Bool)
-> (TeamMembersPage -> TeamMembersPage -> Bool)
-> Eq TeamMembersPage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamMembersPage -> TeamMembersPage -> Bool
== :: TeamMembersPage -> TeamMembersPage -> Bool
$c/= :: TeamMembersPage -> TeamMembersPage -> Bool
/= :: TeamMembersPage -> TeamMembersPage -> Bool
Eq, Int -> TeamMembersPage -> ShowS
[TeamMembersPage] -> ShowS
TeamMembersPage -> String
(Int -> TeamMembersPage -> ShowS)
-> (TeamMembersPage -> String)
-> ([TeamMembersPage] -> ShowS)
-> Show TeamMembersPage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamMembersPage -> ShowS
showsPrec :: Int -> TeamMembersPage -> ShowS
$cshow :: TeamMembersPage -> String
show :: TeamMembersPage -> String
$cshowList :: [TeamMembersPage] -> ShowS
showList :: [TeamMembersPage] -> ShowS
Show, (forall x. TeamMembersPage -> Rep TeamMembersPage x)
-> (forall x. Rep TeamMembersPage x -> TeamMembersPage)
-> Generic TeamMembersPage
forall x. Rep TeamMembersPage x -> TeamMembersPage
forall x. TeamMembersPage -> Rep TeamMembersPage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeamMembersPage -> Rep TeamMembersPage x
from :: forall x. TeamMembersPage -> Rep TeamMembersPage x
$cto :: forall x. Rep TeamMembersPage x -> TeamMembersPage
to :: forall x. Rep TeamMembersPage x -> TeamMembersPage
Generic)
  deriving ([TeamMembersPage] -> Value
[TeamMembersPage] -> Encoding
TeamMembersPage -> Value
TeamMembersPage -> Encoding
(TeamMembersPage -> Value)
-> (TeamMembersPage -> Encoding)
-> ([TeamMembersPage] -> Value)
-> ([TeamMembersPage] -> Encoding)
-> ToJSON TeamMembersPage
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: TeamMembersPage -> Value
toJSON :: TeamMembersPage -> Value
$ctoEncoding :: TeamMembersPage -> Encoding
toEncoding :: TeamMembersPage -> Encoding
$ctoJSONList :: [TeamMembersPage] -> Value
toJSONList :: [TeamMembersPage] -> Value
$ctoEncodingList :: [TeamMembersPage] -> Encoding
toEncodingList :: [TeamMembersPage] -> Encoding
ToJSON, Value -> Parser [TeamMembersPage]
Value -> Parser TeamMembersPage
(Value -> Parser TeamMembersPage)
-> (Value -> Parser [TeamMembersPage]) -> FromJSON TeamMembersPage
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser TeamMembersPage
parseJSON :: Value -> Parser TeamMembersPage
$cparseJSONList :: Value -> Parser [TeamMembersPage]
parseJSONList :: Value -> Parser [TeamMembersPage]
FromJSON, Typeable TeamMembersPage
Typeable TeamMembersPage =>
(Proxy TeamMembersPage -> Declare (Definitions Schema) NamedSchema)
-> ToSchema TeamMembersPage
Proxy TeamMembersPage -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy TeamMembersPage -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy TeamMembersPage -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema TeamMembersPage)

instance ToSchema TeamMembersPage where
  schema :: ValueSchema NamedSwaggerDoc TeamMembersPage
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage
-> ValueSchema NamedSwaggerDoc TeamMembersPage
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"TeamMembersPage" (SchemaP SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage
 -> ValueSchema NamedSwaggerDoc TeamMembersPage)
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage
-> ValueSchema NamedSwaggerDoc TeamMembersPage
forall a b. (a -> b) -> a -> b
$
      TeamMembersPage' -> TeamMembersPage
TeamMembersPage
        (TeamMembersPage' -> TeamMembersPage)
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage'
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMembersPage -> TeamMembersPage'
unTeamMembersPage
          (TeamMembersPage -> TeamMembersPage')
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage' TeamMembersPage'
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage TeamMembersPage'
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ( [TeamMember' 'Optional]
-> Bool
-> MultiTablePagingState TeamMembersPagingName TeamMembersTable
-> TeamMembersPage'
forall (name :: Symbol) (resultsKey :: Symbol) tables a.
[a]
-> Bool
-> MultiTablePagingState name tables
-> MultiTablePage name resultsKey tables a
MultiTablePage
                 ([TeamMember' 'Optional]
 -> Bool
 -> MultiTablePagingState TeamMembersPagingName TeamMembersTable
 -> TeamMembersPage')
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage' [TeamMember' 'Optional]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMembersPage'
     (Bool
      -> MultiTablePagingState TeamMembersPagingName TeamMembersTable
      -> TeamMembersPage')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMembersPage' -> [TeamMember' 'Optional]
forall (name :: Symbol) (resultsKey :: Symbol) tables a.
MultiTablePage name resultsKey tables a -> [a]
mtpResults
                   (TeamMembersPage' -> [TeamMember' 'Optional])
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     [TeamMember' 'Optional]
     [TeamMember' 'Optional]
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage' [TeamMember' 'Optional]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     [TeamMember' 'Optional]
     [TeamMember' 'Optional]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     [TeamMember' 'Optional]
     [TeamMember' 'Optional]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"members" (ValueSchema NamedSwaggerDoc (TeamMember' 'Optional)
-> SchemaP
     SwaggerDoc
     Value
     Value
     [TeamMember' 'Optional]
     [TeamMember' 'Optional]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc (TeamMember' 'Optional)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
                 SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamMembersPage'
  (Bool
   -> MultiTablePagingState TeamMembersPagingName TeamMembersTable
   -> TeamMembersPage')
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' Bool
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMembersPage'
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable
      -> TeamMembersPage')
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamMembersPage' (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' a
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamMembersPage' -> Bool
forall (name :: Symbol) (resultsKey :: Symbol) tables a.
MultiTablePage name resultsKey tables a -> Bool
mtpHasMore
                   (TeamMembersPage' -> Bool)
-> SchemaP SwaggerDoc Object [Pair] Bool Bool
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' Bool
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Bool Bool
-> SchemaP SwaggerDoc Object [Pair] Bool Bool
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"hasMore" SchemaP NamedSwaggerDoc Value Value Bool Bool
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
                 SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamMembersPage'
  (MultiTablePagingState TeamMembersPagingName TeamMembersTable
   -> TeamMembersPage')
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMembersPage'
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
-> SchemaP
     SwaggerDoc Object [Pair] TeamMembersPage' TeamMembersPage'
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamMembersPage' (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' a
-> SchemaP SwaggerDoc Object [Pair] TeamMembersPage' b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamMembersPage'
-> MultiTablePagingState TeamMembersPagingName TeamMembersTable
forall (name :: Symbol) (resultsKey :: Symbol) tables a.
MultiTablePage name resultsKey tables a
-> MultiTablePagingState name tables
mtpPagingState
                   (TeamMembersPage'
 -> MultiTablePagingState TeamMembersPagingName TeamMembersTable)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMembersPage'
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
     (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"pagingState" SchemaP
  NamedSwaggerDoc
  Value
  Value
  (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
  (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
             )

type TeamMembersPagingState = MultiTablePagingState TeamMembersPagingName TeamMembersTable

teamMemberPagingState :: PageWithState TeamMember -> TeamMembersPagingState
teamMemberPagingState :: PageWithState TeamMember
-> MultiTablePagingState TeamMembersPagingName TeamMembersTable
teamMemberPagingState PageWithState TeamMember
p = TeamMembersTable
-> Maybe ByteString
-> MultiTablePagingState TeamMembersPagingName TeamMembersTable
forall (name :: Symbol) tables.
tables -> Maybe ByteString -> MultiTablePagingState name tables
MultiTablePagingState TeamMembersTable
TeamMembersTable (ByteString -> ByteString
LBS.toStrict (ByteString -> ByteString)
-> (PagingState -> ByteString) -> PagingState -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PagingState -> ByteString
C.unPagingState (PagingState -> ByteString)
-> Maybe PagingState -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PageWithState TeamMember -> Maybe PagingState
forall a. PageWithState a -> Maybe PagingState
pwsState PageWithState TeamMember
p)

instance ToParamSchema TeamMembersPagingState where
  toParamSchema :: Proxy
  (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
-> Schema
toParamSchema Proxy
  (MultiTablePagingState TeamMembersPagingName TeamMembersTable)
_ = Proxy Text -> Schema
forall a. ToParamSchema a => Proxy a -> Schema
toParamSchema (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @Text)

type TeamMemberList = TeamMemberList' 'Required

type TeamMemberListOptPerms = TeamMemberList' 'Optional

data TeamMemberList' (tag :: PermissionTag) = TeamMemberList
  { forall (tag :: PermissionTag).
TeamMemberList' tag -> [TeamMember' tag]
_teamMembers :: [TeamMember' tag],
    forall (tag :: PermissionTag). TeamMemberList' tag -> ListType
_teamMemberListType :: ListType
  }
  deriving stock ((forall x. TeamMemberList' tag -> Rep (TeamMemberList' tag) x)
-> (forall x. Rep (TeamMemberList' tag) x -> TeamMemberList' tag)
-> Generic (TeamMemberList' tag)
forall x. Rep (TeamMemberList' tag) x -> TeamMemberList' tag
forall x. TeamMemberList' tag -> Rep (TeamMemberList' tag) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (tag :: PermissionTag) x.
Rep (TeamMemberList' tag) x -> TeamMemberList' tag
forall (tag :: PermissionTag) x.
TeamMemberList' tag -> Rep (TeamMemberList' tag) x
$cfrom :: forall (tag :: PermissionTag) x.
TeamMemberList' tag -> Rep (TeamMemberList' tag) x
from :: forall x. TeamMemberList' tag -> Rep (TeamMemberList' tag) x
$cto :: forall (tag :: PermissionTag) x.
Rep (TeamMemberList' tag) x -> TeamMemberList' tag
to :: forall x. Rep (TeamMemberList' tag) x -> TeamMemberList' tag
Generic)

deriving instance (Eq (PermissionType tag)) => Eq (TeamMemberList' tag)

deriving instance (Show (PermissionType tag)) => Show (TeamMemberList' tag)

deriving via (GenericUniform (TeamMemberList' 'Optional)) instance Arbitrary (TeamMemberList' 'Optional)

deriving via (GenericUniform TeamMemberList) instance Arbitrary TeamMemberList

deriving via
  (Schema (TeamMemberList' tag))
  instance
    (ToSchema (TeamMemberList' tag)) =>
    FromJSON (TeamMemberList' tag)

deriving via
  (Schema (TeamMemberList' tag))
  instance
    (ToSchema (TeamMemberList' tag)) =>
    ToJSON (TeamMemberList' tag)

deriving via
  (Schema (TeamMemberList' tag))
  instance
    (ToSchema (TeamMemberList' tag), Typeable tag) =>
    S.ToSchema (TeamMemberList' tag)

newTeamMemberList :: [TeamMember] -> ListType -> TeamMemberList
newTeamMemberList :: [TeamMember] -> ListType -> TeamMemberList
newTeamMemberList = [TeamMember] -> ListType -> TeamMemberList
forall (tag :: PermissionTag).
[TeamMember' tag] -> ListType -> TeamMemberList' tag
TeamMemberList

instance (ToSchema (TeamMember' tag)) => ToSchema (TeamMemberList' tag) where
  schema :: ValueSchema NamedSwaggerDoc (TeamMemberList' tag)
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ObjectSchema SwaggerDoc (TeamMemberList' tag)
-> ValueSchema NamedSwaggerDoc (TeamMemberList' tag)
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier Text
"TeamMemberList" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"list of team member") (ObjectSchema SwaggerDoc (TeamMemberList' tag)
 -> ValueSchema NamedSwaggerDoc (TeamMemberList' tag))
-> ObjectSchema SwaggerDoc (TeamMemberList' tag)
-> ValueSchema NamedSwaggerDoc (TeamMemberList' tag)
forall a b. (a -> b) -> a -> b
$
      [TeamMember' tag] -> ListType -> TeamMemberList' tag
forall (tag :: PermissionTag).
[TeamMember' tag] -> ListType -> TeamMemberList' tag
TeamMemberList
        ([TeamMember' tag] -> ListType -> TeamMemberList' tag)
-> SchemaP
     SwaggerDoc Object [Pair] (TeamMemberList' tag) [TeamMember' tag]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (TeamMemberList' tag)
     (ListType -> TeamMemberList' tag)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMemberList' tag -> [TeamMember' tag]
forall (tag :: PermissionTag).
TeamMemberList' tag -> [TeamMember' tag]
_teamMembers
          (TeamMemberList' tag -> [TeamMember' tag])
-> SchemaP
     SwaggerDoc Object [Pair] [TeamMember' tag] [TeamMember' tag]
-> SchemaP
     SwaggerDoc Object [Pair] (TeamMemberList' tag) [TeamMember' tag]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP
     SwaggerDoc Value Value [TeamMember' tag] [TeamMember' tag]
-> SchemaP
     SwaggerDoc Object [Pair] [TeamMember' tag] [TeamMember' tag]
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"members" ((Maybe Text -> Identity (Maybe Text))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' SwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Text -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"the array of team members") (ValueSchema NamedSwaggerDoc (TeamMember' tag)
-> SchemaP
     SwaggerDoc Value Value [TeamMember' tag] [TeamMember' tag]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc (TeamMember' tag)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (TeamMemberList' tag)
  (ListType -> TeamMemberList' tag)
-> SchemaP SwaggerDoc Object [Pair] (TeamMemberList' tag) ListType
-> ObjectSchema SwaggerDoc (TeamMemberList' tag)
forall a b.
SchemaP SwaggerDoc Object [Pair] (TeamMemberList' tag) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (TeamMemberList' tag) a
-> SchemaP SwaggerDoc Object [Pair] (TeamMemberList' tag) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamMemberList' tag -> ListType
forall (tag :: PermissionTag). TeamMemberList' tag -> ListType
_teamMemberListType
          (TeamMemberList' tag -> ListType)
-> SchemaP SwaggerDoc Object [Pair] ListType ListType
-> SchemaP SwaggerDoc Object [Pair] (TeamMemberList' tag) ListType
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value ListType ListType
-> SchemaP SwaggerDoc Object [Pair] ListType ListType
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"hasMore" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"true if 'members' doesn't contain all team members") SchemaP NamedSwaggerDoc Value Value ListType ListType
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

-- | Like 'ListType', but without backwards-compatible and boolean-blind json serialization.
data NewListType
  = NewListComplete
  | NewListTruncated
  deriving stock (NewListType -> NewListType -> Bool
(NewListType -> NewListType -> Bool)
-> (NewListType -> NewListType -> Bool) -> Eq NewListType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewListType -> NewListType -> Bool
== :: NewListType -> NewListType -> Bool
$c/= :: NewListType -> NewListType -> Bool
/= :: NewListType -> NewListType -> Bool
Eq, Eq NewListType
Eq NewListType =>
(NewListType -> NewListType -> Ordering)
-> (NewListType -> NewListType -> Bool)
-> (NewListType -> NewListType -> Bool)
-> (NewListType -> NewListType -> Bool)
-> (NewListType -> NewListType -> Bool)
-> (NewListType -> NewListType -> NewListType)
-> (NewListType -> NewListType -> NewListType)
-> Ord NewListType
NewListType -> NewListType -> Bool
NewListType -> NewListType -> Ordering
NewListType -> NewListType -> NewListType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NewListType -> NewListType -> Ordering
compare :: NewListType -> NewListType -> Ordering
$c< :: NewListType -> NewListType -> Bool
< :: NewListType -> NewListType -> Bool
$c<= :: NewListType -> NewListType -> Bool
<= :: NewListType -> NewListType -> Bool
$c> :: NewListType -> NewListType -> Bool
> :: NewListType -> NewListType -> Bool
$c>= :: NewListType -> NewListType -> Bool
>= :: NewListType -> NewListType -> Bool
$cmax :: NewListType -> NewListType -> NewListType
max :: NewListType -> NewListType -> NewListType
$cmin :: NewListType -> NewListType -> NewListType
min :: NewListType -> NewListType -> NewListType
Ord, Int -> NewListType -> ShowS
[NewListType] -> ShowS
NewListType -> String
(Int -> NewListType -> ShowS)
-> (NewListType -> String)
-> ([NewListType] -> ShowS)
-> Show NewListType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewListType -> ShowS
showsPrec :: Int -> NewListType -> ShowS
$cshow :: NewListType -> String
show :: NewListType -> String
$cshowList :: [NewListType] -> ShowS
showList :: [NewListType] -> ShowS
Show, (forall x. NewListType -> Rep NewListType x)
-> (forall x. Rep NewListType x -> NewListType)
-> Generic NewListType
forall x. Rep NewListType x -> NewListType
forall x. NewListType -> Rep NewListType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewListType -> Rep NewListType x
from :: forall x. NewListType -> Rep NewListType x
$cto :: forall x. Rep NewListType x -> NewListType
to :: forall x. Rep NewListType x -> NewListType
Generic)
  deriving (Gen NewListType
Gen NewListType
-> (NewListType -> [NewListType]) -> Arbitrary NewListType
NewListType -> [NewListType]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen NewListType
arbitrary :: Gen NewListType
$cshrink :: NewListType -> [NewListType]
shrink :: NewListType -> [NewListType]
Arbitrary) via (GenericUniform NewListType)
  deriving (Value -> Parser [NewListType]
Value -> Parser NewListType
(Value -> Parser NewListType)
-> (Value -> Parser [NewListType]) -> FromJSON NewListType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser NewListType
parseJSON :: Value -> Parser NewListType
$cparseJSONList :: Value -> Parser [NewListType]
parseJSONList :: Value -> Parser [NewListType]
FromJSON, [NewListType] -> Value
[NewListType] -> Encoding
NewListType -> Value
NewListType -> Encoding
(NewListType -> Value)
-> (NewListType -> Encoding)
-> ([NewListType] -> Value)
-> ([NewListType] -> Encoding)
-> ToJSON NewListType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: NewListType -> Value
toJSON :: NewListType -> Value
$ctoEncoding :: NewListType -> Encoding
toEncoding :: NewListType -> Encoding
$ctoJSONList :: [NewListType] -> Value
toJSONList :: [NewListType] -> Value
$ctoEncodingList :: [NewListType] -> Encoding
toEncodingList :: [NewListType] -> Encoding
ToJSON, Typeable NewListType
Typeable NewListType =>
(Proxy NewListType -> Declare (Definitions Schema) NamedSchema)
-> ToSchema NewListType
Proxy NewListType -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy NewListType -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy NewListType -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema NewListType)

instance ToSchema NewListType where
  schema :: ValueSchema NamedSwaggerDoc NewListType
schema =
    forall v doc a b.
(With v, HasEnum v doc) =>
Text
-> SchemaP [Value] v (Alt Maybe v) a b
-> SchemaP doc Value Value a b
enum @Text Text
"NewListType" (SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType
 -> ValueSchema NamedSwaggerDoc NewListType)
-> SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType
-> ValueSchema NamedSwaggerDoc NewListType
forall a b. (a -> b) -> a -> b
$
      [SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType]
-> SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType
forall a. Monoid a => [a] -> a
mconcat
        [ Text
-> NewListType
-> SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"list_complete" NewListType
NewListComplete,
          Text
-> NewListType
-> SchemaP [Value] Text (Alt Maybe Text) NewListType NewListType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"list_truncated" NewListType
NewListTruncated
        ]

toNewListType :: ListType -> NewListType
toNewListType :: ListType -> NewListType
toNewListType ListType
ListComplete = NewListType
NewListComplete
toNewListType ListType
ListTruncated = NewListType
NewListTruncated

data ListType
  = ListComplete
  | ListTruncated
  deriving stock (ListType -> ListType -> Bool
(ListType -> ListType -> Bool)
-> (ListType -> ListType -> Bool) -> Eq ListType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListType -> ListType -> Bool
== :: ListType -> ListType -> Bool
$c/= :: ListType -> ListType -> Bool
/= :: ListType -> ListType -> Bool
Eq, Eq ListType
Eq ListType =>
(ListType -> ListType -> Ordering)
-> (ListType -> ListType -> Bool)
-> (ListType -> ListType -> Bool)
-> (ListType -> ListType -> Bool)
-> (ListType -> ListType -> Bool)
-> (ListType -> ListType -> ListType)
-> (ListType -> ListType -> ListType)
-> Ord ListType
ListType -> ListType -> Bool
ListType -> ListType -> Ordering
ListType -> ListType -> ListType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListType -> ListType -> Ordering
compare :: ListType -> ListType -> Ordering
$c< :: ListType -> ListType -> Bool
< :: ListType -> ListType -> Bool
$c<= :: ListType -> ListType -> Bool
<= :: ListType -> ListType -> Bool
$c> :: ListType -> ListType -> Bool
> :: ListType -> ListType -> Bool
$c>= :: ListType -> ListType -> Bool
>= :: ListType -> ListType -> Bool
$cmax :: ListType -> ListType -> ListType
max :: ListType -> ListType -> ListType
$cmin :: ListType -> ListType -> ListType
min :: ListType -> ListType -> ListType
Ord, Int -> ListType -> ShowS
[ListType] -> ShowS
ListType -> String
(Int -> ListType -> ShowS)
-> (ListType -> String) -> ([ListType] -> ShowS) -> Show ListType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListType -> ShowS
showsPrec :: Int -> ListType -> ShowS
$cshow :: ListType -> String
show :: ListType -> String
$cshowList :: [ListType] -> ShowS
showList :: [ListType] -> ShowS
Show, (forall x. ListType -> Rep ListType x)
-> (forall x. Rep ListType x -> ListType) -> Generic ListType
forall x. Rep ListType x -> ListType
forall x. ListType -> Rep ListType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ListType -> Rep ListType x
from :: forall x. ListType -> Rep ListType x
$cto :: forall x. Rep ListType x -> ListType
to :: forall x. Rep ListType x -> ListType
Generic)
  deriving (Gen ListType
Gen ListType -> (ListType -> [ListType]) -> Arbitrary ListType
ListType -> [ListType]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ListType
arbitrary :: Gen ListType
$cshrink :: ListType -> [ListType]
shrink :: ListType -> [ListType]
Arbitrary) via (GenericUniform ListType)
  deriving (Value -> Parser [ListType]
Value -> Parser ListType
(Value -> Parser ListType)
-> (Value -> Parser [ListType]) -> FromJSON ListType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ListType
parseJSON :: Value -> Parser ListType
$cparseJSONList :: Value -> Parser [ListType]
parseJSONList :: Value -> Parser [ListType]
FromJSON, [ListType] -> Value
[ListType] -> Encoding
ListType -> Value
ListType -> Encoding
(ListType -> Value)
-> (ListType -> Encoding)
-> ([ListType] -> Value)
-> ([ListType] -> Encoding)
-> ToJSON ListType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ListType -> Value
toJSON :: ListType -> Value
$ctoEncoding :: ListType -> Encoding
toEncoding :: ListType -> Encoding
$ctoJSONList :: [ListType] -> Value
toJSONList :: [ListType] -> Value
$ctoEncodingList :: [ListType] -> Encoding
toEncodingList :: [ListType] -> Encoding
ToJSON, Typeable ListType
Typeable ListType =>
(Proxy ListType -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ListType
Proxy ListType -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ListType -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ListType -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema ListType)

-- This replaces the previous `hasMore` but has no boolean blindness. At the API level
-- though we do want this to remain true/false
instance ToSchema ListType where
  schema :: SchemaP NamedSwaggerDoc Value Value ListType ListType
schema =
    forall v doc a b.
(With v, HasEnum v doc) =>
Text
-> SchemaP [Value] v (Alt Maybe v) a b
-> SchemaP doc Value Value a b
enum @Bool Text
"ListType" (SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType
 -> SchemaP NamedSwaggerDoc Value Value ListType ListType)
-> SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType
-> SchemaP NamedSwaggerDoc Value Value ListType ListType
forall a b. (a -> b) -> a -> b
$
      [SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType]
-> SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType
forall a. Monoid a => [a] -> a
mconcat [Bool
-> ListType
-> SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Bool
True ListType
ListTruncated, Bool
-> ListType
-> SchemaP [Value] Bool (Alt Maybe Bool) ListType ListType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Bool
False ListType
ListComplete]

--------------------------------------------------------------------------------
-- NewTeamMember

type NewTeamMember = NewTeamMember' 'Required

mkNewTeamMember :: UserId -> PermissionType 'Required -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember
mkNewTeamMember :: UserId
-> PermissionType 'Required
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember
mkNewTeamMember = UserId
-> PermissionType 'Required
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' tag
NewTeamMember

-- | Like 'TeamMember', but we can receive this from the clients.  Clients are not allowed to
-- set 'UserLegalHoldStatus'.
data NewTeamMember' (tag :: PermissionTag) = NewTeamMember
  { forall (tag :: PermissionTag). NewTeamMember' tag -> UserId
_nUserId :: UserId,
    forall (tag :: PermissionTag).
NewTeamMember' tag -> PermissionType tag
_nPermissions :: PermissionType tag,
    forall (tag :: PermissionTag).
NewTeamMember' tag -> Maybe (UserId, UTCTimeMillis)
_nInvitation :: Maybe (UserId, UTCTimeMillis)
  }
  deriving stock ((forall x. NewTeamMember' tag -> Rep (NewTeamMember' tag) x)
-> (forall x. Rep (NewTeamMember' tag) x -> NewTeamMember' tag)
-> Generic (NewTeamMember' tag)
forall x. Rep (NewTeamMember' tag) x -> NewTeamMember' tag
forall x. NewTeamMember' tag -> Rep (NewTeamMember' tag) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (tag :: PermissionTag) x.
Rep (NewTeamMember' tag) x -> NewTeamMember' tag
forall (tag :: PermissionTag) x.
NewTeamMember' tag -> Rep (NewTeamMember' tag) x
$cfrom :: forall (tag :: PermissionTag) x.
NewTeamMember' tag -> Rep (NewTeamMember' tag) x
from :: forall x. NewTeamMember' tag -> Rep (NewTeamMember' tag) x
$cto :: forall (tag :: PermissionTag) x.
Rep (NewTeamMember' tag) x -> NewTeamMember' tag
to :: forall x. Rep (NewTeamMember' tag) x -> NewTeamMember' tag
Generic)

deriving instance (Eq (PermissionType tag)) => Eq (NewTeamMember' tag)

deriving instance (Ord (PermissionType tag)) => Ord (NewTeamMember' tag)

deriving instance (Show (PermissionType tag)) => Show (NewTeamMember' tag)

deriving via
  (Schema (NewTeamMember' tag))
  instance
    (ToSchema (NewTeamMember' tag)) =>
    ToJSON (NewTeamMember' tag)

deriving via
  (Schema (NewTeamMember' tag))
  instance
    (ToSchema (NewTeamMember' tag)) =>
    FromJSON (NewTeamMember' tag)

deriving via
  (Schema (NewTeamMember' tag))
  instance
    (ToSchema (NewTeamMember' tag), Typeable tag) =>
    S.ToSchema (NewTeamMember' tag)

deriving via (GenericUniform NewTeamMember) instance Arbitrary NewTeamMember

deriving via (GenericUniform (NewTeamMember' 'Optional)) instance Arbitrary (NewTeamMember' 'Optional)

newTeamMemberSchema :: ObjectSchema SwaggerDoc NewTeamMember
newTeamMemberSchema :: SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
newTeamMemberSchema =
  UserId
-> Permissions -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember
UserId
-> PermissionType 'Required
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> NewTeamMember' tag
NewTeamMember
    (UserId
 -> Permissions -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewTeamMember
     (Permissions -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NewTeamMember -> UserId
forall (tag :: PermissionTag). NewTeamMember' tag -> UserId
_nUserId
      (NewTeamMember -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember UserId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"user" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewTeamMember
  (Permissions -> Maybe (UserId, UTCTimeMillis) -> NewTeamMember)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember Permissions
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewTeamMember
     (Maybe (UserId, UTCTimeMillis) -> NewTeamMember)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewTeamMember (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember a
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewTeamMember -> Permissions
NewTeamMember -> PermissionType 'Required
forall (tag :: PermissionTag).
NewTeamMember' tag -> PermissionType tag
_nPermissions
      (NewTeamMember -> Permissions)
-> SchemaP SwaggerDoc Object [Pair] Permissions Permissions
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember Permissions
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Permissions Permissions
-> SchemaP SwaggerDoc Object [Pair] Permissions Permissions
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"permissions" SchemaP NamedSwaggerDoc Value Value Permissions Permissions
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewTeamMember
  (Maybe (UserId, UTCTimeMillis) -> NewTeamMember)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewTeamMember
     (Maybe (UserId, UTCTimeMillis))
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
forall a b.
SchemaP SwaggerDoc Object [Pair] NewTeamMember (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember a
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewTeamMember -> Maybe (UserId, UTCTimeMillis)
forall (tag :: PermissionTag).
NewTeamMember' tag -> Maybe (UserId, UTCTimeMillis)
_nInvitation
      (NewTeamMember -> Maybe (UserId, UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe (UserId, UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewTeamMember
     (Maybe (UserId, UTCTimeMillis))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  (Maybe (UserId, UTCTimeMillis))
  (Maybe (UserId, UTCTimeMillis))
invitedSchema'

invitedSchema :: ObjectSchemaP SwaggerDoc (Maybe (UserId, UTCTimeMillis)) (Maybe UserId, Maybe UTCTimeMillis)
invitedSchema :: ObjectSchemaP
  SwaggerDoc
  (Maybe (UserId, UTCTimeMillis))
  (Maybe UserId, Maybe UTCTimeMillis)
invitedSchema =
  (,)
    (Maybe UserId
 -> Maybe UTCTimeMillis -> (Maybe UserId, Maybe UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UTCTimeMillis -> (Maybe UserId, Maybe UTCTimeMillis))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((UserId, UTCTimeMillis) -> UserId)
-> Maybe (UserId, UTCTimeMillis) -> Maybe UserId
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UserId, UTCTimeMillis) -> UserId
forall a b. (a, b) -> a
fst
      (Maybe (UserId, UTCTimeMillis) -> Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] (Maybe UserId) (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value (Maybe UserId) UserId
-> SchemaP SwaggerDoc Object [Pair] (Maybe UserId) (Maybe UserId)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"created_by" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"ID of the inviting user.  Requires created_at.") (Value
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP NamedSwaggerDoc Value Value (Maybe UserId) UserId
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Null SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  (Maybe (UserId, UTCTimeMillis))
  (Maybe UTCTimeMillis -> (Maybe UserId, Maybe UTCTimeMillis))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UTCTimeMillis)
-> ObjectSchemaP
     SwaggerDoc
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UserId, Maybe UTCTimeMillis)
forall a b.
SchemaP
  SwaggerDoc Object [Pair] (Maybe (UserId, UTCTimeMillis)) (a -> b)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe (UserId, UTCTimeMillis)) a
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe (UserId, UTCTimeMillis)) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((UserId, UTCTimeMillis) -> UTCTimeMillis)
-> Maybe (UserId, UTCTimeMillis) -> Maybe UTCTimeMillis
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UserId, UTCTimeMillis) -> UTCTimeMillis
forall a b. (a, b) -> b
snd
      (Maybe (UserId, UTCTimeMillis) -> Maybe UTCTimeMillis)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe UTCTimeMillis)
     (Maybe UTCTimeMillis)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe UTCTimeMillis)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe UTCTimeMillis) UTCTimeMillis
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe UTCTimeMillis)
     (Maybe UTCTimeMillis)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"created_at" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Timestamp of invitation creation.  Requires created_by.") (Value
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe UTCTimeMillis) UTCTimeMillis
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Null SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

invitedSchema' :: ObjectSchema SwaggerDoc (Maybe (UserId, UTCTimeMillis))
invitedSchema' :: SchemaP
  SwaggerDoc
  Object
  [Pair]
  (Maybe (UserId, UTCTimeMillis))
  (Maybe (UserId, UTCTimeMillis))
invitedSchema' = ObjectSchemaP
  SwaggerDoc
  (Maybe (UserId, UTCTimeMillis))
  (Maybe UserId, Maybe UTCTimeMillis)
-> ((Maybe UserId, Maybe UTCTimeMillis)
    -> Parser (Maybe (UserId, UTCTimeMillis)))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe (UserId, UTCTimeMillis))
forall doc v w a b b'.
SchemaP doc v w a b -> (b -> Parser b') -> SchemaP doc v w a b'
withParser ObjectSchemaP
  SwaggerDoc
  (Maybe (UserId, UTCTimeMillis))
  (Maybe UserId, Maybe UTCTimeMillis)
invitedSchema (((Maybe UserId, Maybe UTCTimeMillis)
  -> Parser (Maybe (UserId, UTCTimeMillis)))
 -> SchemaP
      SwaggerDoc
      Object
      [Pair]
      (Maybe (UserId, UTCTimeMillis))
      (Maybe (UserId, UTCTimeMillis)))
-> ((Maybe UserId, Maybe UTCTimeMillis)
    -> Parser (Maybe (UserId, UTCTimeMillis)))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe (UserId, UTCTimeMillis))
     (Maybe (UserId, UTCTimeMillis))
forall a b. (a -> b) -> a -> b
$ \(Maybe UserId
invby, Maybe UTCTimeMillis
invat) ->
  case (Maybe UserId
invby, Maybe UTCTimeMillis
invat) of
    (Just UserId
b, Just UTCTimeMillis
a) -> Maybe (UserId, UTCTimeMillis)
-> Parser (Maybe (UserId, UTCTimeMillis))
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (UserId, UTCTimeMillis)
 -> Parser (Maybe (UserId, UTCTimeMillis)))
-> Maybe (UserId, UTCTimeMillis)
-> Parser (Maybe (UserId, UTCTimeMillis))
forall a b. (a -> b) -> a -> b
$ (UserId, UTCTimeMillis) -> Maybe (UserId, UTCTimeMillis)
forall a. a -> Maybe a
Just (UserId
b, UTCTimeMillis
a)
    (Maybe UserId
Nothing, Maybe UTCTimeMillis
Nothing) -> Maybe (UserId, UTCTimeMillis)
-> Parser (Maybe (UserId, UTCTimeMillis))
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (UserId, UTCTimeMillis)
forall a. Maybe a
Nothing
    (Maybe UserId, Maybe UTCTimeMillis)
_ -> String -> Parser (Maybe (UserId, UTCTimeMillis))
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"created_by, created_at"

instance ToSchema NewTeamMember where
  schema :: ValueSchema NamedSwaggerDoc NewTeamMember
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
-> ValueSchema NamedSwaggerDoc NewTeamMember
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier Text
"NewTeamMember" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Required data when creating new team members") (SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
 -> ValueSchema NamedSwaggerDoc NewTeamMember)
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
-> ValueSchema NamedSwaggerDoc NewTeamMember
forall a b. (a -> b) -> a -> b
$
      Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP SwaggerDoc Value Value NewTeamMember NewTeamMember
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"member" ((Maybe Text -> Identity (Maybe Text))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' SwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Text -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"the team member to add (the legalhold_status field must be null or missing!)") (SchemaP SwaggerDoc Value Value NewTeamMember NewTeamMember
 -> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember)
-> SchemaP SwaggerDoc Value Value NewTeamMember NewTeamMember
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
forall a b. (a -> b) -> a -> b
$
        ValueSchema NamedSwaggerDoc NewTeamMember
-> SchemaP SwaggerDoc Value Value NewTeamMember NewTeamMember
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed (Text
-> SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
-> ValueSchema NamedSwaggerDoc NewTeamMember
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"Unnamed" SchemaP SwaggerDoc Object [Pair] NewTeamMember NewTeamMember
newTeamMemberSchema)

--------------------------------------------------------------------------------
-- TeamMemberDeleteData

newtype TeamMemberDeleteData = TeamMemberDeleteData
  { TeamMemberDeleteData -> Maybe PlainTextPassword6
_tmdAuthPassword :: Maybe PlainTextPassword6
  }
  deriving stock (TeamMemberDeleteData -> TeamMemberDeleteData -> Bool
(TeamMemberDeleteData -> TeamMemberDeleteData -> Bool)
-> (TeamMemberDeleteData -> TeamMemberDeleteData -> Bool)
-> Eq TeamMemberDeleteData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamMemberDeleteData -> TeamMemberDeleteData -> Bool
== :: TeamMemberDeleteData -> TeamMemberDeleteData -> Bool
$c/= :: TeamMemberDeleteData -> TeamMemberDeleteData -> Bool
/= :: TeamMemberDeleteData -> TeamMemberDeleteData -> Bool
Eq, Int -> TeamMemberDeleteData -> ShowS
[TeamMemberDeleteData] -> ShowS
TeamMemberDeleteData -> String
(Int -> TeamMemberDeleteData -> ShowS)
-> (TeamMemberDeleteData -> String)
-> ([TeamMemberDeleteData] -> ShowS)
-> Show TeamMemberDeleteData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamMemberDeleteData -> ShowS
showsPrec :: Int -> TeamMemberDeleteData -> ShowS
$cshow :: TeamMemberDeleteData -> String
show :: TeamMemberDeleteData -> String
$cshowList :: [TeamMemberDeleteData] -> ShowS
showList :: [TeamMemberDeleteData] -> ShowS
Show)
  deriving newtype (Gen TeamMemberDeleteData
Gen TeamMemberDeleteData
-> (TeamMemberDeleteData -> [TeamMemberDeleteData])
-> Arbitrary TeamMemberDeleteData
TeamMemberDeleteData -> [TeamMemberDeleteData]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen TeamMemberDeleteData
arbitrary :: Gen TeamMemberDeleteData
$cshrink :: TeamMemberDeleteData -> [TeamMemberDeleteData]
shrink :: TeamMemberDeleteData -> [TeamMemberDeleteData]
Arbitrary)
  deriving ([TeamMemberDeleteData] -> Value
[TeamMemberDeleteData] -> Encoding
TeamMemberDeleteData -> Value
TeamMemberDeleteData -> Encoding
(TeamMemberDeleteData -> Value)
-> (TeamMemberDeleteData -> Encoding)
-> ([TeamMemberDeleteData] -> Value)
-> ([TeamMemberDeleteData] -> Encoding)
-> ToJSON TeamMemberDeleteData
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: TeamMemberDeleteData -> Value
toJSON :: TeamMemberDeleteData -> Value
$ctoEncoding :: TeamMemberDeleteData -> Encoding
toEncoding :: TeamMemberDeleteData -> Encoding
$ctoJSONList :: [TeamMemberDeleteData] -> Value
toJSONList :: [TeamMemberDeleteData] -> Value
$ctoEncodingList :: [TeamMemberDeleteData] -> Encoding
toEncodingList :: [TeamMemberDeleteData] -> Encoding
ToJSON, Value -> Parser [TeamMemberDeleteData]
Value -> Parser TeamMemberDeleteData
(Value -> Parser TeamMemberDeleteData)
-> (Value -> Parser [TeamMemberDeleteData])
-> FromJSON TeamMemberDeleteData
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser TeamMemberDeleteData
parseJSON :: Value -> Parser TeamMemberDeleteData
$cparseJSONList :: Value -> Parser [TeamMemberDeleteData]
parseJSONList :: Value -> Parser [TeamMemberDeleteData]
FromJSON, Typeable TeamMemberDeleteData
Typeable TeamMemberDeleteData =>
(Proxy TeamMemberDeleteData
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema TeamMemberDeleteData
Proxy TeamMemberDeleteData
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy TeamMemberDeleteData
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy TeamMemberDeleteData
-> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema TeamMemberDeleteData)

instance ToSchema TeamMemberDeleteData where
  schema :: ValueSchema NamedSwaggerDoc TeamMemberDeleteData
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ObjectSchema SwaggerDoc TeamMemberDeleteData
-> ValueSchema NamedSwaggerDoc TeamMemberDeleteData
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier Text
"TeamMemberDeleteData" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Data for a team member deletion request in case of binding teams.") (ObjectSchema SwaggerDoc TeamMemberDeleteData
 -> ValueSchema NamedSwaggerDoc TeamMemberDeleteData)
-> ObjectSchema SwaggerDoc TeamMemberDeleteData
-> ValueSchema NamedSwaggerDoc TeamMemberDeleteData
forall a b. (a -> b) -> a -> b
$
      Maybe PlainTextPassword6 -> TeamMemberDeleteData
TeamMemberDeleteData (Maybe PlainTextPassword6 -> TeamMemberDeleteData)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMemberDeleteData
     (Maybe PlainTextPassword6)
-> ObjectSchema SwaggerDoc TeamMemberDeleteData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamMemberDeleteData -> Maybe PlainTextPassword6
_tmdAuthPassword (TeamMemberDeleteData -> Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamMemberDeleteData
     (Maybe PlainTextPassword6)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (Maybe PlainTextPassword6)
     PlainTextPassword6
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"password" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"The account password to authorise the deletion.") (Value
-> SchemaP
     NamedSwaggerDoc Value Value PlainTextPassword6 PlainTextPassword6
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (Maybe PlainTextPassword6)
     PlainTextPassword6
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Null SchemaP
  NamedSwaggerDoc Value Value PlainTextPassword6 PlainTextPassword6
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

newTeamMemberDeleteData :: Maybe PlainTextPassword6 -> TeamMemberDeleteData
newTeamMemberDeleteData :: Maybe PlainTextPassword6 -> TeamMemberDeleteData
newTeamMemberDeleteData = Maybe PlainTextPassword6 -> TeamMemberDeleteData
TeamMemberDeleteData

makeLenses ''TeamMember'
makeLenses ''TeamMemberList'
makeLenses ''NewTeamMember'
makeLenses ''TeamMemberDeleteData

userId :: Lens' TeamMember UserId
userId :: Lens' TeamMember UserId
userId = (NewTeamMember -> f NewTeamMember) -> TeamMember -> f TeamMember
forall (tag :: PermissionTag) (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(NewTeamMember' tag -> f (NewTeamMember' tag))
-> TeamMember' tag -> f (TeamMember' tag)
newTeamMember ((NewTeamMember -> f NewTeamMember) -> TeamMember -> f TeamMember)
-> ((UserId -> f UserId) -> NewTeamMember -> f NewTeamMember)
-> (UserId -> f UserId)
-> TeamMember
-> f TeamMember
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UserId -> f UserId) -> NewTeamMember -> f NewTeamMember
forall (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(UserId -> f UserId)
-> NewTeamMember' tag -> f (NewTeamMember' tag)
nUserId

optionalPermissions :: TeamMemberOptPerms -> Maybe Permissions
optionalPermissions :: TeamMember' 'Optional -> Maybe Permissions
optionalPermissions = NewTeamMember' 'Optional -> Maybe Permissions
NewTeamMember' 'Optional -> PermissionType 'Optional
forall (tag :: PermissionTag).
NewTeamMember' tag -> PermissionType tag
_nPermissions (NewTeamMember' 'Optional -> Maybe Permissions)
-> (TeamMember' 'Optional -> NewTeamMember' 'Optional)
-> TeamMember' 'Optional
-> Maybe Permissions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TeamMember' 'Optional -> NewTeamMember' 'Optional
forall (tag :: PermissionTag).
TeamMember' tag -> NewTeamMember' tag
_newTeamMember

permissions :: Lens (TeamMember' tag1) (TeamMember' tag2) (PermissionType tag1) (PermissionType tag2)
permissions :: forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions = (NewTeamMember' tag1 -> f (NewTeamMember' tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
forall (tag :: PermissionTag) (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(NewTeamMember' tag -> f (NewTeamMember' tag))
-> TeamMember' tag -> f (TeamMember' tag)
newTeamMember ((NewTeamMember' tag1 -> f (NewTeamMember' tag2))
 -> TeamMember' tag1 -> f (TeamMember' tag2))
-> ((PermissionType tag1 -> f (PermissionType tag2))
    -> NewTeamMember' tag1 -> f (NewTeamMember' tag2))
-> (PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1
-> f (TeamMember' tag2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PermissionType tag1 -> f (PermissionType tag2))
-> NewTeamMember' tag1 -> f (NewTeamMember' tag2)
forall (tag :: PermissionTag) (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(PermissionType tag -> f (PermissionType tag))
-> NewTeamMember' tag -> f (NewTeamMember' tag)
nPermissions

invitation :: Lens' TeamMember (Maybe (UserId, UTCTimeMillis))
invitation :: Lens' TeamMember (Maybe (UserId, UTCTimeMillis))
invitation = (NewTeamMember -> f NewTeamMember) -> TeamMember -> f TeamMember
forall (tag :: PermissionTag) (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(NewTeamMember' tag -> f (NewTeamMember' tag))
-> TeamMember' tag -> f (TeamMember' tag)
newTeamMember ((NewTeamMember -> f NewTeamMember) -> TeamMember -> f TeamMember)
-> ((Maybe (UserId, UTCTimeMillis)
     -> f (Maybe (UserId, UTCTimeMillis)))
    -> NewTeamMember -> f NewTeamMember)
-> (Maybe (UserId, UTCTimeMillis)
    -> f (Maybe (UserId, UTCTimeMillis)))
-> TeamMember
-> f TeamMember
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe (UserId, UTCTimeMillis)
 -> f (Maybe (UserId, UTCTimeMillis)))
-> NewTeamMember -> f NewTeamMember
forall (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(Maybe (UserId, UTCTimeMillis)
 -> f (Maybe (UserId, UTCTimeMillis)))
-> NewTeamMember' tag -> f (NewTeamMember' tag)
nInvitation

setOptionalPerms :: (TeamMember -> Bool) -> TeamMember -> TeamMember' 'Optional
setOptionalPerms :: (TeamMember -> Bool) -> TeamMember -> TeamMember' 'Optional
setOptionalPerms TeamMember -> Bool
withPerms TeamMember
m = TeamMember
m TeamMember
-> (TeamMember -> TeamMember' 'Optional) -> TeamMember' 'Optional
forall a b. a -> (a -> b) -> b
& (Permissions -> Identity (Maybe Permissions))
-> TeamMember -> Identity (TeamMember' 'Optional)
(PermissionType 'Required -> Identity (PermissionType 'Optional))
-> TeamMember -> Identity (TeamMember' 'Optional)
forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions ((Permissions -> Identity (Maybe Permissions))
 -> TeamMember -> Identity (TeamMember' 'Optional))
-> (Permissions -> Maybe Permissions)
-> TeamMember
-> TeamMember' 'Optional
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Bool -> Permissions -> Maybe Permissions
setPerm (TeamMember -> Bool
withPerms TeamMember
m)

setOptionalPermsMany :: (TeamMember -> Bool) -> TeamMemberList -> TeamMemberList' 'Optional
setOptionalPermsMany :: (TeamMember -> Bool) -> TeamMemberList -> TeamMemberList' 'Optional
setOptionalPermsMany TeamMember -> Bool
withPerms TeamMemberList
l =
  TeamMemberList
l {_teamMembers = map (setOptionalPerms withPerms) (_teamMembers l)}

-- Note [hidden team roles]
--
-- The problem: the mapping between 'Role' and 'Permissions' is fixed by external contracts:
-- client apps treat permission bit matrices as opaque role identifiers, so if we add new
-- permission flags, things will break there.
--
-- "Hidden" in "HiddenPerm", therefore, refers to a permission hidden from
-- clients, thereby making it internal to the backend.
--
-- The solution: add new permission bits to 'HiddenPerm', 'HiddenPermissions', and make
-- 'hasPermission', 'mayGrantPermission' polymorphic.  Now you can check both for the hidden
-- permission bits and the old ones that we share with the client apps.

-- | See Note [hidden team roles]
data HiddenPerm
  = ChangeLegalHoldTeamSettings
  | ChangeLegalHoldUserSettings
  | ViewLegalHoldUserSettings
  | ChangeTeamFeature
  | ChangeTeamSearchVisibility
  | ViewTeamSearchVisibility
  | ViewSameTeamEmails
  | ReadIdp
  | CreateUpdateDeleteIdp
  | CreateReadDeleteScimToken
  | -- | this has its own permission because we're not sure how
    -- efficient this end-point is.  better not let all team members
    -- play with it unless we have to.
    DownloadTeamMembersCsv
  | ChangeTeamMemberProfiles
  | SearchContacts
  deriving (HiddenPerm -> HiddenPerm -> Bool
(HiddenPerm -> HiddenPerm -> Bool)
-> (HiddenPerm -> HiddenPerm -> Bool) -> Eq HiddenPerm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HiddenPerm -> HiddenPerm -> Bool
== :: HiddenPerm -> HiddenPerm -> Bool
$c/= :: HiddenPerm -> HiddenPerm -> Bool
/= :: HiddenPerm -> HiddenPerm -> Bool
Eq, Eq HiddenPerm
Eq HiddenPerm =>
(HiddenPerm -> HiddenPerm -> Ordering)
-> (HiddenPerm -> HiddenPerm -> Bool)
-> (HiddenPerm -> HiddenPerm -> Bool)
-> (HiddenPerm -> HiddenPerm -> Bool)
-> (HiddenPerm -> HiddenPerm -> Bool)
-> (HiddenPerm -> HiddenPerm -> HiddenPerm)
-> (HiddenPerm -> HiddenPerm -> HiddenPerm)
-> Ord HiddenPerm
HiddenPerm -> HiddenPerm -> Bool
HiddenPerm -> HiddenPerm -> Ordering
HiddenPerm -> HiddenPerm -> HiddenPerm
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HiddenPerm -> HiddenPerm -> Ordering
compare :: HiddenPerm -> HiddenPerm -> Ordering
$c< :: HiddenPerm -> HiddenPerm -> Bool
< :: HiddenPerm -> HiddenPerm -> Bool
$c<= :: HiddenPerm -> HiddenPerm -> Bool
<= :: HiddenPerm -> HiddenPerm -> Bool
$c> :: HiddenPerm -> HiddenPerm -> Bool
> :: HiddenPerm -> HiddenPerm -> Bool
$c>= :: HiddenPerm -> HiddenPerm -> Bool
>= :: HiddenPerm -> HiddenPerm -> Bool
$cmax :: HiddenPerm -> HiddenPerm -> HiddenPerm
max :: HiddenPerm -> HiddenPerm -> HiddenPerm
$cmin :: HiddenPerm -> HiddenPerm -> HiddenPerm
min :: HiddenPerm -> HiddenPerm -> HiddenPerm
Ord, Int -> HiddenPerm -> ShowS
[HiddenPerm] -> ShowS
HiddenPerm -> String
(Int -> HiddenPerm -> ShowS)
-> (HiddenPerm -> String)
-> ([HiddenPerm] -> ShowS)
-> Show HiddenPerm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HiddenPerm -> ShowS
showsPrec :: Int -> HiddenPerm -> ShowS
$cshow :: HiddenPerm -> String
show :: HiddenPerm -> String
$cshowList :: [HiddenPerm] -> ShowS
showList :: [HiddenPerm] -> ShowS
Show)

-- | See Note [hidden team roles]
data HiddenPermissions = HiddenPermissions
  { HiddenPermissions -> Set HiddenPerm
_hself :: Set HiddenPerm,
    HiddenPermissions -> Set HiddenPerm
_hcopy :: Set HiddenPerm
  }
  deriving (HiddenPermissions -> HiddenPermissions -> Bool
(HiddenPermissions -> HiddenPermissions -> Bool)
-> (HiddenPermissions -> HiddenPermissions -> Bool)
-> Eq HiddenPermissions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HiddenPermissions -> HiddenPermissions -> Bool
== :: HiddenPermissions -> HiddenPermissions -> Bool
$c/= :: HiddenPermissions -> HiddenPermissions -> Bool
/= :: HiddenPermissions -> HiddenPermissions -> Bool
Eq, Eq HiddenPermissions
Eq HiddenPermissions =>
(HiddenPermissions -> HiddenPermissions -> Ordering)
-> (HiddenPermissions -> HiddenPermissions -> Bool)
-> (HiddenPermissions -> HiddenPermissions -> Bool)
-> (HiddenPermissions -> HiddenPermissions -> Bool)
-> (HiddenPermissions -> HiddenPermissions -> Bool)
-> (HiddenPermissions -> HiddenPermissions -> HiddenPermissions)
-> (HiddenPermissions -> HiddenPermissions -> HiddenPermissions)
-> Ord HiddenPermissions
HiddenPermissions -> HiddenPermissions -> Bool
HiddenPermissions -> HiddenPermissions -> Ordering
HiddenPermissions -> HiddenPermissions -> HiddenPermissions
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HiddenPermissions -> HiddenPermissions -> Ordering
compare :: HiddenPermissions -> HiddenPermissions -> Ordering
$c< :: HiddenPermissions -> HiddenPermissions -> Bool
< :: HiddenPermissions -> HiddenPermissions -> Bool
$c<= :: HiddenPermissions -> HiddenPermissions -> Bool
<= :: HiddenPermissions -> HiddenPermissions -> Bool
$c> :: HiddenPermissions -> HiddenPermissions -> Bool
> :: HiddenPermissions -> HiddenPermissions -> Bool
$c>= :: HiddenPermissions -> HiddenPermissions -> Bool
>= :: HiddenPermissions -> HiddenPermissions -> Bool
$cmax :: HiddenPermissions -> HiddenPermissions -> HiddenPermissions
max :: HiddenPermissions -> HiddenPermissions -> HiddenPermissions
$cmin :: HiddenPermissions -> HiddenPermissions -> HiddenPermissions
min :: HiddenPermissions -> HiddenPermissions -> HiddenPermissions
Ord, Int -> HiddenPermissions -> ShowS
[HiddenPermissions] -> ShowS
HiddenPermissions -> String
(Int -> HiddenPermissions -> ShowS)
-> (HiddenPermissions -> String)
-> ([HiddenPermissions] -> ShowS)
-> Show HiddenPermissions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HiddenPermissions -> ShowS
showsPrec :: Int -> HiddenPermissions -> ShowS
$cshow :: HiddenPermissions -> String
show :: HiddenPermissions -> String
$cshowList :: [HiddenPermissions] -> ShowS
showList :: [HiddenPermissions] -> ShowS
Show)

makeLenses ''HiddenPermissions

rolePermissions :: Role -> Permissions
rolePermissions :: Role -> Permissions
rolePermissions Role
role = Set Perm -> Set Perm -> Permissions
Permissions Set Perm
p Set Perm
p where p :: Set Perm
p = Role -> Set Perm
rolePerms Role
role

permissionsRole :: Permissions -> Maybe Role
permissionsRole :: Permissions -> Maybe Role
permissionsRole (Permissions Set Perm
p Set Perm
p') =
  if Set Perm
p Set Perm -> Set Perm -> Bool
forall a. Eq a => a -> a -> Bool
/= Set Perm
p'
    then do
      -- we never did use @p /= p'@ for anything, fingers crossed that it doesn't occur anywhere
      -- in the wild.  but if it does, this implementation prevents privilege escalation.
      let p'' :: Set Perm
p'' = Set Perm -> Set Perm -> Set Perm
forall a. Ord a => Set a -> Set a -> Set a
Set.intersection Set Perm
p Set Perm
p'
       in Permissions -> Maybe Role
permissionsRole (Set Perm -> Set Perm -> Permissions
Permissions Set Perm
p'' Set Perm
p'')
    else Set Perm -> Maybe Role
permsRole Set Perm
p
  where
    permsRole :: Set Perm -> Maybe Role
    permsRole :: Set Perm -> Maybe Role
permsRole Set Perm
perms =
      [Role] -> Maybe Role
forall a. [a] -> Maybe a
listToMaybe
        [ Role
role
          | Role
role <- [Role
forall a. Bounded a => a
minBound ..],
            -- if a there is a role that is strictly less permissive than the perms set that
            -- we encounter, we downgrade.  this shouldn't happen in real life, but it has
            -- happened to very old users on a staging environment, where a user (probably)
            -- was create before the current publicly visible permissions had been stabilized.
            Role -> Set Perm
rolePerms Role
role Set Perm -> Set Perm -> Bool
forall a. Ord a => Set a -> Set a -> Bool
`Set.isSubsetOf` Set Perm
perms
        ]

-- | Internal function for 'rolePermissions'.  (It works iff the two sets in 'Permissions' are
-- identical for every 'Role', otherwise it'll need to be specialized for the resp. sides.)
rolePerms :: Role -> Set Perm
rolePerms :: Role -> Set Perm
rolePerms Role
RoleOwner =
  Role -> Set Perm
rolePerms Role
RoleAdmin
    Set Perm -> Set Perm -> Set Perm
forall a. Semigroup a => a -> a -> a
<> [Perm] -> Set Perm
forall a. Ord a => [a] -> Set a
Set.fromList
      [ Perm
GetBilling,
        Perm
SetBilling,
        Perm
DeleteTeam
      ]
rolePerms Role
RoleAdmin =
  Role -> Set Perm
rolePerms Role
RoleMember
    Set Perm -> Set Perm -> Set Perm
forall a. Semigroup a => a -> a -> a
<> [Perm] -> Set Perm
forall a. Ord a => [a] -> Set a
Set.fromList
      [ Perm
AddTeamMember,
        Perm
RemoveTeamMember,
        Perm
SetTeamData,
        Perm
SetMemberPermissions
      ]
rolePerms Role
RoleMember =
  Role -> Set Perm
rolePerms Role
RoleExternalPartner
    Set Perm -> Set Perm -> Set Perm
forall a. Semigroup a => a -> a -> a
<> [Perm] -> Set Perm
forall a. Ord a => [a] -> Set a
Set.fromList
      [ Perm
DeleteConversation,
        Perm
AddRemoveConvMember,
        Perm
ModifyConvName,
        Perm
GetMemberPermissions
      ]
rolePerms Role
RoleExternalPartner =
  [Perm] -> Set Perm
forall a. Ord a => [a] -> Set a
Set.fromList
    [ Perm
CreateConversation,
      Perm
GetTeamConversations
    ]

roleHiddenPermissions :: Role -> HiddenPermissions
roleHiddenPermissions :: Role -> HiddenPermissions
roleHiddenPermissions Role
role = Set HiddenPerm -> Set HiddenPerm -> HiddenPermissions
HiddenPermissions Set HiddenPerm
p Set HiddenPerm
p
  where
    p :: Set HiddenPerm
p = Role -> Set HiddenPerm
roleHiddenPerms Role
role
    roleHiddenPerms :: Role -> Set HiddenPerm
    roleHiddenPerms :: Role -> Set HiddenPerm
roleHiddenPerms Role
RoleOwner = Role -> Set HiddenPerm
roleHiddenPerms Role
RoleAdmin
    roleHiddenPerms Role
RoleAdmin =
      (Role -> Set HiddenPerm
roleHiddenPerms Role
RoleMember <>) (Set HiddenPerm -> Set HiddenPerm)
-> Set HiddenPerm -> Set HiddenPerm
forall a b. (a -> b) -> a -> b
$
        [HiddenPerm] -> Set HiddenPerm
forall a. Ord a => [a] -> Set a
Set.fromList
          [ HiddenPerm
ChangeLegalHoldTeamSettings,
            HiddenPerm
ChangeLegalHoldUserSettings,
            HiddenPerm
ChangeTeamSearchVisibility,
            HiddenPerm
ChangeTeamFeature,
            HiddenPerm
ChangeTeamMemberProfiles,
            HiddenPerm
ReadIdp,
            HiddenPerm
CreateUpdateDeleteIdp,
            HiddenPerm
CreateReadDeleteScimToken,
            HiddenPerm
DownloadTeamMembersCsv
          ]
    roleHiddenPerms Role
RoleMember =
      (Role -> Set HiddenPerm
roleHiddenPerms Role
RoleExternalPartner <>) (Set HiddenPerm -> Set HiddenPerm)
-> Set HiddenPerm -> Set HiddenPerm
forall a b. (a -> b) -> a -> b
$
        [HiddenPerm] -> Set HiddenPerm
forall a. Ord a => [a] -> Set a
Set.fromList
          [ HiddenPerm
ViewSameTeamEmails,
            HiddenPerm
SearchContacts
          ]
    roleHiddenPerms Role
RoleExternalPartner =
      [HiddenPerm] -> Set HiddenPerm
forall a. Ord a => [a] -> Set a
Set.fromList
        [ HiddenPerm
ViewLegalHoldUserSettings,
          HiddenPerm
ViewTeamSearchVisibility
        ]

isAdminOrOwner :: Permissions -> Bool
isAdminOrOwner :: Permissions -> Bool
isAdminOrOwner Permissions
perms =
  case Permissions -> Maybe Role
permissionsRole Permissions
perms of
    Just Role
RoleOwner -> Bool
True
    Just Role
RoleAdmin -> Bool
True
    Just Role
RoleMember -> Bool
False
    Just Role
RoleExternalPartner -> Bool
False
    Maybe Role
Nothing -> Bool
False

-- | See Note [hidden team roles]
class IsPerm perm where
  type PermError (e :: perm) :: GalleyError

  roleHasPerm :: Role -> perm -> Bool
  roleGrantsPerm :: Role -> perm -> Bool
  hasPermission :: TeamMember -> perm -> Bool
  hasPermission TeamMember
tm perm
perm = Bool -> (Role -> Bool) -> Maybe Role -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Role -> perm -> Bool
forall perm. IsPerm perm => Role -> perm -> Bool
`roleHasPerm` perm
perm) (Maybe Role -> Bool)
-> (Permissions -> Maybe Role) -> Permissions -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permissions -> Maybe Role
permissionsRole (Permissions -> Bool) -> Permissions -> Bool
forall a b. (a -> b) -> a -> b
$ TeamMember
tm TeamMember
-> Getting Permissions TeamMember Permissions -> Permissions
forall s a. s -> Getting a s a -> a
^. Getting Permissions TeamMember Permissions
(PermissionType 'Required
 -> Const Permissions (PermissionType 'Required))
-> TeamMember -> Const Permissions TeamMember
forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions
  mayGrantPermission :: TeamMember -> perm -> Bool
  mayGrantPermission TeamMember
tm perm
perm = Bool -> (Role -> Bool) -> Maybe Role -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Role -> perm -> Bool
forall perm. IsPerm perm => Role -> perm -> Bool
`roleGrantsPerm` perm
perm) (Maybe Role -> Bool)
-> (Permissions -> Maybe Role) -> Permissions -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permissions -> Maybe Role
permissionsRole (Permissions -> Bool) -> Permissions -> Bool
forall a b. (a -> b) -> a -> b
$ TeamMember
tm TeamMember
-> Getting Permissions TeamMember Permissions -> Permissions
forall s a. s -> Getting a s a -> a
^. Getting Permissions TeamMember Permissions
(PermissionType 'Required
 -> Const Permissions (PermissionType 'Required))
-> TeamMember -> Const Permissions TeamMember
forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions

instance IsPerm Perm where
  type PermError p = 'MissingPermission ('Just p)

  roleHasPerm :: Role -> Perm -> Bool
roleHasPerm Role
r Perm
p = Perm
p Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` ((Role -> Permissions
rolePermissions Role
r).self)
  roleGrantsPerm :: Role -> Perm -> Bool
roleGrantsPerm Role
r Perm
p = Perm
p Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` ((Role -> Permissions
rolePermissions Role
r).copy)
  hasPermission :: TeamMember -> Perm -> Bool
hasPermission TeamMember
tm Perm
p = Perm
p Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` ((TeamMember
tm TeamMember
-> Getting Permissions TeamMember Permissions -> Permissions
forall s a. s -> Getting a s a -> a
^. Getting Permissions TeamMember Permissions
(PermissionType 'Required
 -> Const Permissions (PermissionType 'Required))
-> TeamMember -> Const Permissions TeamMember
forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions).self)
  mayGrantPermission :: TeamMember -> Perm -> Bool
mayGrantPermission TeamMember
tm Perm
p = Perm
p Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` ((TeamMember
tm TeamMember
-> Getting Permissions TeamMember Permissions -> Permissions
forall s a. s -> Getting a s a -> a
^. Getting Permissions TeamMember Permissions
(PermissionType 'Required
 -> Const Permissions (PermissionType 'Required))
-> TeamMember -> Const Permissions TeamMember
forall (tag1 :: PermissionTag) (tag2 :: PermissionTag)
       (f :: * -> *).
Functor f =>
(PermissionType tag1 -> f (PermissionType tag2))
-> TeamMember' tag1 -> f (TeamMember' tag2)
permissions).copy)

instance IsPerm HiddenPerm where
  type PermError p = OperationDenied

  roleHasPerm :: Role -> HiddenPerm -> Bool
roleHasPerm Role
r HiddenPerm
p = HiddenPerm
p HiddenPerm -> Set HiddenPerm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` (Role -> HiddenPermissions
roleHiddenPermissions Role
r HiddenPermissions
-> Getting (Set HiddenPerm) HiddenPermissions (Set HiddenPerm)
-> Set HiddenPerm
forall s a. s -> Getting a s a -> a
^. Getting (Set HiddenPerm) HiddenPermissions (Set HiddenPerm)
Lens' HiddenPermissions (Set HiddenPerm)
hself)
  roleGrantsPerm :: Role -> HiddenPerm -> Bool
roleGrantsPerm Role
r HiddenPerm
p = HiddenPerm
p HiddenPerm -> Set HiddenPerm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` (Role -> HiddenPermissions
roleHiddenPermissions Role
r HiddenPermissions
-> Getting (Set HiddenPerm) HiddenPermissions (Set HiddenPerm)
-> Set HiddenPerm
forall s a. s -> Getting a s a -> a
^. Getting (Set HiddenPerm) HiddenPermissions (Set HiddenPerm)
Lens' HiddenPermissions (Set HiddenPerm)
hcopy)