-- 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 Galley.Cassandra.Team
  ( interpretTeamStoreToCassandra,
    interpretTeamMemberStoreToCassandra,
    interpretTeamListToCassandra,
    interpretInternalTeamListToCassandra,
    interpretTeamMemberStoreToCassandraWithPaging,
  )
where

import Cassandra
import Cassandra.Util
import Control.Exception (ErrorCall (ErrorCall))
import Control.Lens hiding ((<|))
import Control.Monad.Catch (throwM)
import Control.Monad.Extra (ifM)
import Data.ByteString.Conversion (toByteString')
import Data.Id as Id
import Data.Json.Util (UTCTimeMillis (..))
import Data.LegalHold (UserLegalHoldStatus (..), defUserLegalHoldStatus)
import Data.Map.Strict qualified as Map
import Data.Range
import Data.Set qualified as Set
import Data.Text.Encoding
import Data.UUID.V4 (nextRandom)
import Galley.Aws qualified as Aws
import Galley.Cassandra.Conversation qualified as C
import Galley.Cassandra.LegalHold (isTeamLegalholdWhitelisted)
import Galley.Cassandra.Queries qualified as Cql
import Galley.Cassandra.Store
import Galley.Cassandra.Util
import Galley.Effects.ListItems
import Galley.Effects.TeamMemberStore
import Galley.Effects.TeamStore (TeamStore (..))
import Galley.Env
import Galley.Monad
import Galley.Options
import Galley.Types.Teams
import Imports hiding (Set, max)
import Polysemy
import Polysemy.Input
import Polysemy.TinyLog
import UnliftIO qualified
import Wire.API.Routes.Internal.Galley.TeamsIntra
import Wire.API.Team
import Wire.API.Team.Conversation
import Wire.API.Team.Feature
import Wire.API.Team.Member
import Wire.API.Team.Permission (Perm (SetBilling), Permissions, self)
import Wire.Sem.Paging.Cassandra

interpretTeamStoreToCassandra ::
  ( Member (Embed IO) r,
    Member (Input Env) r,
    Member (Input ClientState) r,
    Member TinyLog r
  ) =>
  FeatureDefaults LegalholdConfig ->
  Sem (TeamStore ': r) a ->
  Sem r a
interpretTeamStoreToCassandra :: forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input Env) r,
 Member (Input ClientState) r, Member TinyLog r) =>
FeatureDefaults LegalholdConfig -> Sem (TeamStore : r) a -> Sem r a
interpretTeamStoreToCassandra FeatureDefaults LegalholdConfig
lh = (forall (rInitial :: EffectRow) x.
 TeamStore (Sem rInitial) x -> Sem r x)
-> Sem (TeamStore : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret ((forall (rInitial :: EffectRow) x.
  TeamStore (Sem rInitial) x -> Sem r x)
 -> Sem (TeamStore : r) a -> Sem r a)
-> (forall (rInitial :: EffectRow) x.
    TeamStore (Sem rInitial) x -> Sem r x)
-> Sem (TeamStore : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ \case
  CreateTeamMember TeamId
tid TeamMember
mem -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.CreateTeamMember"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> TeamMember -> Client ()
addTeamMember TeamId
tid TeamMember
mem)
  SetTeamMemberPermissions Permissions
perm0 TeamId
tid UserId
uid Permissions
perm1 -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SetTeamMemberPermissions"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Permissions -> TeamId -> UserId -> Permissions -> Client ()
updateTeamMember Permissions
perm0 TeamId
tid UserId
uid Permissions
perm1)
  CreateTeam Maybe TeamId
t UserId
uid Range 1 256 Text
n Icon
i Maybe (Range 1 256 Text)
k TeamBinding
b -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.CreateTeam"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Maybe TeamId
-> UserId
-> Range 1 256 Text
-> Icon
-> Maybe (Range 1 256 Text)
-> TeamBinding
-> Client Team
createTeam Maybe TeamId
t UserId
uid Range 1 256 Text
n Icon
i Maybe (Range 1 256 Text)
k TeamBinding
b)
  DeleteTeamMember TeamId
tid UserId
uid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.DeleteTeamMember"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> UserId -> Client ()
removeTeamMember TeamId
tid UserId
uid)
  GetBillingTeamMembers TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetBillingTeamMembers"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client [UserId]
listBillingTeamMembers TeamId
tid)
  GetTeamAdmins TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamAdmins"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client [UserId]
listTeamAdmins TeamId
tid)
  GetTeam TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeam"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client (Maybe TeamData)
team TeamId
tid)
  GetTeamName TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamName"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client (Maybe Text)
getTeamName TeamId
tid)
  GetTeamConversation TeamId
tid ConvId
cid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamConversation"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> ConvId -> Client (Maybe TeamConversation)
teamConversation TeamId
tid ConvId
cid)
  GetTeamConversations TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamConversations"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client [TeamConversation]
getTeamConversations TeamId
tid)
  SelectTeams UserId
uid [TeamId]
tids -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SelectTeams"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (UserId -> [TeamId] -> Client [TeamId]
teamIdsOf UserId
uid [TeamId]
tids)
  GetTeamMember TeamId
tid UserId
uid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamMember"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (FeatureDefaults LegalholdConfig
-> TeamId -> UserId -> Client (Maybe TeamMember)
teamMember FeatureDefaults LegalholdConfig
lh TeamId
tid UserId
uid)
  GetTeamMembersWithLimit TeamId
tid Range 1 HardTruncationLimit Int32
n -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamMembersWithLimit"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (FeatureDefaults LegalholdConfig
-> TeamId
-> Range 1 HardTruncationLimit Int32
-> Client (TeamMemberList' 'Required)
teamMembersWithLimit FeatureDefaults LegalholdConfig
lh TeamId
tid Range 1 HardTruncationLimit Int32
n)
  GetTeamMembers TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamMembers"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (FeatureDefaults LegalholdConfig -> TeamId -> Client [TeamMember]
teamMembersCollectedWithPagination FeatureDefaults LegalholdConfig
lh TeamId
tid)
  SelectTeamMembers TeamId
tid [UserId]
uids -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SelectTeamMembers"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (FeatureDefaults LegalholdConfig
-> TeamId -> [UserId] -> Client [TeamMember]
teamMembersLimited FeatureDefaults LegalholdConfig
lh TeamId
tid [UserId]
uids)
  GetUserTeams UserId
uid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetUserTeams"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (UserId -> Client [TeamId]
userTeams UserId
uid)
  GetUsersTeams [UserId]
uids -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetUsersTeams"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient ([UserId] -> Client (Map UserId TeamId)
usersTeams [UserId]
uids)
  GetOneUserTeam UserId
uid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetOneUserTeam"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (UserId -> Client (Maybe TeamId)
oneUserTeam UserId
uid)
  GetTeamsBindings [TeamId]
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamsBindings"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient ([TeamId] -> Client [TeamBinding]
getTeamsBindings [TeamId]
tid)
  GetTeamBinding TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamBinding"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client (Maybe TeamBinding)
getTeamBinding TeamId
tid)
  GetTeamCreationTime TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetTeamCreationTime"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client (Maybe TeamCreationTime)
teamCreationTime TeamId
tid)
  DeleteTeam TeamId
tid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.DeleteTeam"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> Client ()
deleteTeam TeamId
tid)
  DeleteTeamConversation TeamId
tid ConvId
cid -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.DeleteTeamConversation"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> ConvId -> Client ()
removeTeamConv TeamId
tid ConvId
cid)
  SetTeamData TeamId
tid TeamUpdateData
upd -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SetTeamData"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> TeamUpdateData -> Client ()
updateTeam TeamId
tid TeamUpdateData
upd)
  SetTeamStatus TeamId
tid TeamStatus
st -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SetTeamStatus"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (TeamId -> TeamStatus -> Client ()
updateTeamStatus TeamId
tid TeamStatus
st)
  TeamStore (Sem rInitial) x
FanoutLimit -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.FanoutLimit"
    App x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input Env) r) =>
App a -> Sem r a
embedApp (Opts -> x
Opts -> Range 1 HardTruncationLimit Int32
currentFanoutLimit (Opts -> x) -> App Opts -> App x
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting Opts Env Opts -> App Opts
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Opts Env Opts
Lens' Env Opts
options)
  TeamStore (Sem rInitial) x
GetLegalHoldFlag -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.GetLegalHoldFlag"
    Getting
  (FeatureDefaults LegalholdConfig)
  Env
  (FeatureDefaults LegalholdConfig)
-> Env -> FeatureDefaults LegalholdConfig
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((Opts -> Const (FeatureDefaults LegalholdConfig) Opts)
-> Env -> Const (FeatureDefaults LegalholdConfig) Env
Lens' Env Opts
options ((Opts -> Const (FeatureDefaults LegalholdConfig) Opts)
 -> Env -> Const (FeatureDefaults LegalholdConfig) Env)
-> ((FeatureDefaults LegalholdConfig
     -> Const
          (FeatureDefaults LegalholdConfig)
          (FeatureDefaults LegalholdConfig))
    -> Opts -> Const (FeatureDefaults LegalholdConfig) Opts)
-> Getting
     (FeatureDefaults LegalholdConfig)
     Env
     (FeatureDefaults LegalholdConfig)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Settings -> Const (FeatureDefaults LegalholdConfig) Settings)
-> Opts -> Const (FeatureDefaults LegalholdConfig) Opts
Lens' Opts Settings
settings ((Settings -> Const (FeatureDefaults LegalholdConfig) Settings)
 -> Opts -> Const (FeatureDefaults LegalholdConfig) Opts)
-> ((FeatureDefaults LegalholdConfig
     -> Const
          (FeatureDefaults LegalholdConfig)
          (FeatureDefaults LegalholdConfig))
    -> Settings -> Const (FeatureDefaults LegalholdConfig) Settings)
-> (FeatureDefaults LegalholdConfig
    -> Const
         (FeatureDefaults LegalholdConfig)
         (FeatureDefaults LegalholdConfig))
-> Opts
-> Const (FeatureDefaults LegalholdConfig) Opts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FeatureFlags
 -> Const (FeatureDefaults LegalholdConfig) FeatureFlags)
-> Settings -> Const (FeatureDefaults LegalholdConfig) Settings
Lens' Settings FeatureFlags
featureFlags ((FeatureFlags
  -> Const (FeatureDefaults LegalholdConfig) FeatureFlags)
 -> Settings -> Const (FeatureDefaults LegalholdConfig) Settings)
-> ((FeatureDefaults LegalholdConfig
     -> Const
          (FeatureDefaults LegalholdConfig)
          (FeatureDefaults LegalholdConfig))
    -> FeatureFlags
    -> Const (FeatureDefaults LegalholdConfig) FeatureFlags)
-> (FeatureDefaults LegalholdConfig
    -> Const
         (FeatureDefaults LegalholdConfig)
         (FeatureDefaults LegalholdConfig))
-> Settings
-> Const (FeatureDefaults LegalholdConfig) Settings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FeatureFlags -> FeatureDefaults LegalholdConfig)
-> (FeatureDefaults LegalholdConfig
    -> Const
         (FeatureDefaults LegalholdConfig)
         (FeatureDefaults LegalholdConfig))
-> FeatureFlags
-> Const (FeatureDefaults LegalholdConfig) FeatureFlags
forall (p :: * -> * -> *) (f :: * -> *) s a.
(Profunctor p, Contravariant f) =>
(s -> a) -> Optic' p f s a
to FeatureFlags -> FeatureDefaults LegalholdConfig
forall {k} (x :: k) (f :: k -> *) (xs :: [k]).
NpProject x xs =>
NP f xs -> f x
npProject) (Env -> x) -> Sem r Env -> Sem r x
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sem r Env
forall i (r :: EffectRow). Member (Input i) r => Sem r i
input
  EnqueueTeamEvent TeamEvent
