module Matterhorn.Events.Websocket
  ( handleWebsocketEvent
  , handleWebsocketActionResponse
  )
where

import           Prelude ()
import           Matterhorn.Prelude

import qualified Data.HashMap.Strict as HM
import qualified Data.Sequence as Seq
import qualified Data.Set as Set
import qualified Data.Text as T
import           Lens.Micro.Platform ( preuse )

import           Network.Mattermost.Lenses
import           Network.Mattermost.Types
import           Network.Mattermost.WebSocket

import           Matterhorn.State.ChannelList
import           Matterhorn.State.Channels
import           Matterhorn.State.Common
import           Matterhorn.State.Flagging
import           Matterhorn.State.Messages
import           Matterhorn.State.Reactions
import           Matterhorn.State.Teams
import           Matterhorn.State.Users
import           Matterhorn.Types
import           Matterhorn.Types.Common


foreachTeam :: (TeamId -> MH ()) -> MH ()
foreachTeam :: (TeamId -> MH ()) -> MH ()
foreachTeam TeamId -> MH ()
act = do
    HashMap TeamId TeamState
ts <- Getting
  (HashMap TeamId TeamState) ChatState (HashMap TeamId TeamState)
-> MH (HashMap TeamId TeamState)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting
  (HashMap TeamId TeamState) ChatState (HashMap TeamId TeamState)
Lens' ChatState (HashMap TeamId TeamState)
csTeams
    let myTIds :: [TeamId]
myTIds = HashMap TeamId TeamState -> [TeamId]
forall k v. HashMap k v -> [k]
HM.keys HashMap TeamId TeamState
ts
    (TeamId -> MH ()) -> [TeamId] -> MH ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TeamId -> MH ()
act [TeamId]
myTIds

handleWebsocketEvent :: WebsocketEvent -> MH ()
handleWebsocketEvent :: WebsocketEvent -> MH ()
handleWebsocketEvent WebsocketEvent
we = do
    UserId
myId <- (ChatState -> UserId) -> MH UserId
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ChatState -> UserId
myUserId
    HashMap TeamId TeamState
ts <- Getting
  (HashMap TeamId TeamState) ChatState (HashMap TeamId TeamState)
-> MH (HashMap TeamId TeamState)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting
  (HashMap TeamId TeamState) ChatState (HashMap TeamId TeamState)
Lens' ChatState (HashMap TeamId TeamState)
csTeams
    let memberOf :: TeamId -> Bool
memberOf TeamId
tId = TeamId -> HashMap TeamId TeamState -> Bool
forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
HM.member TeamId
tId HashMap TeamId TeamState
ts

        -- The team ID is one of the teams we're in, or the team ID is
        -- absent, which typically indicates a DM channel event since DM
        -- channels are not associated with teams.
        inMyTeamOrDM :: Maybe TeamId -> Bool
inMyTeamOrDM (Just TeamId
i) = TeamId -> Bool
memberOf TeamId
i
        inMyTeamOrDM Maybe TeamId
Nothing = Bool
True

        -- The team ID is one of the teams we're in. A missing team ID
        -- yields False.
        inMyTeam :: Maybe TeamId -> Bool
inMyTeam (Just TeamId
i) = TeamId -> Bool
memberOf TeamId
i
        inMyTeam Maybe TeamId
Nothing = Bool
False

    case WebsocketEvent -> WebsocketEventType
weEvent WebsocketEvent
we of
        WebsocketEventType
WMPosted
            | Just Post
p <- WEData -> Maybe Post
wepPost (WebsocketEvent -> WEData
weData WebsocketEvent
we) ->
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe TeamId -> Bool
inMyTeamOrDM (WEData -> Maybe TeamId
wepTeamId (WebsocketEvent -> WEData
weData WebsocketEvent
we))) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$ do
                    let wasMentioned :: Bool
wasMentioned = Bool -> (Set UserId -> Bool) -> Maybe (Set UserId) -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (UserId -> Set UserId -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member UserId
myId) (Maybe (Set UserId) -> Bool) -> Maybe (Set UserId) -> Bool
forall a b. (a -> b) -> a -> b
$ WEData -> Maybe (Set UserId)
wepMentions (WebsocketEvent -> WEData
weData WebsocketEvent
we)
                    PostToAdd -> MH ()
addNewPostedMessage (PostToAdd -> MH ()) -> PostToAdd -> MH ()
forall a b. (a -> b) -> a -> b
$ Post -> Bool -> PostToAdd
RecentPost Post
p Bool
wasMentioned
                    TeamId