e -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.EnqueueTeamEvent"
    Maybe Env
menv <- (Env -> Maybe Env) -> Sem r (Maybe Env)
forall i j (r :: EffectRow).
Member (Input i) r =>
(i -> j) -> Sem r j
inputs (Getting (Maybe Env) Env (Maybe Env) -> Env -> Maybe Env
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Env) Env (Maybe Env)
Lens' Env (Maybe Env)
aEnv)
    Maybe Env -> (Env -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ Maybe Env
menv ((Env -> Sem r ()) -> Sem r ()) -> (Env -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ \Env
env ->
      forall (m :: * -> *) (r :: EffectRow) a.
Member (Embed m) r =>
m a -> Sem r a
embed @IO (Env -> Amazon () -> IO ()
forall (m :: * -> *) a. MonadIO m => Env -> Amazon a -> m a
Aws.execute Env
env (TeamEvent -> Amazon ()
Aws.enqueue TeamEvent
e))
  SelectTeamMembersPaginated TeamId
tid [UserId]
uids Maybe (PagingState CassandraPaging TeamMember)
mps PagingBounds CassandraPaging TeamMember
lim -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamStore.SelectTeamMembersPaginated"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (FeatureDefaults LegalholdConfig
-> TeamId
-> [UserId]
-> Maybe PagingState
-> Range 1 HardTruncationLimit Int32
-> Client (PageWithState TeamMember)
selectSomeTeamMembersPaginated FeatureDefaults LegalholdConfig
lh TeamId
tid [UserId]
uids Maybe PagingState
Maybe (PagingState CassandraPaging TeamMember)
mps PagingBounds CassandraPaging TeamMember
Range 1 HardTruncationLimit Int32
lim)

interpretTeamListToCassandra ::
  ( Member (Embed IO) r,
    Member (Input ClientState) r,
    Member TinyLog r
  ) =>
  Sem (ListItems LegacyPaging TeamId ': r) a ->
  Sem r a
interpretTeamListToCassandra :: forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r,
 Member TinyLog r) =>
Sem (ListItems LegacyPaging TeamId : r) a -> Sem r a
interpretTeamListToCassandra = (forall (rInitial :: EffectRow) x.
 ListItems LegacyPaging TeamId (Sem rInitial) x -> Sem r x)
-> Sem (ListItems LegacyPaging TeamId : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret ((forall (rInitial :: EffectRow) x.
  ListItems LegacyPaging TeamId (Sem rInitial) x -> Sem r x)
 -> Sem (ListItems LegacyPaging TeamId : r) a -> Sem r a)
-> (forall (rInitial :: EffectRow) x.
    ListItems LegacyPaging TeamId (Sem rInitial) x -> Sem r x)
-> Sem (ListItems LegacyPaging TeamId : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ \case
  ListItems UserId
uid Maybe (PagingState LegacyPaging TeamId)
ps PagingBounds LegacyPaging TeamId
lim -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamList.ListItems"
    Client (ResultSet TeamId) -> Sem r (ResultSet TeamId)
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Client (ResultSet TeamId) -> Sem r (ResultSet TeamId))
-> Client (ResultSet TeamId) -> Sem r (ResultSet TeamId)
forall a b. (a -> b) -> a -> b
$ UserId
-> Maybe TeamId -> Range 1 100 Int32 -> Client (ResultSet TeamId)
teamIdsFrom UserId
uid Maybe (PagingState LegacyPaging TeamId)
Maybe TeamId
ps PagingBounds LegacyPaging TeamId
Range 1 100 Int32
lim

interpretInternalTeamListToCassandra ::
  ( Member (Embed IO) r,
    Member (Input ClientState) r,
    Member TinyLog r
  ) =>
  Sem (ListItems InternalPaging TeamId ': r) a ->
  Sem r a
interpretInternalTeamListToCassandra :: forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r,
 Member TinyLog r) =>
Sem (ListItems InternalPaging TeamId : r) a -> Sem r a
interpretInternalTeamListToCassandra = (forall (rInitial :: EffectRow) x.
 ListItems InternalPaging TeamId (Sem rInitial) x -> Sem r x)
-> Sem (ListItems InternalPaging TeamId : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret ((forall (rInitial :: EffectRow) x.
  ListItems InternalPaging TeamId (Sem rInitial) x -> Sem r x)
 -> Sem (ListItems InternalPaging TeamId : r) a -> Sem r a)
-> (forall (rInitial :: EffectRow) x.
    ListItems InternalPaging TeamId (Sem rInitial) x -> Sem r x)
-> Sem (ListItems InternalPaging TeamId : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ \case
  ListItems UserId
uid Maybe (PagingState InternalPaging TeamId)
mps PagingBounds InternalPaging TeamId
lim -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"InternalTeamList.ListItems"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Client x -> Sem r x) -> Client x -> Sem r x
forall a b. (a -> b) -> a -> b
$ case Maybe (PagingState InternalPaging TeamId)
mps of
      Maybe (PagingState InternalPaging TeamId)
Nothing -> do
        Page TeamId
page <- UserId -> Maybe TeamId -> Range 1 100 Int32 -> Client (Page TeamId)
teamIdsForPagination UserId
uid Maybe TeamId
forall a. Maybe a
Nothing PagingBounds InternalPaging TeamId
Range 1 100 Int32
lim
        Page TeamId
-> (TeamId -> Client TeamId) -> Client (InternalPage TeamId)
forall s a. Page s -> (s -> Client a) -> Client (InternalPage a)
mkInternalPage Page TeamId
page TeamId -> Client TeamId
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      Just PagingState InternalPaging TeamId
ps -> InternalPagingState TeamId -> Client (InternalPage TeamId)
forall a. InternalPagingState a -> Client (InternalPage a)
ipNext PagingState InternalPaging TeamId
InternalPagingState TeamId
ps

interpretTeamMemberStoreToCassandra ::
  ( Member (Embed IO) r,
    Member (Input ClientState) r,
    Member TinyLog r
  ) =>
  FeatureDefaults LegalholdConfig ->
  Sem (TeamMemberStore InternalPaging ': r) a ->
  Sem r a
interpretTeamMemberStoreToCassandra :: forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r,
 Member TinyLog r) =>
FeatureDefaults LegalholdConfig
-> Sem (TeamMemberStore InternalPaging : r) a -> Sem r a
interpretTeamMemberStoreToCassandra FeatureDefaults LegalholdConfig
lh = (forall (rInitial :: EffectRow) x.
 TeamMemberStore InternalPaging (Sem rInitial) x -> Sem r x)
-> Sem (TeamMemberStore InternalPaging : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret ((forall (rInitial :: EffectRow) x.
  TeamMemberStore InternalPaging (Sem rInitial) x -> Sem r x)
 -> Sem (TeamMemberStore InternalPaging : r) a -> Sem r a)
-> (forall (rInitial :: EffectRow) x.
    TeamMemberStore InternalPaging (Sem rInitial) x -> Sem r x)
-> Sem (TeamMemberStore InternalPaging : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ \case
  ListTeamMembers TeamId
tid Maybe (PagingState InternalPaging TeamMember)
mps PagingBounds InternalPaging TeamMember
lim -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamMemberStore.ListTeamMembers"
    Client x -> Sem r x
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Client x -> Sem r x) -> Client x -> Sem r x
forall a b. (a -> b) -> a -> b
$ case Maybe (PagingState InternalPaging TeamMember)
mps of
      Maybe (PagingState InternalPaging TeamMember)
Nothing -> do
        Page RawTeamMember
page <- TeamId
-> Maybe UserId
-> Range 1 HardTruncationLimit Int32
-> Client (Page RawTeamMember)
teamMembersForPagination TeamId
tid Maybe UserId
forall a. Maybe a
Nothing PagingBounds InternalPaging TeamMember
Range 1 HardTruncationLimit Int32
lim
        Page RawTeamMember
-> (RawTeamMember -> Client TeamMember)
-> Client (InternalPage TeamMember)
forall s a. Page s -> (s -> Client a) -> Client (InternalPage a)
mkInternalPage Page RawTeamMember
page (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
tid)
      Just PagingState InternalPaging TeamMember
ps -> InternalPagingState TeamMember -> Client (InternalPage TeamMember)
forall a. InternalPagingState a -> Client (InternalPage a)
ipNext PagingState InternalPaging TeamMember
InternalPagingState TeamMember
ps

interpretTeamMemberStoreToCassandraWithPaging ::
  ( Member (Embed IO) r,
    Member (Input ClientState) r,
    Member TinyLog r
  ) =>
  FeatureDefaults LegalholdConfig ->
  Sem (TeamMemberStore CassandraPaging ': r) a ->
  Sem r a
interpretTeamMemberStoreToCassandraWithPaging :: forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r,
 Member TinyLog r) =>
FeatureDefaults LegalholdConfig
-> Sem (TeamMemberStore CassandraPaging : r) a -> Sem r a
interpretTeamMemberStoreToCassandraWithPaging FeatureDefaults LegalholdConfig
lh = (forall (rInitial :: EffectRow) x.
 TeamMemberStore CassandraPaging (Sem rInitial) x -> Sem r x)
-> Sem (TeamMemberStore CassandraPaging : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: EffectRow) a.
FirstOrder e "interpret" =>
(forall (rInitial :: EffectRow) x. e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret ((forall (rInitial :: EffectRow) x.
  TeamMemberStore CassandraPaging (Sem rInitial) x -> Sem r x)
 -> Sem (TeamMemberStore CassandraPaging : r) a -> Sem r a)
-> (forall (rInitial :: EffectRow) x.
    TeamMemberStore CassandraPaging (Sem rInitial) x -> Sem r x)
-> Sem (TeamMemberStore CassandraPaging : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ \case
  ListTeamMembers TeamId
tid Maybe (PagingState CassandraPaging TeamMember)
mps PagingBounds CassandraPaging TeamMember
lim -> do
    ByteString -> Sem r ()
forall (r :: EffectRow). Member TinyLog r => ByteString -> Sem r ()
logEffect ByteString
"TeamMemberStore.ListTeamMembers"
    Client (PageWithState TeamMember)
-> Sem r (PageWithState TeamMember)
forall (r :: EffectRow) a.
(Member (Embed IO) r, Member (Input ClientState) r) =>
Client a -> Sem r a
embedClient (Client (PageWithState TeamMember)
 -> Sem r (PageWithState TeamMember))
-> Client (PageWithState TeamMember)
-> Sem r (PageWithState TeamMember)
forall a b. (a -> b) -> a -> b
$ FeatureDefaults LegalholdConfig
-> TeamId
-> Maybe PagingState
-> Range 1 HardTruncationLimit Int32
-> Client (PageWithState TeamMember)
teamMembersPageFrom FeatureDefaults LegalholdConfig
lh TeamId
tid Maybe PagingState
Maybe (PagingState CassandraPaging TeamMember)
mps PagingBounds CassandraPaging TeamMember
Range 1 HardTruncationLimit Int32
lim

createTeam ::
  Maybe TeamId ->
  UserId ->
  Range 1 256 Text ->
  Icon ->
  Maybe (Range 1 256 Text) ->
  TeamBinding ->
  Client Team
createTeam :: Maybe TeamId
-> UserId
-> Range 1 256 Text
-> Icon
-> Maybe (Range 1 256 Text)
-> TeamBinding
-> Client Team
createTeam Maybe TeamId
t UserId
uid (Range 1 256 Text -> Text
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Text
n) Icon
i Maybe (Range 1 256 Text)
k TeamBinding
b = do
  TeamId
tid <- Client TeamId
-> (TeamId -> Client TeamId) -> Maybe TeamId -> Client TeamId
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (UUID -> TeamId
forall {k} (a :: k). UUID -> Id a
Id (UUID -> TeamId) -> Client UUID -> Client TeamId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO UUID -> Client UUID
forall a. IO a -> Client a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UUID
nextRandom) TeamId -> Client TeamId
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe TeamId
t
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$ PrepQuery
  W
  (TeamId, UserId, Text, Icon, Maybe Text, TeamStatus, TeamBinding)
  ()
-> QueryParams
     (TeamId, UserId, Text, Icon, Maybe Text, TeamStatus, TeamBinding)
-> Client ()
forall (m :: * -> *) a (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, RunQ q) =>
q W a () -> QueryParams a -> m ()
write PrepQuery
  W
  (TeamId, UserId, Text, Icon, Maybe Text, TeamStatus, TeamBinding)
  ()
Cql.insertTeam (Consistency
-> (TeamId, UserId, Text, Icon, Maybe Text, TeamStatus,
    TeamBinding)
-> QueryParams
     (TeamId, UserId, Text, Icon, Maybe Text, TeamStatus, TeamBinding)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId
tid, UserId
uid, Text
n, Icon
i, Range 1 256 Text -> Text
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange (Range 1 256 Text -> Text)
-> Maybe (Range 1 256 Text) -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Range 1 256 Text)
k, TeamBinding -> TeamStatus
initialStatus TeamBinding
b, TeamBinding
b))
  Team -> Client Team
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeamId -> UserId -> Text -> Icon -> TeamBinding -> Team
newTeam TeamId
tid UserId
uid Text
n Icon
i TeamBinding
b Team -> (Team -> Team) -> Team
forall a b. a -> (a -> b) -> b
& (Maybe Text -> Identity (Maybe Text)) -> Team -> Identity Team
Lens' Team (Maybe Text)
teamIconKey ((Maybe Text -> Identity (Maybe Text)) -> Team -> Identity Team)
-> Maybe Text -> Team -> Team
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Range 1 256 Text -> Text
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange (Range 1 256 Text -> Text)
-> Maybe (Range 1 256 Text) -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Range 1 256 Text)
k))
  where
    initialStatus :: TeamBinding -> TeamStatus
initialStatus TeamBinding
Binding = TeamStatus
PendingActive -- Team becomes Active after User account activation
    initialStatus TeamBinding
NonBinding = TeamStatus
Active

listBillingTeamMembers :: TeamId -> Client [UserId]
listBillingTeamMembers :: TeamId -> Client [UserId]
listBillingTeamMembers TeamId
tid =
  (Identity UserId -> UserId) -> [Identity UserId] -> [UserId]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity UserId -> UserId
forall a. Identity a -> a
runIdentity
    ([Identity UserId] -> [UserId])
-> Client [Identity UserId] -> Client [UserId]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client [Identity UserId] -> Client [Identity UserId]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity UserId)
-> QueryParams (Identity TeamId) -> Client [Identity UserId]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (Identity TeamId) (Identity UserId)
Cql.listBillingTeamMembers (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid)))

listTeamAdmins :: TeamId -> Client [UserId]
listTeamAdmins :: TeamId -> Client [UserId]
listTeamAdmins TeamId
tid =
  (Identity UserId -> UserId) -> [Identity UserId] -> [UserId]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity UserId -> UserId
forall a. Identity a -> a
runIdentity
    ([Identity UserId] -> [UserId])
-> Client [Identity UserId] -> Client [UserId]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client [Identity UserId] -> Client [Identity UserId]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity UserId)
-> QueryParams (Identity TeamId) -> Client [Identity UserId]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (Identity TeamId) (Identity UserId)
Cql.listTeamAdmins (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid)))

getTeamName :: TeamId -> Client (Maybe Text)
getTeamName :: TeamId -> Client (Maybe Text)
getTeamName TeamId
tid =
  (Identity Text -> Text) -> Maybe (Identity Text) -> Maybe Text
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity Text -> Text
forall a. Identity a -> a
runIdentity
    (Maybe (Identity Text) -> Maybe Text)
-> Client (Maybe (Identity Text)) -> Client (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client (Maybe (Identity Text)) -> Client (Maybe (Identity Text))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity Text)
-> QueryParams (Identity TeamId) -> Client (Maybe (Identity Text))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery R (Identity TeamId) (Identity Text)
Cql.selectTeamName (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid)))

teamConversation :: TeamId -> ConvId -> Client (Maybe TeamConversation)
teamConversation :: TeamId -> ConvId -> Client (Maybe TeamConversation)
teamConversation TeamId
t ConvId
c =
  (Identity ConvId -> TeamConversation)
-> Maybe (Identity ConvId) -> Maybe TeamConversation
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ConvId -> TeamConversation
newTeamConversation (ConvId -> TeamConversation)
-> (Identity ConvId -> ConvId)
-> Identity ConvId
-> TeamConversation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity ConvId -> ConvId
forall a. Identity a -> a
runIdentity)
    (Maybe (Identity ConvId) -> Maybe TeamConversation)
-> Client (Maybe (Identity ConvId))
-> Client (Maybe TeamConversation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client (Maybe (Identity ConvId))
-> Client (Maybe (Identity ConvId))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (TeamId, ConvId) (Identity ConvId)
-> QueryParams (TeamId, ConvId) -> Client (Maybe (Identity ConvId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery R (TeamId, ConvId) (Identity ConvId)
Cql.selectTeamConv (Consistency -> (TeamId, ConvId) -> QueryParams (TeamId, ConvId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId
t, ConvId
c)))

getTeamConversations :: TeamId -> Client [TeamConversation]
getTeamConversations :: TeamId -> Client [TeamConversation]
getTeamConversations TeamId
t =
  (Identity ConvId -> TeamConversation)
-> [Identity ConvId] -> [TeamConversation]
forall a b. (a -> b) -> [a] -> [b]
map (ConvId -> TeamConversation
newTeamConversation (ConvId -> TeamConversation)
-> (Identity ConvId -> ConvId)
-> Identity ConvId
-> TeamConversation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity ConvId -> ConvId
forall a. Identity a -> a
runIdentity)
    ([Identity ConvId] -> [TeamConversation])
-> Client [Identity ConvId] -> Client [TeamConversation]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client [Identity ConvId] -> Client [Identity ConvId]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity ConvId)
-> QueryParams (Identity TeamId) -> Client [Identity ConvId]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (Identity TeamId) (Identity ConvId)
Cql.selectTeamConvs (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
t)))

teamIdsFrom :: UserId -> Maybe TeamId -> Range 1 100 Int32 -> Client (ResultSet TeamId)
teamIdsFrom :: UserId
-> Maybe TeamId -> Range 1 100 Int32 -> Client (ResultSet TeamId)
teamIdsFrom UserId
usr Maybe TeamId
range (Range 1 100 Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) =
  Page TeamId -> ResultSet TeamId