tId <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
                    ChannelId
cId <- Getting ChannelId ChatState ChannelId -> MH ChannelId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (TeamId -> SimpleGetter ChatState ChannelId
csCurrentChannelId TeamId
tId)
                    Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Post -> ChannelId
postChannelId Post
p ChannelId -> ChannelId -> Bool
forall a. Eq a => a -> a -> Bool
/= ChannelId
cId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                        ChannelId -> Bool -> MH ()
showChannelInSidebar (Post
pPost -> Getting ChannelId Post ChannelId -> ChannelId
forall s a. s -> Getting a s a -> a
^.Getting ChannelId Post ChannelId
Lens' Post ChannelId
postChannelIdL) Bool
False
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMPostEdited
            | Just Post
p <- WEData -> Maybe Post
wepPost (WebsocketEvent -> WEData
weData WebsocketEvent
we) -> do
                Post -> MH ()
editMessage Post
p

                TeamId
currTid <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
                (TeamId -> MH ()) -> MH ()
foreachTeam ((TeamId -> MH ()) -> MH ()) -> (TeamId -> MH ()) -> MH ()
forall a b. (a -> b) -> a -> b
$ \TeamId
tId -> do
                    ChannelId
cId <- Getting ChannelId ChatState ChannelId -> MH ChannelId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (TeamId -> SimpleGetter ChatState ChannelId
csCurrentChannelId TeamId
tId)
                    Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Post -> ChannelId
postChannelId Post
p ChannelId -> ChannelId -> Bool
forall a. Eq a => a -> a -> Bool
== ChannelId
cId Bool -> Bool -> Bool
&& TeamId
tId TeamId -> TeamId -> Bool
forall a. Eq a => a -> a -> Bool
== TeamId
currTid) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                        Bool -> MH ()
updateViewed Bool
False
                    Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Post -> ChannelId
postChannelId Post
p ChannelId -> ChannelId -> Bool
forall a. Eq a => a -> a -> Bool
/= ChannelId
cId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                        ChannelId -> Bool -> MH ()
showChannelInSidebar (Post
pPost -> Getting ChannelId Post ChannelId -> ChannelId
forall s a. s -> Getting a s a -> a
^.Getting ChannelId Post ChannelId
Lens' Post ChannelId
postChannelIdL) Bool
False
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMPostDeleted
            | Just Post
p <- WEData -> Maybe Post
wepPost (WebsocketEvent -> WEData
weData WebsocketEvent
we) -> do
                Post -> MH ()
deleteMessage Post
p

                TeamId
currTid <- Getting TeamId ChatState TeamId -> MH TeamId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting TeamId ChatState TeamId
SimpleGetter ChatState TeamId
csCurrentTeamId
                (TeamId -> MH ()) -> MH ()
foreachTeam ((TeamId -> MH ()) -> MH ()) -> (TeamId -> MH ()) -> MH ()
forall a b. (a -> b) -> a -> b
$ \TeamId
tId -> do
                    ChannelId
cId <- Getting ChannelId ChatState ChannelId -> MH ChannelId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (TeamId -> SimpleGetter ChatState ChannelId
csCurrentChannelId TeamId
tId)
                    Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Post -> ChannelId
postChannelId Post
p ChannelId -> ChannelId -> Bool
forall a. Eq a => a -> a -> Bool
== ChannelId
cId Bool -> Bool -> Bool
&& TeamId
tId TeamId -> TeamId -> Bool
forall a. Eq a => a -> a -> Bool
== TeamId
currTid) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                        Bool -> MH ()
updateViewed Bool
False
                    Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Post -> ChannelId
postChannelId Post
p ChannelId -> ChannelId -> Bool
forall a. Eq a => a -> a -> Bool
/= ChannelId
cId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                        ChannelId -> Bool -> MH ()
showChannelInSidebar (Post
pPost -> Getting ChannelId Post ChannelId -> ChannelId
forall s a. s -> Getting a s a -> a
^.Getting ChannelId Post ChannelId
Lens' Post ChannelId
postChannelIdL) Bool
False
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMStatusChange
            | Just Text
status <- WEData -> Maybe Text
wepStatus (WebsocketEvent -> WEData
weData WebsocketEvent
we)
            , Just UserId
uId <- WEData -> Maybe UserId
wepUserId (WebsocketEvent -> WEData
weData WebsocketEvent
we) ->
                UserId -> Text -> MH ()