forall a. Page a -> ResultSet a
mkResultSet (Page TeamId -> ResultSet TeamId)
-> (Page (Identity TeamId) -> Page TeamId)
-> Page (Identity TeamId)
-> ResultSet TeamId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identity TeamId -> TeamId)
-> Page (Identity TeamId) -> Page TeamId
forall a b. (a -> b) -> Page a -> Page b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity TeamId -> TeamId
forall a. Identity a -> a
runIdentity (Page (Identity TeamId) -> Page TeamId)
-> (Page (Identity TeamId) -> Page (Identity TeamId))
-> Page (Identity TeamId)
-> Page TeamId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Page (Identity TeamId) -> Page (Identity TeamId)
strip (Page (Identity TeamId) -> ResultSet TeamId)
-> Client (Page (Identity TeamId)) -> Client (ResultSet TeamId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Maybe TeamId
range of
    Just TeamId
c -> PrepQuery R (UserId, TeamId) (Identity TeamId)
-> QueryParams (UserId, TeamId) -> Client (Page (Identity TeamId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (UserId, TeamId) (Identity TeamId)
Cql.selectUserTeamsFrom (Consistency
-> (UserId, TeamId) -> Int32 -> QueryParams (UserId, TeamId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (UserId
usr, TeamId
c) (Int32
max Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
1))
    Maybe TeamId
Nothing -> PrepQuery R (Identity UserId) (Identity TeamId)
-> QueryParams (Identity UserId) -> Client (Page (Identity TeamId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (Identity UserId) (Identity TeamId)
Cql.selectUserTeams (Consistency
-> Identity UserId -> Int32 -> QueryParams (Identity UserId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (UserId -> Identity UserId
forall a. a -> Identity a
Identity UserId
usr) (Int32
max Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
1))
  where
    strip :: Page (Identity TeamId) -> Page (Identity TeamId)
strip Page (Identity TeamId)
p = Page (Identity TeamId)
p {result = take (fromIntegral max) (result p)}

teamIdsForPagination :: UserId -> Maybe TeamId -> Range 1 100 Int32 -> Client (Page TeamId)
teamIdsForPagination :: UserId -> Maybe TeamId -> Range 1 100 Int32 -> Client (Page TeamId)
teamIdsForPagination UserId
usr Maybe TeamId
range (Range 1 100 Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) =
  (Identity TeamId -> TeamId)
-> Page (Identity TeamId) -> Page TeamId
forall a b. (a -> b) -> Page a -> Page b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity TeamId -> TeamId
forall a. Identity a -> a
runIdentity (Page (Identity TeamId) -> Page TeamId)
-> Client (Page (Identity TeamId)) -> Client (Page TeamId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Maybe TeamId
range of
    Just TeamId
c -> PrepQuery R (UserId, TeamId) (Identity TeamId)
-> QueryParams (UserId, TeamId) -> Client (Page (Identity TeamId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (UserId, TeamId) (Identity TeamId)
Cql.selectUserTeamsFrom (Consistency
-> (UserId, TeamId) -> Int32 -> QueryParams (UserId, TeamId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (UserId
usr, TeamId
c) Int32
max)
    Maybe TeamId
Nothing -> PrepQuery R (Identity UserId) (Identity TeamId)
-> QueryParams (Identity UserId) -> Client (Page (Identity TeamId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (Identity UserId) (Identity TeamId)
Cql.selectUserTeams (Consistency
-> Identity UserId -> Int32 -> QueryParams (Identity UserId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (UserId -> Identity UserId
forall a. a -> Identity a
Identity UserId
usr) Int32
max)

teamMember :: FeatureDefaults LegalholdConfig -> TeamId -> UserId -> Client (Maybe TeamMember)
teamMember :: FeatureDefaults LegalholdConfig
-> TeamId -> UserId -> Client (Maybe TeamMember)
teamMember FeatureDefaults LegalholdConfig
lh TeamId
t UserId
u =
  UserId
-> Maybe
     (Permissions, Maybe UserId, Maybe UTCTimeMillis,
      Maybe UserLegalHoldStatus)
-> Client (Maybe TeamMember)
newTeamMember'' UserId
u (Maybe
   (Permissions, Maybe UserId, Maybe UTCTimeMillis,
    Maybe UserLegalHoldStatus)
 -> Client (Maybe TeamMember))
-> Client
     (Maybe
        (Permissions, Maybe UserId, Maybe UTCTimeMillis,
         Maybe UserLegalHoldStatus))
-> Client (Maybe TeamMember)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< RetrySettings
-> Client
     (Maybe
        (Permissions, Maybe UserId, Maybe UTCTimeMillis,
         Maybe UserLegalHoldStatus))
-> Client
     (Maybe
        (Permissions, Maybe UserId, Maybe UTCTimeMillis,
         Maybe UserLegalHoldStatus))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery
  R
  (TeamId, UserId)
  (Permissions, Maybe UserId, Maybe UTCTimeMillis,
   Maybe UserLegalHoldStatus)
-> QueryParams (TeamId, UserId)
-> Client
     (Maybe
        (Permissions, Maybe UserId, Maybe UTCTimeMillis,
         Maybe UserLegalHoldStatus))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery
  R
  (TeamId, UserId)
  (Permissions, Maybe UserId, Maybe UTCTimeMillis,
   Maybe UserLegalHoldStatus)
Cql.selectTeamMember (Consistency -> (TeamId, UserId) -> QueryParams (TeamId, UserId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId
t, UserId
u)))
  where
    newTeamMember'' ::
      UserId ->
      Maybe (Permissions, Maybe UserId, Maybe UTCTimeMillis, Maybe UserLegalHoldStatus) ->
      Client (Maybe TeamMember)
    newTeamMember'' :: UserId
-> Maybe
     (Permissions, Maybe UserId, Maybe UTCTimeMillis,
      Maybe UserLegalHoldStatus)
-> Client (Maybe TeamMember)
newTeamMember'' UserId
_ Maybe
  (Permissions, Maybe UserId, Maybe UTCTimeMillis,
   Maybe UserLegalHoldStatus)
Nothing = Maybe TeamMember -> Client (Maybe TeamMember)
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe TeamMember
forall a. Maybe a
Nothing
    newTeamMember'' UserId
uid (Just (Permissions
perms, Maybe UserId
minvu, Maybe UTCTimeMillis
minvt, Maybe UserLegalHoldStatus
mulhStatus)) =
      TeamMember -> Maybe TeamMember
forall a. a -> Maybe a
Just (TeamMember -> Maybe TeamMember)
-> Client TeamMember -> Client (Maybe TeamMember)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
t (UserId
uid, Permissions
perms, Maybe UserId
minvu, Maybe UTCTimeMillis
minvt, Maybe UserLegalHoldStatus
mulhStatus)

addTeamMember :: TeamId -> TeamMember -> Client ()
addTeamMember :: TeamId -> TeamMember -> Client ()
addTeamMember TeamId
t TeamMember
m =
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ())
-> (BatchM () -> Client ()) -> BatchM () -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BatchM () -> Client ()
forall (m :: * -> *). MonadClient m => BatchM () -> m ()
batch (BatchM () -> Client ()) -> BatchM () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
    BatchType -> BatchM ()
setType BatchType
BatchLogged
    Consistency -> BatchM ()
setConsistency Consistency
LocalQuorum
    PrepQuery
  W
  (TeamId, UserId, Permissions, Maybe UserId, Maybe UTCTimeMillis)
  ()
-> (TeamId, UserId, Permissions, Maybe UserId, Maybe UTCTimeMillis)
-> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery
      PrepQuery
  W
  (TeamId, UserId, Permissions, Maybe UserId, Maybe UTCTimeMillis)
  ()
Cql.insertTeamMember
      ( TeamId
t,
        TeamMember
m TeamMember -> Getting UserId TeamMember UserId -> UserId
forall s a. s -> Getting a s a -> a
^. Getting UserId TeamMember UserId
Lens' TeamMember UserId
userId,
        TeamMember
m 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,
        TeamMember
m TeamMember
-> Getting (First UserId) TeamMember UserId -> Maybe UserId
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe (UserId, UTCTimeMillis)
 -> Const (First UserId) (Maybe (UserId, UTCTimeMillis)))
-> TeamMember -> Const (First UserId) TeamMember
Lens' TeamMember (Maybe (UserId, UTCTimeMillis))
invitation ((Maybe (UserId, UTCTimeMillis)
  -> Const (First UserId) (Maybe (UserId, UTCTimeMillis)))
 -> TeamMember -> Const (First UserId) TeamMember)
-> ((UserId -> Const (First UserId) UserId)
    -> Maybe (UserId, UTCTimeMillis)
    -> Const (First UserId) (Maybe (UserId, UTCTimeMillis)))
-> Getting (First UserId) TeamMember UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((UserId, UTCTimeMillis)
 -> Const (First UserId) (UserId, UTCTimeMillis))
-> Maybe (UserId, UTCTimeMillis)
-> Const (First UserId) (Maybe (UserId, UTCTimeMillis))
forall a b (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p a (f b) -> p (Maybe a) (f (Maybe b))
_Just (((UserId, UTCTimeMillis)
  -> Const (First UserId) (UserId, UTCTimeMillis))
 -> Maybe (UserId, UTCTimeMillis)
 -> Const (First UserId) (Maybe (UserId, UTCTimeMillis)))
-> ((UserId -> Const (First UserId) UserId)
    -> (UserId, UTCTimeMillis)
    -> Const (First UserId) (UserId, UTCTimeMillis))
-> (UserId -> Const (First UserId) UserId)
-> Maybe (UserId, UTCTimeMillis)
-> Const (First UserId) (Maybe (UserId, UTCTimeMillis))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UserId -> Const (First UserId) UserId)
-> (UserId, UTCTimeMillis)
-> Const (First UserId) (UserId, UTCTimeMillis)
forall s t a b. Field1 s t a b => Lens s t a b
Lens (UserId, UTCTimeMillis) (UserId, UTCTimeMillis) UserId UserId
_1,
        TeamMember
m TeamMember
-> Getting (First UTCTimeMillis) TeamMember UTCTimeMillis
-> Maybe UTCTimeMillis
forall s a. s -> Getting (First a) s a -> Maybe a
^? (Maybe (UserId, UTCTimeMillis)
 -> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis)))
-> TeamMember -> Const (First UTCTimeMillis) TeamMember
Lens' TeamMember (Maybe (UserId, UTCTimeMillis))
invitation ((Maybe (UserId, UTCTimeMillis)
  -> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis)))
 -> TeamMember -> Const (First UTCTimeMillis) TeamMember)
-> ((UTCTimeMillis -> Const (First UTCTimeMillis) UTCTimeMillis)
    -> Maybe (UserId, UTCTimeMillis)
    -> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis)))
-> Getting (First UTCTimeMillis) TeamMember UTCTimeMillis
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((UserId, UTCTimeMillis)
 -> Const (First UTCTimeMillis) (UserId, UTCTimeMillis))
-> Maybe (UserId, UTCTimeMillis)
-> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis))
forall a b (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p a (f b) -> p (Maybe a) (f (Maybe b))
_Just (((UserId, UTCTimeMillis)
  -> Const (First UTCTimeMillis) (UserId, UTCTimeMillis))
 -> Maybe (UserId, UTCTimeMillis)
 -> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis)))
-> ((UTCTimeMillis -> Const (First UTCTimeMillis) UTCTimeMillis)
    -> (UserId, UTCTimeMillis)
    -> Const (First UTCTimeMillis) (UserId, UTCTimeMillis))
-> (UTCTimeMillis -> Const (First UTCTimeMillis) UTCTimeMillis)
-> Maybe (UserId, UTCTimeMillis)
-> Const (First UTCTimeMillis) (Maybe (UserId, UTCTimeMillis))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTCTimeMillis -> Const (First UTCTimeMillis) UTCTimeMillis)
-> (UserId, UTCTimeMillis)
-> Const (First UTCTimeMillis) (UserId, UTCTimeMillis)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UserId, UTCTimeMillis)
  (UserId, UTCTimeMillis)
  UTCTimeMillis
  UTCTimeMillis
_2
      )
    PrepQuery W (UserId, TeamId) () -> (UserId, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (UserId, TeamId) ()
Cql.insertUserTeam (TeamMember
m TeamMember -> Getting UserId TeamMember UserId -> UserId
forall s a. s -> Getting a s a -> a
^. Getting UserId TeamMember UserId
Lens' TeamMember UserId
userId, TeamId
t)

    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (TeamMember
m TeamMember -> Perm -> Bool
forall perm. IsPerm perm => TeamMember -> perm -> Bool
`hasPermission` Perm
SetBilling) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.insertBillingTeamMember (TeamId
t, TeamMember
m TeamMember -> Getting UserId TeamMember UserId -> UserId
forall s a. s -> Getting a s a -> a
^. Getting UserId TeamMember UserId
Lens' TeamMember UserId
userId)

    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Permissions -> Bool
isAdminOrOwner (TeamMember
m 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)) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.insertTeamAdmin (TeamId
t, TeamMember
m TeamMember -> Getting UserId TeamMember UserId -> UserId
forall s a. s -> Getting a s a -> a
^. Getting UserId TeamMember UserId
Lens' TeamMember UserId
userId)

updateTeamMember ::
  -- | Old permissions, used for maintaining 'billing_team_member' and 'team_admin' tables
  Permissions ->
  TeamId ->
  UserId ->
  -- | New permissions
  Permissions ->
  Client ()
updateTeamMember :: Permissions -> TeamId -> UserId -> Permissions -> Client ()
updateTeamMember Permissions
oldPerms TeamId
tid UserId
uid Permissions
newPerms = do
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ())
-> (BatchM () -> Client ()) -> BatchM () -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BatchM () -> Client ()
forall (m :: * -> *). MonadClient m => BatchM () -> m ()
batch (BatchM () -> Client ()) -> BatchM () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
    BatchType -> BatchM ()
setType BatchType
BatchLogged
    Consistency -> BatchM ()
setConsistency Consistency
LocalQuorum
    PrepQuery W (Permissions, TeamId, UserId) ()
-> (Permissions, TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Permissions, TeamId, UserId) ()
Cql.updatePermissions (Permissions
newPerms, TeamId
tid, UserId
uid)

    -- update billing_team_member table
    let permDiff :: Permissions -> Permissions -> Set Perm
permDiff = Set Perm -> Set Perm -> Set Perm
forall a. Ord a => Set a -> Set a -> Set a
Set.difference (Set Perm -> Set Perm -> Set Perm)
-> (Permissions -> Set Perm)
-> Permissions
-> Permissions
-> Set Perm
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Permissions -> Set Perm
self
        acquiredPerms :: Set Perm
acquiredPerms = Permissions
newPerms Permissions -> Permissions -> Set Perm
`permDiff` Permissions
oldPerms
        lostPerms :: Set Perm
lostPerms = Permissions
oldPerms Permissions -> Permissions -> Set Perm
`permDiff` Permissions
newPerms

    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Perm
SetBilling Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Perm
acquiredPerms) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.insertBillingTeamMember (TeamId
tid, UserId
uid)
    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Perm
SetBilling Perm -> Set Perm -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Perm
lostPerms) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.deleteBillingTeamMember (TeamId
tid, UserId
uid)

    -- update team_admin table
    let wasAdmin :: Bool
wasAdmin = Permissions -> Bool
isAdminOrOwner Permissions
oldPerms
        isAdmin :: Bool
isAdmin = Permissions -> Bool
isAdminOrOwner Permissions
newPerms

    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
isAdmin Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
wasAdmin) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.insertTeamAdmin (TeamId
tid, UserId
uid)

    Bool -> BatchM () -> BatchM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
isAdmin Bool -> Bool -> Bool
&& Bool
wasAdmin) (BatchM () -> BatchM ()) -> BatchM () -> BatchM ()
forall a b. (a -> b) -> a -> b
$
      PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.deleteTeamAdmin (TeamId
tid, UserId
uid)

removeTeamMember :: TeamId -> UserId -> Client ()
removeTeamMember :: TeamId -> UserId -> Client ()
removeTeamMember TeamId
t UserId
m =
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ())
-> (BatchM () -> Client ()) -> BatchM () -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BatchM () -> Client ()
forall (m :: * -> *). MonadClient m => BatchM () -> m ()
batch (BatchM () -> Client ()) -> BatchM () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
    BatchType -> BatchM ()
setType BatchType
BatchLogged
    Consistency -> BatchM ()
setConsistency Consistency
LocalQuorum
    PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.deleteTeamMember (TeamId
t, UserId
m)
    PrepQuery W (UserId, TeamId) () -> (UserId, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (UserId, TeamId) ()
Cql.deleteUserTeam (UserId
m, TeamId
t)
    PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.deleteBillingTeamMember (TeamId
t, UserId
m)
    PrepQuery W (TeamId, UserId) () -> (TeamId, UserId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, UserId) ()
Cql.deleteTeamAdmin (TeamId
t, UserId
m)

team :: TeamId -> Client (Maybe TeamData)
team :: TeamId -> Client (Maybe TeamData)
team TeamId
tid =
  ((UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
  Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
 -> TeamData)
-> Maybe
     (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
      Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
-> Maybe TeamData
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
 Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
-> TeamData
toTeam (Maybe
   (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
    Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
 -> Maybe TeamData)
-> Client
     (Maybe
        (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
         Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon))
-> Client (Maybe TeamData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client
     (Maybe
        (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
         Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon))
-> Client
     (Maybe
        (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
         Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery
  R
  (Identity TeamId)
  (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
   Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
-> QueryParams (Identity TeamId)
-> Client
     (Maybe
        (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
         Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery
  R
  (Identity TeamId)
  (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
   Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
Cql.selectTeam (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid)))
  where
    toTeam :: (UserId, Text, Icon, Maybe Text, Bool, Maybe TeamStatus,
 Maybe (Writetime TeamStatus), Maybe TeamBinding, Maybe Icon)
-> TeamData
toTeam (UserId
u, Text
n, Icon
i, Maybe Text
k, Bool
d, Maybe TeamStatus
s, Maybe (Writetime TeamStatus)
st, Maybe TeamBinding
b, Maybe Icon
ss) =
      let t :: Team
t = TeamId -> UserId -> Text -> Icon -> TeamBinding -> Team
newTeam TeamId
tid UserId
u Text
n Icon
i (TeamBinding -> Maybe TeamBinding -> TeamBinding
forall a. a -> Maybe a -> a
fromMaybe TeamBinding
NonBinding Maybe TeamBinding
b) Team -> (Team -> Team) -> Team
forall a b. a -> (a -> b) -> b
& (Maybe Text -> Identity (Maybe Text)) -> Team -> Identity Team
Lens' Team (Maybe Text)
teamIconKey ((Maybe Text -> Identity (Maybe Text)) -> Team -> Identity Team)
-> Maybe Text -> Team -> Team
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe Text
k Team -> (Team -> Team) -> Team
forall a b. a -> (a -> b) -> b
& (Icon -> Identity Icon) -> Team -> Identity Team
Lens' Team Icon
teamSplashScreen ((Icon -> Identity Icon) -> Team -> Identity Team)
-> Icon -> Team -> Team
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Icon -> Maybe Icon -> Icon
forall a. a -> Maybe a -> a
fromMaybe Icon
DefaultIcon Maybe Icon
ss
          status :: TeamStatus
status = if Bool
d then TeamStatus
PendingDelete else TeamStatus -> Maybe TeamStatus -> TeamStatus
forall a. a -> Maybe a -> a
fromMaybe TeamStatus
Active Maybe TeamStatus
s
       in Team -> TeamStatus -> Maybe UTCTime -> TeamData
TeamData Team
t TeamStatus
status (Writetime TeamStatus -> UTCTime
forall {k} (a :: k). Writetime a -> UTCTime
writetimeToUTC (Writetime TeamStatus -> UTCTime)
-> Maybe (Writetime TeamStatus) -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Writetime TeamStatus)
st)

teamIdsOf :: UserId -> [TeamId] -> Client [TeamId]
teamIdsOf :: UserId -> [TeamId] -> Client [TeamId]
teamIdsOf UserId
usr [TeamId]
tids =
  (Identity TeamId -> TeamId) -> [Identity TeamId] -> [TeamId]
forall a b. (a -> b) -> [a] -> [b]
map Identity TeamId -> TeamId
forall a. Identity a -> a
runIdentity ([Identity TeamId] -> [TeamId])
-> Client [Identity TeamId] -> Client [TeamId]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client [Identity TeamId] -> Client [Identity TeamId]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (UserId, [TeamId]) (Identity TeamId)
-> QueryParams (UserId, [TeamId]) -> Client [Identity TeamId]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (UserId, [TeamId]) (Identity TeamId)
Cql.selectUserTeamsIn (Consistency -> (UserId, [TeamId]) -> QueryParams (UserId, [TeamId])
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (UserId
usr, [TeamId] -> [TeamId]
forall a. [a] -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList [TeamId]
tids)))

teamMembersWithLimit ::
  FeatureDefaults LegalholdConfig ->
  TeamId ->
  Range 1 HardTruncationLimit Int32 ->
  Client TeamMemberList
teamMembersWithLimit :: FeatureDefaults LegalholdConfig
-> TeamId
-> Range 1 HardTruncationLimit Int32
-> Client (TeamMemberList' 'Required)
teamMembersWithLimit FeatureDefaults LegalholdConfig
lh TeamId
t (Range 1 HardTruncationLimit Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
limit) = do
  -- NOTE: We use +1 as size and then trim it due to the semantics of C* when getting a page with the exact same size
  Page RawTeamMember
pageTuple <- RetrySettings
-> Client (Page RawTeamMember) -> Client (Page RawTeamMember)
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) RawTeamMember
-> QueryParams (Identity TeamId) -> Client (Page RawTeamMember)
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (Identity TeamId) RawTeamMember
Cql.selectTeamMembers (Consistency
-> Identity TeamId -> Int32 -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
t) (Int32
limit Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
1)))
  [TeamMember]
ms <- (RawTeamMember -> Client TeamMember)
-> [RawTeamMember] -> Client [TeamMember]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
t) ([RawTeamMember] -> Client [TeamMember])
-> ([RawTeamMember] -> [RawTeamMember])
-> [RawTeamMember]
-> Client [TeamMember]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [RawTeamMember] -> [RawTeamMember]
forall a. Int -> [a] -> [a]
take (Int32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
limit) ([RawTeamMember] -> Client [TeamMember])
-> [RawTeamMember] -> Client [TeamMember]
forall a b. (a -> b) -> a -> b
$ Page RawTeamMember -> [RawTeamMember]
forall a. Page a -> [a]
result Page RawTeamMember
pageTuple
  TeamMemberList' 'Required -> Client (TeamMemberList' 'Required)
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeamMemberList' 'Required -> Client (TeamMemberList' 'Required))
-> TeamMemberList' 'Required -> Client (TeamMemberList' 'Required)
forall a b. (a -> b) -> a -> b
$
    if Page RawTeamMember -> Bool
forall a. Page a -> Bool
hasMore Page RawTeamMember
pageTuple
      then [TeamMember] -> ListType -> TeamMemberList' 'Required
newTeamMemberList [TeamMember]
ms ListType
ListTruncated
      else [TeamMember] -> ListType -> TeamMemberList' 'Required
newTeamMemberList [TeamMember]
ms ListType
ListComplete

-- NOTE: Use this function with care... should only be required when deleting a team!
--       Maybe should be left explicitly for the caller?
teamMembersCollectedWithPagination :: FeatureDefaults LegalholdConfig -> TeamId -> Client [TeamMember]
teamMembersCollectedWithPagination :: FeatureDefaults LegalholdConfig -> TeamId -> Client [TeamMember]
teamMembersCollectedWithPagination FeatureDefaults LegalholdConfig
lh TeamId
tid = do
  Page RawTeamMember
mems <- TeamId
-> Maybe UserId
-> Range 1 HardTruncationLimit Int32
-> Client (Page RawTeamMember)
teamMembersForPagination TeamId
tid Maybe UserId
forall a. Maybe a
Nothing (Int32 -> Range 1 HardTruncationLimit Int32
forall a (n :: Nat) (m :: Nat).
(Show a, KnownNat n, KnownNat m, Within a n m) =>
a -> Range n m a
unsafeRange Int32
2000)
  [TeamMember] -> Page RawTeamMember -> Client [TeamMember]
collectTeamMembersPaginated [] Page RawTeamMember
mems
  where
    collectTeamMembersPaginated :: [TeamMember] -> Page RawTeamMember -> Client [TeamMember]
collectTeamMembersPaginated [TeamMember]
acc Page RawTeamMember
mems = do
      [TeamMember]
tMembers <- (RawTeamMember -> Client TeamMember)
-> [RawTeamMember] -> Client [TeamMember]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
tid) (Page RawTeamMember -> [RawTeamMember]
forall a. Page a -> [a]
result Page RawTeamMember
mems)
      if Page RawTeamMember -> Bool
forall a. Page a -> Bool
hasMore Page RawTeamMember
mems
        then [TeamMember] -> Page RawTeamMember -> Client [TeamMember]
collectTeamMembersPaginated ([TeamMember]
tMembers [TeamMember] -> [TeamMember] -> [TeamMember]
forall a. [a] -> [a] -> [a]
++ [TeamMember]
acc) (Page RawTeamMember -> Client [TeamMember])
-> Client (Page RawTeamMember) -> Client [TeamMember]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Page RawTeamMember -> Client (Page RawTeamMember)
forall a. Page a -> Client (Page a)
nextPage Page RawTeamMember
mems
        else [TeamMember] -> Client [TeamMember]
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([TeamMember]
tMembers [TeamMember] -> [TeamMember] -> [TeamMember]
forall a. [a] -> [a] -> [a]
++ [TeamMember]
acc)

-- Lookup only specific team members: this is particularly useful for large teams when
-- needed to look up only a small subset of members (typically 2, user to perform the action
-- and the target user)
teamMembersLimited :: FeatureDefaults LegalholdConfig -> TeamId -> [UserId] -> Client [TeamMember]
teamMembersLimited :: FeatureDefaults LegalholdConfig
-> TeamId -> [UserId] -> Client [TeamMember]
teamMembersLimited FeatureDefaults LegalholdConfig
lh TeamId
t [UserId]
u =
  (RawTeamMember -> Client TeamMember)
-> [RawTeamMember] -> Client [TeamMember]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
t)
    ([RawTeamMember] -> Client [TeamMember])
-> Client [RawTeamMember] -> Client [TeamMember]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< RetrySettings -> Client [RawTeamMember] -> Client [RawTeamMember]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (TeamId, [UserId]) RawTeamMember
-> QueryParams (TeamId, [UserId]) -> Client [RawTeamMember]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (TeamId, [UserId]) RawTeamMember
Cql.selectTeamMembers' (Consistency -> (TeamId, [UserId]) -> QueryParams (TeamId, [UserId])
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId
t, [UserId]
u)))

userTeams :: UserId -> Client [TeamId]
userTeams :: UserId -> Client [TeamId]
userTeams UserId
u =
  (Identity TeamId -> TeamId) -> [Identity TeamId] -> [TeamId]
forall a b. (a -> b) -> [a] -> [b]
map Identity TeamId -> TeamId
forall a. Identity a -> a
runIdentity
    ([Identity TeamId] -> [TeamId])