setUserStatus UserId
uId Text
status
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        -- Despite this event's name, it means "a user was added to a
        -- channel". The event that occurs when a new user is added to
        -- the server, see WMNewUser.
        WebsocketEventType
WMUserAdded
            | Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) ->
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (WEData -> Maybe UserId
wepUserId (WebsocketEvent -> WEData
weData WebsocketEvent
we) Maybe UserId -> Maybe UserId -> Bool
forall a. Eq a => a -> a -> Bool
== UserId -> Maybe UserId
forall a. a -> Maybe a
Just UserId
myId Bool -> Bool -> Bool
&&
                      Maybe TeamId -> Bool
inMyTeam (WEData -> Maybe TeamId
wepTeamId (WebsocketEvent -> WEData
weData WebsocketEvent
we))) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                    ChannelId -> MH ()
handleChannelInvite ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMNewUser
            | Just UserId
uId <- WEData -> Maybe UserId
wepUserId (WEData -> Maybe UserId) -> WEData -> Maybe UserId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we ->
                Seq UserId -> MH () -> MH ()
handleNewUsers (UserId -> Seq UserId
forall a. a -> Seq a
Seq.singleton UserId
uId) (() -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMUserRemoved
            | Just ChannelId
cId <- WEData -> Maybe ChannelId
wepChannelId (WebsocketEvent -> WEData
weData WebsocketEvent
we) ->
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (WEBroadcast -> Maybe UserId
webUserId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) Maybe UserId -> Maybe UserId -> Bool
forall a. Eq a => a -> a -> Bool
== UserId -> Maybe UserId
forall a. a -> Maybe a
Just UserId
myId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                    ChannelId -> MH ()
removeChannelFromState ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMTyping
            | Just UserId
uId <- WEData -> Maybe UserId
wepUserId (WEData -> Maybe UserId) -> WEData -> Maybe UserId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we
            , Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) -> UserId -> ChannelId -> MH ()
handleTypingUser UserId
uId ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMChannelDeleted
            | Just ChannelId
cId <- WEData -> Maybe ChannelId
wepChannelId (WebsocketEvent -> WEData
weData WebsocketEvent
we) ->
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe TeamId -> Bool
inMyTeamOrDM (WEBroadcast -> Maybe TeamId
webTeamId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we))) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                    ChannelId -> MH ()
removeChannelFromState ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMDirectAdded
            | Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) -> ChannelId -> MH ()
handleChannelInvite ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        -- An 'ephemeral message' is just Mattermost's version of our
        -- 'client message'. This can be a little bit wacky, e.g.
        -- if the user types '/shortcuts' in the browser, we'll get
        -- an ephemeral message even in MatterHorn with the browser
        -- shortcuts, but it's probably a good idea to handle these
        -- messages anyway.
        WebsocketEventType
WMEphemeralMessage
            | Just Post
p <- WEData -> Maybe Post
wepPost (WEData -> Maybe Post) -> WEData -> Maybe Post
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we -> Text -> MH ()
postInfoMessage (UserText -> Text
sanitizeUserText (UserText -> Text) -> UserText -> Text
forall a b. (a -> b) -> a -> b
$ Post
pPost -> Getting UserText Post UserText -> UserText
forall s a. s -> Getting a s a -> a
^.Getting UserText Post UserText
Lens' Post UserText
postMessageL)
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMPreferenceChanged
            | Just Seq Preference
prefs <- WEData -> Maybe (Seq Preference)
wepPreferences (WebsocketEvent -> WEData
weData WebsocketEvent
we) ->
                (Preference -> MH ()) -> Seq Preference -> MH ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Preference -> MH ()
applyPreferenceChange Seq Preference
prefs
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMPreferenceDeleted
            | Just Seq Preference
pref <- WEData -> Maybe (Seq Preference)
wepPreferences (WebsocketEvent -> WEData
weData WebsocketEvent
we)
            , Just Seq FlaggedPost
fps <- (Preference -> Maybe FlaggedPost)
-> Seq Preference -> Maybe (Seq FlaggedPost)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Preference -> Maybe FlaggedPost
preferenceToFlaggedPost Seq Preference
pref ->
              Seq FlaggedPost -> (FlaggedPost -> MH ()) -> MH ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ Seq FlaggedPost
fps ((FlaggedPost -> MH ()) -> MH ())
-> (FlaggedPost -> MH ()) -> MH ()
forall a b. (a -> b) -> a -> b
$ \FlaggedPost
f ->
                  PostId -> Bool -> MH ()