-> Client [Identity TeamId] -> Client [TeamId]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client [Identity TeamId] -> Client [Identity TeamId]
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity UserId) (Identity TeamId)
-> QueryParams (Identity UserId) -> Client [Identity TeamId]
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m [b]
query PrepQuery R (Identity UserId) (Identity TeamId)
Cql.selectUserTeams (Consistency -> Identity UserId -> QueryParams (Identity UserId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (UserId -> Identity UserId
forall a. a -> Identity a
Identity UserId
u)))

usersTeams :: [UserId] -> Client (Map UserId TeamId)
usersTeams :: [UserId] -> Client (Map UserId TeamId)
usersTeams [UserId]
uids = do
  [(UserId, TeamId)]
pairs :: [(UserId, TeamId)] <-
    [Maybe (UserId, TeamId)] -> [(UserId, TeamId)]
forall a. [Maybe a] -> [a]
catMaybes
      ([Maybe (UserId, TeamId)] -> [(UserId, TeamId)])
-> Client [Maybe (UserId, TeamId)] -> Client [(UserId, TeamId)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int
-> (UserId -> Client (Maybe (UserId, TeamId)))
-> [UserId]
-> Client [Maybe (UserId, TeamId)]
forall (m :: * -> *) (t :: * -> *) a b.
(MonadUnliftIO m, Traversable t) =>
Int -> (a -> m b) -> t a -> m (t b)
UnliftIO.pooledMapConcurrentlyN Int
8 (\UserId
uid -> (UserId
uid,) (TeamId -> (UserId, TeamId))
-> Client (Maybe TeamId) -> Client (Maybe (UserId, TeamId))
forall (f :: * -> *) (g :: * -> *) a b.
(Functor f, Functor g) =>
(a -> b) -> f (g a) -> f (g b)
<$$> UserId -> Client (Maybe TeamId)
oneUserTeam UserId
uid) [UserId]
uids
  Map UserId TeamId -> Client (Map UserId TeamId)
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map UserId TeamId -> Client (Map UserId TeamId))
-> Map UserId TeamId -> Client (Map UserId TeamId)
forall a b. (a -> b) -> a -> b
$ (Map UserId TeamId -> (UserId, TeamId) -> Map UserId TeamId)
-> Map UserId TeamId -> [(UserId, TeamId)] -> Map UserId TeamId
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Map UserId TeamId
m (UserId
k, TeamId
v) -> UserId -> TeamId -> Map UserId TeamId -> Map UserId TeamId
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert UserId
k TeamId
v Map UserId TeamId
m) Map UserId TeamId
forall k a. Map k a
Map.empty [(UserId, TeamId)]
pairs

oneUserTeam :: UserId -> Client (Maybe TeamId)
oneUserTeam :: UserId -> Client (Maybe TeamId)
oneUserTeam UserId
u =
  (Identity TeamId -> TeamId)
-> Maybe (Identity TeamId) -> Maybe TeamId
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity TeamId -> TeamId
forall a. Identity a -> a
runIdentity
    (Maybe (Identity TeamId) -> Maybe TeamId)
-> Client (Maybe (Identity TeamId)) -> Client (Maybe TeamId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client (Maybe (Identity TeamId))
-> Client (Maybe (Identity TeamId))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity UserId) (Identity TeamId)
-> QueryParams (Identity UserId)
-> Client (Maybe (Identity TeamId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery R (Identity UserId) (Identity TeamId)
Cql.selectOneUserTeam (Consistency -> Identity UserId -> QueryParams (Identity UserId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (UserId -> Identity UserId
forall a. a -> Identity a
Identity UserId
u)))

teamCreationTime :: TeamId -> Client (Maybe TeamCreationTime)
teamCreationTime :: TeamId -> Client (Maybe TeamCreationTime)
teamCreationTime TeamId
t =
  Maybe (Maybe Int64) -> Maybe TeamCreationTime
checkCreation (Maybe (Maybe Int64) -> Maybe TeamCreationTime)
-> (Maybe (Identity (Maybe Int64)) -> Maybe (Maybe Int64))
-> Maybe (Identity (Maybe Int64))
-> Maybe TeamCreationTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identity (Maybe Int64) -> Maybe Int64)
-> Maybe (Identity (Maybe Int64)) -> Maybe (Maybe Int64)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity (Maybe Int64) -> Maybe Int64
forall a. Identity a -> a
runIdentity
    (Maybe (Identity (Maybe Int64)) -> Maybe TeamCreationTime)
-> Client (Maybe (Identity (Maybe Int64)))
-> Client (Maybe TeamCreationTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client (Maybe (Identity (Maybe Int64)))
-> Client (Maybe (Identity (Maybe Int64)))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity (Maybe Int64))
-> QueryParams (Identity TeamId)
-> Client (Maybe (Identity (Maybe Int64)))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery R (Identity TeamId) (Identity (Maybe Int64))
Cql.selectTeamBindingWritetime (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
t)))
  where
    checkCreation :: Maybe (Maybe Int64) -> Maybe TeamCreationTime
checkCreation (Just (Just Int64
ts)) = TeamCreationTime -> Maybe TeamCreationTime
forall a. a -> Maybe a
Just (TeamCreationTime -> Maybe TeamCreationTime)
-> TeamCreationTime -> Maybe TeamCreationTime
forall a b. (a -> b) -> a -> b
$ Int64 -> TeamCreationTime
TeamCreationTime Int64
ts
    checkCreation Maybe (Maybe Int64)
_ = Maybe TeamCreationTime
forall a. Maybe a
Nothing

getTeamBinding :: TeamId -> Client (Maybe TeamBinding)
getTeamBinding :: TeamId -> Client (Maybe TeamBinding)
getTeamBinding TeamId
t =
  (Identity (Maybe TeamBinding) -> TeamBinding)
-> Maybe (Identity (Maybe TeamBinding)) -> Maybe TeamBinding
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TeamBinding -> Maybe TeamBinding -> TeamBinding
forall a. a -> Maybe a -> a
fromMaybe TeamBinding
NonBinding (Maybe TeamBinding -> TeamBinding)
-> (Identity (Maybe TeamBinding) -> Maybe TeamBinding)
-> Identity (Maybe TeamBinding)
-> TeamBinding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity (Maybe TeamBinding) -> Maybe TeamBinding
forall a. Identity a -> a
runIdentity)
    (Maybe (Identity (Maybe TeamBinding)) -> Maybe TeamBinding)
-> Client (Maybe (Identity (Maybe TeamBinding)))
-> Client (Maybe TeamBinding)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RetrySettings
-> Client (Maybe (Identity (Maybe TeamBinding)))
-> Client (Maybe (Identity (Maybe TeamBinding)))
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x1 (PrepQuery R (Identity TeamId) (Identity (Maybe TeamBinding))
-> QueryParams (Identity TeamId)
-> Client (Maybe (Identity (Maybe TeamBinding)))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Maybe b)
query1 PrepQuery R (Identity TeamId) (Identity (Maybe TeamBinding))
Cql.selectTeamBinding (Consistency -> Identity TeamId -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
t)))

getTeamsBindings :: [TeamId] -> Client [TeamBinding]
getTeamsBindings :: [TeamId] -> Client [TeamBinding]
getTeamsBindings =
  ([Maybe TeamBinding] -> [TeamBinding])
-> Client [Maybe TeamBinding] -> Client [TeamBinding]
forall a b. (a -> b) -> Client a -> Client b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe TeamBinding] -> [TeamBinding]
forall a. [Maybe a] -> [a]
catMaybes
    (Client [Maybe TeamBinding] -> Client [TeamBinding])
-> ([TeamId] -> Client [Maybe TeamBinding])
-> [TeamId]
-> Client [TeamBinding]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> (TeamId -> Client (Maybe TeamBinding))
-> [TeamId]
-> Client [Maybe TeamBinding]
forall (m :: * -> *) (t :: * -> *) a b.
(MonadUnliftIO m, Traversable t) =>
Int -> (a -> m b) -> t a -> m (t b)
UnliftIO.pooledMapConcurrentlyN Int
8 TeamId -> Client (Maybe TeamBinding)
getTeamBinding

deleteTeam :: TeamId -> Client ()
deleteTeam :: TeamId -> Client ()
deleteTeam TeamId
tid = do
  -- TODO: delete service_whitelist records that mention this team
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$ PrepQuery W (TeamStatus, TeamId) ()
-> QueryParams (TeamStatus, TeamId) -> Client ()
forall (m :: * -> *) a (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, RunQ q) =>
q W a () -> QueryParams a -> m ()
write PrepQuery W (TeamStatus, TeamId) ()
Cql.markTeamDeleted (Consistency
-> (TeamStatus, TeamId) -> QueryParams (TeamStatus, TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamStatus
PendingDelete, TeamId
tid))
  Page RawTeamMember
mems <- TeamId
-> Maybe UserId
-> Range 1 HardTruncationLimit Int32
-> Client (Page RawTeamMember)
teamMembersForPagination TeamId
tid Maybe UserId
forall a. Maybe a
Nothing (Int32 -> Range 1 HardTruncationLimit Int32
forall a (n :: Nat) (m :: Nat).
(Show a, KnownNat n, KnownNat m, Within a n m) =>
a -> Range n m a
unsafeRange Int32
2000)
  Page RawTeamMember -> Client ()
removeTeamMembers Page RawTeamMember
mems
  Page TeamConversation
cnvs <- TeamId
-> Maybe ConvId
-> Range 1 HardTruncationLimit Int32
-> Client (Page TeamConversation)
teamConversationsForPagination TeamId
tid Maybe ConvId
forall a. Maybe a
Nothing (Int32 -> Range 1 HardTruncationLimit Int32
forall a (n :: Nat) (m :: Nat).
(Show a, KnownNat n, KnownNat m, Within a n m) =>
a -> Range n m a
unsafeRange Int32
2000)
  Page TeamConversation -> Client ()
removeConvs Page TeamConversation
cnvs
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$ PrepQuery W (TeamStatus, TeamId) ()
-> QueryParams (TeamStatus, TeamId) -> Client ()
forall (m :: * -> *) a (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, RunQ q) =>
q W a () -> QueryParams a -> m ()
write PrepQuery W (TeamStatus, TeamId) ()
Cql.deleteTeam (Consistency
-> (TeamStatus, TeamId) -> QueryParams (TeamStatus, TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamStatus
Deleted, TeamId
tid))
  where
    removeConvs :: Page TeamConversation -> Client ()
    removeConvs :: Page TeamConversation -> Client ()
removeConvs Page TeamConversation
cnvs = do
      [TeamConversation] -> (TeamConversation -> Client ()) -> Client ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Page TeamConversation -> [TeamConversation]
forall a. Page a -> [a]
result Page TeamConversation
cnvs) ((TeamConversation -> Client ()) -> Client ())
-> (TeamConversation -> Client ()) -> Client ()
forall a b. (a -> b) -> a -> b
$ TeamId -> ConvId -> Client ()
removeTeamConv TeamId
tid (ConvId -> Client ())
-> (TeamConversation -> ConvId) -> TeamConversation -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting ConvId TeamConversation ConvId
-> TeamConversation -> ConvId
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting ConvId TeamConversation ConvId
Iso' TeamConversation ConvId
conversationId
      Bool -> Client () -> Client ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([TeamConversation] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([TeamConversation] -> Bool) -> [TeamConversation] -> Bool
forall a b. (a -> b) -> a -> b
$ Page TeamConversation -> [TeamConversation]
forall a. Page a -> [a]
result Page TeamConversation
cnvs) (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$
        Page TeamConversation -> Client ()
removeConvs (Page TeamConversation -> Client ())
-> Client (Page TeamConversation) -> Client ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Client (Page TeamConversation) -> Client (Page TeamConversation)
forall a. Client a -> Client a
forall (m :: * -> *) a. MonadClient m => Client a -> m a
liftClient (Page TeamConversation -> Client (Page TeamConversation)
forall a. Page a -> Client (Page a)
nextPage Page TeamConversation
cnvs)

    removeTeamMembers ::
      Page
        ( UserId,
          Permissions,
          Maybe UserId,
          Maybe UTCTimeMillis,
          Maybe UserLegalHoldStatus
        ) ->
      Client ()
    removeTeamMembers :: Page RawTeamMember -> Client ()
removeTeamMembers Page RawTeamMember
mems = do
      (RawTeamMember -> Client ()) -> [RawTeamMember] -> Client ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (TeamId -> UserId -> Client ()
removeTeamMember TeamId
tid (UserId -> Client ())
-> (RawTeamMember -> UserId) -> RawTeamMember -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting UserId RawTeamMember UserId -> RawTeamMember -> UserId
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting UserId RawTeamMember UserId
forall s t a b. Field1 s t a b => Lens s t a b
Lens RawTeamMember RawTeamMember UserId UserId
_1) (Page RawTeamMember -> [RawTeamMember]
forall a. Page a -> [a]
result Page RawTeamMember
mems)
      Bool -> Client () -> Client ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([RawTeamMember] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([RawTeamMember] -> Bool) -> [RawTeamMember] -> Bool
forall a b. (a -> b) -> a -> b
$ Page RawTeamMember -> [RawTeamMember]
forall a. Page a -> [a]
result Page RawTeamMember
mems) (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$
        Page RawTeamMember -> Client ()
removeTeamMembers (Page RawTeamMember -> Client ())
-> Client (Page RawTeamMember) -> Client ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Client (Page RawTeamMember) -> Client (Page RawTeamMember)
forall a. Client a -> Client a
forall (m :: * -> *) a. MonadClient m => Client a -> m a
liftClient (Page RawTeamMember -> Client (Page RawTeamMember)
forall a. Page a -> Client (Page a)
nextPage Page RawTeamMember
mems)

removeTeamConv :: TeamId -> ConvId -> Client ()
removeTeamConv :: TeamId -> ConvId -> Client ()
removeTeamConv TeamId
tid ConvId
cid = Client () -> Client ()
forall a. Client a -> Client a
forall (m :: * -> *) a. MonadClient m => Client a -> m a
liftClient (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
  RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ())
-> (BatchM () -> Client ()) -> BatchM () -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BatchM () -> Client ()
forall (m :: * -> *). MonadClient m => BatchM () -> m ()
batch (BatchM () -> Client ()) -> BatchM () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
    BatchType -> BatchM ()
setType BatchType
BatchLogged
    Consistency -> BatchM ()
setConsistency Consistency
LocalQuorum
    PrepQuery W (Identity ConvId) () -> Identity ConvId -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Identity ConvId) ()
Cql.markConvDeleted (ConvId -> Identity ConvId
forall a. a -> Identity a
Identity ConvId
cid)
    PrepQuery W (TeamId, ConvId) () -> (TeamId, ConvId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (TeamId, ConvId) ()
Cql.deleteTeamConv (TeamId
tid, ConvId
cid)
  ConvId -> Client ()
C.deleteConversation ConvId
cid

updateTeamStatus :: TeamId -> TeamStatus -> Client ()
updateTeamStatus :: TeamId -> TeamStatus -> Client ()
updateTeamStatus TeamId
t TeamStatus
s = RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ()) -> Client () -> Client ()
forall a b. (a -> b) -> a -> b
$ PrepQuery W (TeamStatus, TeamId) ()
-> QueryParams (TeamStatus, TeamId) -> Client ()
forall (m :: * -> *) a (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, RunQ q) =>
q W a () -> QueryParams a -> m ()
write PrepQuery W (TeamStatus, TeamId) ()
Cql.updateTeamStatus (Consistency
-> (TeamStatus, TeamId) -> QueryParams (TeamStatus, TeamId)
forall a. Consistency -> a -> QueryParams a
params Consistency
LocalQuorum (TeamStatus
s, TeamId
t))

updateTeam :: TeamId -> TeamUpdateData -> Client ()
updateTeam :: TeamId -> TeamUpdateData -> Client ()
updateTeam TeamId
tid TeamUpdateData
u = RetrySettings -> Client () -> Client ()
forall (m :: * -> *) a.
MonadClient m =>
RetrySettings -> m a -> m a
retry RetrySettings
x5 (Client () -> Client ())
-> (BatchM () -> Client ()) -> BatchM () -> Client ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BatchM () -> Client ()
forall (m :: * -> *). MonadClient m => BatchM () -> m ()
batch (BatchM () -> Client ()) -> BatchM () -> Client ()
forall a b. (a -> b) -> a -> b
$ do
  BatchType -> BatchM ()
setType BatchType
BatchLogged
  Consistency -> BatchM ()
setConsistency Consistency
LocalQuorum
  Maybe (Range 1 256 Text)
-> (Range 1 256 Text -> BatchM ()) -> BatchM ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (TeamUpdateData
u TeamUpdateData
-> Getting
     (Maybe (Range 1 256 Text))
     TeamUpdateData
     (Maybe (Range 1 256 Text))
-> Maybe (Range 1 256 Text)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Range 1 256 Text))
  TeamUpdateData
  (Maybe (Range 1 256 Text))
Lens' TeamUpdateData (Maybe (Range 1 256 Text))
nameUpdate) ((Range 1 256 Text -> BatchM ()) -> BatchM ())
-> (Range 1 256 Text -> BatchM ()) -> BatchM ()
forall a b. (a -> b) -> a -> b
$ \Range 1 256 Text
n ->
    PrepQuery W (Text, TeamId) () -> (Text, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Text, TeamId) ()
Cql.updateTeamName (Range 1 256 Text -> Text
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange Range 1 256 Text
n, TeamId
tid)
  Maybe Icon -> (Icon -> BatchM ()) -> BatchM ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (TeamUpdateData
u TeamUpdateData
-> Getting (Maybe Icon) TeamUpdateData (Maybe Icon) -> Maybe Icon
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Icon) TeamUpdateData (Maybe Icon)
Lens' TeamUpdateData (Maybe Icon)
iconUpdate) ((Icon -> BatchM ()) -> BatchM ())
-> (Icon -> BatchM ()) -> BatchM ()
forall a b. (a -> b) -> a -> b
$ \Icon
i ->
    PrepQuery W (Text, TeamId) () -> (Text, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Text, TeamId) ()
Cql.updateTeamIcon (ByteString -> Text
decodeUtf8 (ByteString -> Text) -> (Icon -> ByteString) -> Icon -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Icon -> ByteString
forall a. ToByteString a => a -> ByteString
toByteString' (Icon -> Text) -> Icon -> Text
forall a b. (a -> b) -> a -> b
$ Icon
i, TeamId
tid)
  Maybe (Range 1 256 Text)
-> (Range 1 256 Text -> BatchM ()) -> BatchM ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (TeamUpdateData
u TeamUpdateData
-> Getting
     (Maybe (Range 1 256 Text))
     TeamUpdateData
     (Maybe (Range 1 256 Text))
-> Maybe (Range 1 256 Text)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Range 1 256 Text))
  TeamUpdateData
  (Maybe (Range 1 256 Text))
Lens' TeamUpdateData (Maybe (Range 1 256 Text))
iconKeyUpdate) ((Range 1 256 Text -> BatchM ()) -> BatchM ())
-> (Range 1 256 Text -> BatchM ()) -> BatchM ()
forall a b. (a -> b) -> a -> b
$ \Range 1 256 Text
k ->
    PrepQuery W (Text, TeamId) () -> (Text, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Text, TeamId) ()
Cql.updateTeamIconKey (Range 1 256 Text -> Text
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange Range 1 256 Text
k, TeamId
tid)
  Maybe Icon -> (Icon -> BatchM ()) -> BatchM ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (TeamUpdateData
u TeamUpdateData
-> Getting (Maybe Icon) TeamUpdateData (Maybe Icon) -> Maybe Icon
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Icon) TeamUpdateData (Maybe Icon)
Lens' TeamUpdateData (Maybe Icon)
splashScreenUpdate) ((Icon -> BatchM ()) -> BatchM ())
-> (Icon -> BatchM ()) -> BatchM ()
forall a b. (a -> b) -> a -> b
$ \Icon
ss ->
    PrepQuery W (Text, TeamId) () -> (Text, TeamId) -> BatchM ()
forall a b.
(Show a, Tuple a, Tuple b) =>
PrepQuery W a b -> a -> BatchM ()
addPrepQuery PrepQuery W (Text, TeamId) ()
Cql.updateTeamSplashScreen (ByteString -> Text
decodeUtf8 (ByteString -> Text) -> (Icon -> ByteString) -> Icon -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Icon -> ByteString
forall a. ToByteString a => a -> ByteString
toByteString' (Icon -> Text) -> Icon -> Text
forall a b. (a -> b) -> a -> b
$ Icon
ss, TeamId
tid)

-- | Construct 'TeamMember' from database tuple.
-- If FeatureLegalHoldWhitelistTeamsAndImplicitConsent is enabled set UserLegalHoldDisabled
-- if team is whitelisted.
--
-- Throw an exception if one of invitation timestamp and inviter is 'Nothing' and the
-- other is 'Just', which can only be caused by inconsistent database content.
newTeamMember' ::
  FeatureDefaults LegalholdConfig ->
  TeamId ->
  (UserId, Permissions, Maybe UserId, Maybe UTCTimeMillis, Maybe UserLegalHoldStatus) ->
  Client TeamMember
newTeamMember' :: FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
tid (UserId
uid, Permissions
perms, Maybe UserId
minvu, Maybe UTCTimeMillis
minvt, UserLegalHoldStatus
-> Maybe UserLegalHoldStatus -> UserLegalHoldStatus
forall a. a -> Maybe a -> a
fromMaybe UserLegalHoldStatus
defUserLegalHoldStatus -> UserLegalHoldStatus
lhStatus) = do
  Maybe UserId -> Maybe UTCTimeMillis -> Client TeamMember
mk Maybe UserId
minvu Maybe UTCTimeMillis
minvt Client TeamMember
-> (TeamMember -> Client TeamMember) -> Client TeamMember
forall a b. Client a -> (a -> Client b) -> Client b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TeamMember -> Client TeamMember
maybeGrant
  where
    maybeGrant :: TeamMember -> Client TeamMember
    maybeGrant :: TeamMember -> Client TeamMember
maybeGrant TeamMember
m =
      Client Bool
-> Client TeamMember -> Client TeamMember -> Client TeamMember
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM
        (FeatureDefaults LegalholdConfig -> TeamId -> Client Bool
isTeamLegalholdWhitelisted FeatureDefaults LegalholdConfig
lh TeamId
tid)
        (TeamMember -> Client TeamMember
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeamMember -> TeamMember
grantImplicitConsent TeamMember
m))
        (TeamMember -> Client TeamMember
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TeamMember
m)

    grantImplicitConsent :: TeamMember -> TeamMember
    grantImplicitConsent :: TeamMember -> TeamMember
grantImplicitConsent =
      (UserLegalHoldStatus -> Identity UserLegalHoldStatus)