updateMessageFlag (FlaggedPost -> PostId
flaggedPostId FlaggedPost
f) Bool
False
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMReactionAdded
            | Just Reaction
r <- WEData -> Maybe Reaction
wepReaction (WebsocketEvent -> WEData
weData WebsocketEvent
we)
            , Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) -> ChannelId -> [Reaction] -> MH ()
addReactions ChannelId
cId [Reaction
r]
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMReactionRemoved
            | Just Reaction
r <- WEData -> Maybe Reaction
wepReaction (WebsocketEvent -> WEData
weData WebsocketEvent
we)
            , Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) -> Reaction -> ChannelId -> MH ()
removeReaction Reaction
r ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMChannelViewed
            | Just ChannelId
cId <- WEData -> Maybe ChannelId
wepChannelId (WEData -> Maybe ChannelId) -> WEData -> Maybe ChannelId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we -> ChannelId -> MH ()
refreshChannelById ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMChannelUpdated
            | Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WEBroadcast -> Maybe ChannelId) -> WEBroadcast -> Maybe ChannelId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we -> do
                Maybe ClientChannel
mChan <- Getting (First ClientChannel) ChatState ClientChannel
-> MH (Maybe ClientChannel)
forall s (m :: * -> *) a.
MonadState s m =>
Getting (First a) s a -> m (Maybe a)
preuse (ChannelId -> Traversal' ChatState ClientChannel
csChannel(ChannelId
cId))
                case Maybe ClientChannel
mChan of
                    Just ClientChannel
chan -> do
                        ChannelId -> MH ()
refreshChannelById ChannelId
cId
                        Maybe TeamId -> MH ()
updateSidebar (ClientChannel
chanClientChannel
-> Getting (Maybe TeamId) ClientChannel (Maybe TeamId)
-> Maybe TeamId
forall s a. s -> Getting a s a -> a
^.(ChannelInfo -> Const (Maybe TeamId) ChannelInfo)
-> ClientChannel -> Const (Maybe TeamId) ClientChannel
Lens' ClientChannel ChannelInfo
ccInfo((ChannelInfo -> Const (Maybe TeamId) ChannelInfo)
 -> ClientChannel -> Const (Maybe TeamId) ClientChannel)
-> ((Maybe TeamId -> Const (Maybe TeamId) (Maybe TeamId))
    -> ChannelInfo -> Const (Maybe TeamId) ChannelInfo)
-> Getting (Maybe TeamId) ClientChannel (Maybe TeamId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Maybe TeamId -> Const (Maybe TeamId) (Maybe TeamId))
-> ChannelInfo -> Const (Maybe TeamId) ChannelInfo
Lens' ChannelInfo (Maybe TeamId)
cdTeamId)
                    Maybe ClientChannel
Nothing -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMGroupAdded
            | Just ChannelId
cId <- WEBroadcast -> Maybe ChannelId
webChannelId (WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we) -> ChannelId -> MH ()
handleChannelInvite ChannelId
cId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMChannelMemberUpdated
            | Just ChannelMember
channelMember <- WEData -> Maybe ChannelMember
wepChannelMember (WEData -> Maybe ChannelMember) -> WEData -> Maybe ChannelMember
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we ->
                  Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ChannelMember -> UserId
channelMemberUserId ChannelMember
channelMember UserId -> UserId -> Bool
forall a. Eq a => a -> a -> Bool
== UserId
myId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$
                      ChannelId -> ChannelNotifyProps -> MH ()
updateChannelNotifyProps
                      (ChannelMember -> ChannelId
channelMemberChannelId ChannelMember
channelMember)
                      (ChannelMember -> ChannelNotifyProps
channelMemberNotifyProps ChannelMember
channelMember)
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMAddedToTeam
            | Just TeamId
tId <- WEData -> Maybe TeamId
wepTeamId (WEData -> Maybe TeamId) -> WEData -> Maybe TeamId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we
            , Just UserId
uId <- WEData -> Maybe UserId
wepUserId (WEData -> Maybe UserId) -> WEData -> Maybe UserId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we -> do
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (UserId
uId UserId -> UserId -> Bool
forall a. Eq a => a -> a -> Bool
== UserId
myId Bool -> Bool -> Bool
&& Bool -> Bool
not (TeamId -> Bool
memberOf TeamId
tId)) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$ do
                    TeamId -> MH ()
handleJoinTeam TeamId
tId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMUpdateTeam
            | Just TeamId