-> TeamMember -> Identity TeamMember
forall (tag :: PermissionTag) (f :: * -> *).
Functor f =>
(UserLegalHoldStatus -> f UserLegalHoldStatus)
-> TeamMember' tag -> f (TeamMember' tag)
legalHoldStatus ((UserLegalHoldStatus -> Identity UserLegalHoldStatus)
 -> TeamMember -> Identity TeamMember)
-> (UserLegalHoldStatus -> UserLegalHoldStatus)
-> TeamMember
-> TeamMember
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ \case
        UserLegalHoldStatus
UserLegalHoldNoConsent -> UserLegalHoldStatus
UserLegalHoldDisabled
        -- the other cases don't change; we just enumerate them to catch future changes in
        -- 'UserLegalHoldStatus' better.
        UserLegalHoldStatus
UserLegalHoldDisabled -> UserLegalHoldStatus
UserLegalHoldDisabled
        UserLegalHoldStatus
UserLegalHoldPending -> UserLegalHoldStatus
UserLegalHoldPending
        UserLegalHoldStatus
UserLegalHoldEnabled -> UserLegalHoldStatus
UserLegalHoldEnabled

    mk :: Maybe UserId -> Maybe UTCTimeMillis -> Client TeamMember
mk (Just UserId
invu) (Just UTCTimeMillis
invt) = TeamMember -> Client TeamMember
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeamMember -> Client TeamMember)
-> TeamMember -> Client TeamMember
forall a b. (a -> b) -> a -> b
$ UserId
-> PermissionType 'Required
-> Maybe (UserId, UTCTimeMillis)
-> UserLegalHoldStatus
-> TeamMember
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> UserLegalHoldStatus
-> TeamMember' tag
mkTeamMember UserId
uid Permissions
PermissionType 'Required
perms ((UserId, UTCTimeMillis) -> Maybe (UserId, UTCTimeMillis)
forall a. a -> Maybe a
Just (UserId
invu, UTCTimeMillis
invt)) UserLegalHoldStatus
lhStatus
    mk Maybe UserId
Nothing Maybe UTCTimeMillis
Nothing = TeamMember -> Client TeamMember
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeamMember -> Client TeamMember)
-> TeamMember -> Client TeamMember
forall a b. (a -> b) -> a -> b
$ UserId
-> PermissionType 'Required
-> Maybe (UserId, UTCTimeMillis)
-> UserLegalHoldStatus
-> TeamMember
forall (tag :: PermissionTag).
UserId
-> PermissionType tag
-> Maybe (UserId, UTCTimeMillis)
-> UserLegalHoldStatus
-> TeamMember' tag
mkTeamMember UserId
uid Permissions
PermissionType 'Required
perms Maybe (UserId, UTCTimeMillis)
forall a. Maybe a
Nothing UserLegalHoldStatus
lhStatus
    mk Maybe UserId
_ Maybe UTCTimeMillis
_ = ErrorCall -> Client TeamMember
forall e a. (HasCallStack, Exception e) => e -> Client a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (ErrorCall -> Client TeamMember) -> ErrorCall -> Client TeamMember
forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"TeamMember with incomplete metadata."

teamConversationsForPagination ::
  TeamId ->
  Maybe ConvId ->
  Range 1 HardTruncationLimit Int32 ->
  Client (Page TeamConversation)
teamConversationsForPagination :: TeamId
-> Maybe ConvId
-> Range 1 HardTruncationLimit Int32
-> Client (Page TeamConversation)
teamConversationsForPagination TeamId
tid Maybe ConvId
start (Range 1 HardTruncationLimit Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) =
  (Identity ConvId -> TeamConversation)
-> Page (Identity ConvId) -> Page TeamConversation
forall a b. (a -> b) -> Page a -> Page b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ConvId -> TeamConversation
newTeamConversation (ConvId -> TeamConversation)
-> (Identity ConvId -> ConvId)
-> Identity ConvId
-> TeamConversation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity ConvId -> ConvId
forall a. Identity a -> a
runIdentity) (Page (Identity ConvId) -> Page TeamConversation)
-> Client (Page (Identity ConvId))
-> Client (Page TeamConversation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Maybe ConvId
start of
    Just ConvId
c -> PrepQuery R (TeamId, ConvId) (Identity ConvId)
-> QueryParams (TeamId, ConvId) -> Client (Page (Identity ConvId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (TeamId, ConvId) (Identity ConvId)
Cql.selectTeamConvsFrom (Consistency
-> (TeamId, ConvId) -> Int32 -> QueryParams (TeamId, ConvId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (TeamId
tid, ConvId
c) Int32
max)
    Maybe ConvId
Nothing -> PrepQuery R (Identity TeamId) (Identity ConvId)
-> QueryParams (Identity TeamId) -> Client (Page (Identity ConvId))
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (Identity TeamId) (Identity ConvId)
Cql.selectTeamConvs (Consistency
-> Identity TeamId -> Int32 -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid) Int32
max)

type RawTeamMember = (UserId, Permissions, Maybe UserId, Maybe UTCTimeMillis, Maybe UserLegalHoldStatus)

-- This function has a bit of a difficult type to work with because we don't
-- have a pure function of type RawTeamMember -> TeamMember so we cannot fmap
-- over the ResultSet. We don't want to mess around with the Result size
-- nextPage either otherwise
teamMembersForPagination :: TeamId -> Maybe UserId -> Range 1 HardTruncationLimit Int32 -> Client (Page RawTeamMember)
teamMembersForPagination :: TeamId
-> Maybe UserId
-> Range 1 HardTruncationLimit Int32
-> Client (Page RawTeamMember)
teamMembersForPagination TeamId
tid Maybe UserId
start (Range 1 HardTruncationLimit Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) =
  case Maybe UserId
start of
    Just UserId
u -> PrepQuery R (TeamId, UserId) RawTeamMember
-> QueryParams (TeamId, UserId) -> Client (Page RawTeamMember)
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (TeamId, UserId) RawTeamMember
Cql.selectTeamMembersFrom (Consistency
-> (TeamId, UserId) -> Int32 -> QueryParams (TeamId, UserId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (TeamId
tid, UserId
u) Int32
max)
    Maybe UserId
Nothing -> PrepQuery R (Identity TeamId) RawTeamMember
-> QueryParams (Identity TeamId) -> Client (Page RawTeamMember)
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (Page b)
paginate PrepQuery R (Identity TeamId) RawTeamMember
Cql.selectTeamMembers (Consistency
-> Identity TeamId -> Int32 -> QueryParams (Identity TeamId)
forall a. Consistency -> a -> Int32 -> QueryParams a
paramsP Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid) Int32
max)

teamMembersPageFrom ::
  FeatureDefaults LegalholdConfig ->
  TeamId ->
  Maybe PagingState ->
  Range 1 HardTruncationLimit Int32 ->
  Client (PageWithState TeamMember)
teamMembersPageFrom :: FeatureDefaults LegalholdConfig
-> TeamId
-> Maybe PagingState
-> Range 1 HardTruncationLimit Int32
-> Client (PageWithState TeamMember)
teamMembersPageFrom FeatureDefaults LegalholdConfig
lh TeamId
tid Maybe PagingState
pagingState (Range 1 HardTruncationLimit Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) = do
  PageWithState RawTeamMember
page <- PrepQuery R (Identity TeamId) RawTeamMember
-> QueryParams (Identity TeamId)
-> Client (PageWithState RawTeamMember)
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (PageWithState b)
paginateWithState PrepQuery R (Identity TeamId) RawTeamMember
Cql.selectTeamMembers (Consistency
-> Identity TeamId
-> Int32
-> Maybe PagingState
-> QueryParams (Identity TeamId)
forall a.
Consistency -> a -> Int32 -> Maybe PagingState -> QueryParams a
paramsPagingState Consistency
LocalQuorum (TeamId -> Identity TeamId
forall a. a -> Identity a
Identity TeamId
tid) Int32
max Maybe PagingState
pagingState)
  [TeamMember]
members <- (RawTeamMember -> Client TeamMember)
-> [RawTeamMember] -> Client [TeamMember]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
tid) (PageWithState RawTeamMember -> [RawTeamMember]
forall a. PageWithState a -> [a]
pwsResults PageWithState RawTeamMember
page)
  PageWithState TeamMember -> Client (PageWithState TeamMember)
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PageWithState TeamMember -> Client (PageWithState TeamMember))
-> PageWithState TeamMember -> Client (PageWithState TeamMember)
forall a b. (a -> b) -> a -> b
$ [TeamMember] -> Maybe PagingState -> PageWithState TeamMember
forall a. [a] -> Maybe PagingState -> PageWithState a
PageWithState [TeamMember]
members (PageWithState RawTeamMember -> Maybe PagingState
forall a. PageWithState a -> Maybe PagingState
pwsState PageWithState RawTeamMember
page)

selectSomeTeamMembersPaginated ::
  FeatureDefaults LegalholdConfig ->
  TeamId ->
  [UserId] ->
  Maybe PagingState ->
  Range 1 HardTruncationLimit Int32 ->
  Client (PageWithState TeamMember)
selectSomeTeamMembersPaginated :: FeatureDefaults LegalholdConfig
-> TeamId
-> [UserId]
-> Maybe PagingState
-> Range 1 HardTruncationLimit Int32
-> Client (PageWithState TeamMember)
selectSomeTeamMembersPaginated FeatureDefaults LegalholdConfig
lh TeamId
tid [UserId]
uids Maybe PagingState
pagingState (Range 1 HardTruncationLimit Int32 -> Int32
forall (n :: Nat) (m :: Nat) a. Range n m a -> a
fromRange -> Int32
max) = do
  PageWithState RawTeamMember
page <- PrepQuery R (TeamId, [UserId]) RawTeamMember
-> QueryParams (TeamId, [UserId])
-> Client (PageWithState RawTeamMember)
forall (m :: * -> *) a b (q :: * -> * -> * -> *).
(MonadClient m, Tuple a, Tuple b, RunQ q) =>
q R a b -> QueryParams a -> m (PageWithState b)
paginateWithState PrepQuery R (TeamId, [UserId]) RawTeamMember
Cql.selectTeamMembers' (Consistency
-> (TeamId, [UserId])
-> Int32
-> Maybe PagingState
-> QueryParams (TeamId, [UserId])
forall a.
Consistency -> a -> Int32 -> Maybe PagingState -> QueryParams a
paramsPagingState Consistency
LocalQuorum (TeamId
tid, [UserId]
uids) Int32
max Maybe PagingState
pagingState)
  [TeamMember]
members <- (RawTeamMember -> Client TeamMember)
-> [RawTeamMember] -> Client [TeamMember]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (FeatureDefaults LegalholdConfig
-> TeamId -> RawTeamMember -> Client TeamMember
newTeamMember' FeatureDefaults LegalholdConfig
lh TeamId
tid) (PageWithState RawTeamMember -> [RawTeamMember]
forall a. PageWithState a -> [a]
pwsResults PageWithState RawTeamMember
page)
  PageWithState TeamMember -> Client (PageWithState TeamMember)
forall a. a -> Client a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PageWithState TeamMember -> Client (PageWithState TeamMember))
-> PageWithState TeamMember -> Client (PageWithState TeamMember)
forall a b. (a -> b) -> a -> b
$ [TeamMember] -> Maybe PagingState -> PageWithState TeamMember
forall a. [a] -> Maybe PagingState -> PageWithState a
PageWithState [TeamMember]
members (PageWithState RawTeamMember -> Maybe PagingState
forall a. PageWithState a -> Maybe PagingState
pwsState PageWithState RawTeamMember
page)