tId <- WEBroadcast -> Maybe TeamId
webTeamId (WEBroadcast -> Maybe TeamId) -> WEBroadcast -> Maybe TeamId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEBroadcast
weBroadcast WebsocketEvent
we -> do
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (TeamId -> Bool
memberOf TeamId
tId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$ do
                    TeamId -> MH ()
handleUpdateTeam TeamId
tId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMLeaveTeam
            | Just TeamId
tId <- WEData -> Maybe TeamId
wepTeamId (WEData -> Maybe TeamId) -> WEData -> Maybe TeamId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we
            , Just UserId
uId <- WEData -> Maybe UserId
wepUserId (WEData -> Maybe UserId) -> WEData -> Maybe UserId
forall a b. (a -> b) -> a -> b
$ WebsocketEvent -> WEData
weData WebsocketEvent
we -> do
                Bool -> MH () -> MH ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (UserId
uId UserId -> UserId -> Bool
forall a. Eq a => a -> a -> Bool
== UserId
myId Bool -> Bool -> Bool
&& TeamId -> Bool
memberOf TeamId
tId) (MH () -> MH ()) -> MH () -> MH ()
forall a b. (a -> b) -> a -> b
$ do
                    TeamId -> MH ()
handleLeaveTeam TeamId
tId
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        WebsocketEventType
WMTeamDeleted -> do
            LogCategory -> Text -> MH ()
mhLog LogCategory
LogGeneral (Text -> MH ()) -> Text -> MH ()
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
                String
"WMTeamDeleted event: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> WebsocketEvent -> String
forall a. Show a => a -> String
show WebsocketEvent
we

        WebsocketEventType
WMUserUpdated
            | Just User
user <- WEData -> Maybe User
wepUser (WebsocketEvent -> WEData
weData WebsocketEvent
we) -> do
                User -> MH ()
handleUserUpdated User
user
                ChannelId
cid <- Getting ChannelId ChatState ChannelId -> MH ChannelId
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting ChannelId ChatState ChannelId -> MH ChannelId)
-> Getting ChannelId ChatState ChannelId -> MH ChannelId
forall a b. (a -> b) -> a -> b
$ (ClientChannel -> Const ChannelId ClientChannel)
-> ChatState -> Const ChannelId ChatState
Lens' ChatState ClientChannel
csCurrentChannel ((ClientChannel -> Const ChannelId ClientChannel)
 -> ChatState -> Const ChannelId ChatState)
-> ((ChannelId -> Const ChannelId ChannelId)
    -> ClientChannel -> Const ChannelId ClientChannel)
-> Getting ChannelId ChatState ChannelId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ChannelInfo -> Const ChannelId ChannelInfo)
-> ClientChannel -> Const ChannelId ClientChannel
Lens' ClientChannel ChannelInfo
ccInfo ((ChannelInfo -> Const ChannelId ChannelInfo)
 -> ClientChannel -> Const ChannelId ClientChannel)
-> ((ChannelId -> Const ChannelId ChannelId)
    -> ChannelInfo -> Const ChannelId ChannelInfo)
-> (ChannelId -> Const ChannelId ChannelId)
-> ClientChannel
-> Const ChannelId ClientChannel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ChannelId -> Const ChannelId ChannelId)
-> ChannelInfo -> Const ChannelId ChannelInfo
Lens' ChannelInfo ChannelId
cdChannelId
                ChannelId -> MH ()
refreshChannelById ChannelId
cid
            | Bool
otherwise -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        -- We deliberately ignore these events:
        WebsocketEventType
WMChannelCreated -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMEmojiAdded -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMWebRTC -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMHello -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMAuthenticationChallenge -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMUserRoleUpdated -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMPluginStatusesChanged -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMPluginEnabled -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WebsocketEventType
WMPluginDisabled -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        WMUnknownEvent {} ->
            LogCategory -> Text -> MH ()
mhLog LogCategory
LogWebsocket (Text -> MH ()) -> Text -> MH ()
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
                String
"Websocket event not handled due to unknown event type: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> WebsocketEvent -> String
forall a. Show a => a -> String
show WebsocketEvent
we

handleWebsocketActionResponse :: WebsocketActionResponse -> MH ()
handleWebsocketActionResponse :: WebsocketActionResponse -> MH ()
handleWebsocketActionResponse WebsocketActionResponse
r =
    case WebsocketActionResponse -> WebsocketActionStatus
warStatus WebsocketActionResponse
r of
        WebsocketActionStatus
WebsocketActionStatusOK -> () -> MH ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()