{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE OverloadedStrings    #-}
{-# LANGUAGE TupleSections        #-}
module Network.Mattermost
( -- * Types
  -- ** Mattermost-Related Types (deprecated: use Network.Mattermost.Types instead)
  -- n.b. the deprecation notice is in that haddock header because we're
  -- still waiting for https://ghc.haskell.org/trac/ghc/ticket/4879 ...
  ConnectionPoolConfig(..)
, Login(..)
, Hostname
, Port
, ConnectionData
, Session
, Id(..)
, User(..)
, UserId(..)
, InitialLoad(..)
, Team(..)
, TeamMember(..)
, Type(..)
, TeamId(..)
, TeamsCreate(..)
, Channel(..)
, ChannelWithData(..)
, ChannelData(..)
, ChannelId(..)
, Channels
, ConnectionType(..)
, MinChannel(..)
, UsersCreate(..)
, Post(..)
, PostType(..)
, PostProps(..)
, PendingPost(..)
, PostId(..)
, FileId(..)
, FileInfo(..)
, Reaction(..)
, urlForFile
, Posts(..)
, MinCommand(..)
, CommandResponse(..)
, CommandResponseType(..)
, Preference(..)
, PreferenceCategory(..)
, PreferenceName(..)
, PreferenceValue(..)
, FlaggedPost(..)
, preferenceToFlaggedPost
-- ** Log-related types
, Logger
, LogEvent(..)
, LogEventType(..)
, withLogger
, noLogger
-- * Typeclasses
, HasId(..)
-- * HTTP API Functions
, defaultConnectionPoolConfig
, mkConnectionData
, initConnectionData
, mmCloseSession
, mmLogin
, mmCreateDirect
, mmCreateChannel
, mmCreateGroupChannel
, mmCreateTeam
, mmDeleteChannel
, mmLeaveChannel
, mmJoinChannel
, mmGetTeams
, mmGetChannels
, mmGetAllChannelsForUser
, mmGetAllChannelDataForUser
, mmGetAllChannelsWithDataForUser
, mmGetMoreChannels
, mmGetChannel
, mmViewChannel
, mmDeletePost
, mmGetPost
, mmGetPosts
, mmGetPostsSince
, mmGetPostsBefore
, mmGetPostsAfter
, mmSearchPosts
, mmGetReactionsForPost
, mmGetFileInfo
, mmGetFile
, mmGetUser
, mmGetUsers
, mmGetTeamMembers
, mmGetChannelMembers
, mmGetProfilesForDMList
, mmGetMe
, mmGetProfiles
, mmGetStatuses
, mmGetInitialLoad
, mmSaveConfig
, mmSetChannelHeader
, mmChannelAddUser
, mmChannelRemoveUser
, mmTeamAddUser
, mmUsersCreate
, mmUsersCreateWithSession
, mmPost
, mmUpdatePost
, mmExecute
, mmGetConfig
, mmGetClientConfig
, mmSetPreferences
, mmSavePreferences
, mmDeletePreferences
, mmFlagPost
, mmUnflagPost
, mmGetFlaggedPosts
, mmGetMyPreferences
, mkPendingPost
, idString
, hoistE
, noteE
, assertE
) where

import           Control.Exception (throwIO)
import           Control.Monad (when)
import           Data.Monoid ((<>))
import           Text.Printf ( printf )
import qualified Data.ByteString.Char8 as B
import qualified Data.ByteString.Lazy.Char8 as BL
import           Network.HTTP.Headers ( HeaderName(..)
                                      , mkHeader
                                      )
import           Network.HTTP.Base ( Request(..)
                                   , RequestMethod(..)
                                   , defaultUserAgent
                                   , Response_String
                                   , Response(..) )
import           Network.URI ( URI, parseRelativeReference )
import           Network.HTTP.Stream ( simpleHTTP_ )
import           Data.HashMap.Strict ( HashMap )
import qualified Data.HashMap.Strict as HM
import           Data.Aeson ( Value(..)
                            , ToJSON(..)
                            , FromJSON
                            , object
                            , (.=)
                            , encode
                            , eitherDecode
                            )
import           Data.Maybe ( maybeToList, fromJust )
import qualified Data.Foldable as F
import qualified Data.Sequence as Seq
import qualified Data.Text as T
import           Control.Arrow ( left )

import           Network.Mattermost.Connection (assertJSONResponse, mmGetHeader)
import           Network.Mattermost.Exceptions
import           Network.Mattermost.Util
import           Network.Mattermost.Types.Base
import           Network.Mattermost.Types.Internal
import           Network.Mattermost.Types


-- MM utility functions

-- | Parse a path, failing if we cannot.
mmPath :: String -> IO URI
mmPath :: String -> IO URI
mmPath String
str =
  Maybe URI -> URIParseException -> IO URI
forall e r. Exception e => Maybe r -> e -> IO r
noteE (String -> Maybe URI
parseRelativeReference String
str)
        (String -> URIParseException
URIParseException (String
"mmPath: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
str))

-- | Parse the JSON body out of a request, failing if it isn't an
--   'application/json' response, or if the parsing failed
mmGetJSONBody :: FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody :: String -> Response_String -> IO (Value, t)
mmGetJSONBody String
label Response_String
rsp = do
  Response_String -> IO ()
assertJSONResponse Response_String
rsp

  let value :: Either JSONDecodeException t
value = (String -> JSONDecodeException)
-> Either String t -> Either JSONDecodeException t
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\String
s -> String -> String -> JSONDecodeException
JSONDecodeException (String
"mmGetJSONBody: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
label String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s)
                                              (Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp))
                   (ByteString -> Either String t
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (String -> ByteString
BL.pack (Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp)))
  let rawVal :: Either JSONDecodeException Value
rawVal = (String -> JSONDecodeException)
-> Either String Value -> Either JSONDecodeException Value
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\String
s -> String -> String -> JSONDecodeException
JSONDecodeException (String
"mmGetJSONBody: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
label String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s)
                                              (Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp))
                   (ByteString -> Either String Value
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (String -> ByteString
BL.pack (Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp)))
  Either JSONDecodeException (Value, t) -> IO (Value, t)
forall e r. Exception e => Either e r -> IO r
hoistE (Either JSONDecodeException (Value, t) -> IO (Value, t))
-> Either JSONDecodeException (Value, t) -> IO (Value, t)
forall a b. (a -> b) -> a -> b
$ do
    Value
x <- Either JSONDecodeException Value
rawVal
    t
y <- Either JSONDecodeException t
value
    (Value, t) -> Either JSONDecodeException (Value, t)
forall (m :: * -> *) a. Monad m => a -> m a
return (Value
x, t
y)

-- API calls

-- | We should really only need this function to get an auth token.
-- We provide it in a fairly generic form in case we need ever need it
-- but it could be inlined into mmLogin.
mmUnauthenticatedHTTPPost :: ToJSON t => ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost :: ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
path t
json = do
  Result Response_String
rsp <- ConnectionData
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd ((MMConn -> IO (Result Response_String))
 -> IO (Result Response_String))
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let content :: ByteString
content       = ByteString -> ByteString
BL.toStrict (t -> ByteString
forall a. ToJSON a => a -> ByteString
encode t
json)
        contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request String
request       = Request :: forall a. URI -> RequestMethod -> [Header] -> a -> Request a
Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
POST
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> String -> Header
mkHeader HeaderName
HdrHost          (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrUserAgent     String
defaultUserAgent
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentType   String
"application/json"
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentLength (Int -> String
forall a. Show a => a -> String
show Int
contentLength)
                        ] [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: String
rqBody    = ByteString -> String
B.unpack ByteString
content
          }
    MMConn -> Request String -> IO (Result Response_String)
forall s.
Stream s =>
s -> Request String -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request String
request
  Either ConnectionException Response_String -> IO Response_String
forall e r. Exception e => Either e r -> IO r
hoistE (Either ConnectionException Response_String -> IO Response_String)
-> Either ConnectionException Response_String -> IO Response_String
forall a b. (a -> b) -> a -> b
$ (ConnError -> ConnectionException)
-> Result Response_String
-> Either ConnectionException Response_String
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left ConnError -> ConnectionException
ConnectionException Result Response_String
rsp

-- | Fire off a login attempt. Note: We get back more than just the auth token.
-- We also get all the server-side configuration data for the user.
--
-- route: @\/api\/v3\/users\/login@
mmLogin :: ConnectionData -> Login -> IO (Either LoginFailureException (Session, User))
mmLogin :: ConnectionData
-> Login -> IO (Either LoginFailureException (Session, User))
mmLogin ConnectionData
cd Login
login = do
  let rawPath :: String
rawPath = String
"/api/v3/users/login"
  URI
path <- String -> IO URI
mmPath String
rawPath
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
"mmLogin" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
GET String
rawPath (String -> Maybe String
forall a. a -> Maybe a
Just (Login -> String
forall a. Show a => a -> String
show (Login -> String) -> Login -> String
forall a b. (a -> b) -> a -> b
$ Login
login { password :: Text
password = Text
"<elided>" }))
  Response_String
rsp  <- ConnectionData -> URI -> Login -> IO Response_String
forall t.
ToJSON t =>
ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
path Login
login
  if (Response_String -> ResponseCode
forall a. Response a -> ResponseCode
rspCode Response_String
rsp ResponseCode -> ResponseCode -> Bool
forall a. Eq a => a -> a -> Bool
/= (Int
2,Int
0,Int
0))
    then do
        let eMsg :: String
eMsg = String
"Server returned unexpected " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> ResponseCode -> String
showRespCode (Response_String -> ResponseCode
forall a. Response a -> ResponseCode
rspCode Response_String
rsp) String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" response"
        Either LoginFailureException (Session, User)
-> IO (Either LoginFailureException (Session, User))
forall (m :: * -> *) a. Monad m => a -> m a
return (Either LoginFailureException (Session, User)
 -> IO (Either LoginFailureException (Session, User)))
-> Either LoginFailureException (Session, User)
-> IO (Either LoginFailureException (Session, User))
forall a b. (a -> b) -> a -> b
$ LoginFailureException
-> Either LoginFailureException (Session, User)
forall a b. a -> Either a b
Left (LoginFailureException
 -> Either LoginFailureException (Session, User))
-> LoginFailureException
-> Either LoginFailureException (Session, User)
forall a b. (a -> b) -> a -> b
$ String -> LoginFailureException
LoginFailureException String
eMsg
    else do
      String
token <- Response_String -> HeaderName -> IO String
mmGetHeader   Response_String
rsp (String -> HeaderName
HdrCustom String
"Token")
      (Value
raw, User
value) <- String -> Response_String -> IO (Value, User)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"User" Response_String
rsp
      ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
"mmLogin" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
        Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
rawPath (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
raw)
      Either LoginFailureException (Session, User)
-> IO (Either LoginFailureException (Session, User))
forall (m :: * -> *) a. Monad m => a -> m a
return ((Session, User) -> Either LoginFailureException (Session, User)
forall a b. b -> Either a b
Right (ConnectionData -> Token -> Session
Session ConnectionData
cd (String -> Token
Token String
token), User
value))

showRespCode :: (Int, Int, Int) -> String
showRespCode :: ResponseCode -> String
showRespCode (Int
a, Int
b, Int
c) = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show (Int -> String) -> [Int] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
a, Int
b, Int
c]

-- | Fire off a login attempt. Note: We get back more than just the auth token.
-- We also get all the server-side configuration data for the user.
--
-- route: @\/api\/v3\/users\/initial_load@
mmGetInitialLoad :: Session -> IO InitialLoad
mmGetInitialLoad :: Session -> IO InitialLoad
mmGetInitialLoad Session
sess =
  Session -> String -> String -> IO InitialLoad
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetInitialLoad" String
"/api/v3/users/initial_load"

-- | Requires an authenticated user. Returns the full list of teams.
--
-- route: @\/api\/v3\/teams\/all@
mmGetTeams :: Session -> IO (HashMap TeamId Team)
mmGetTeams :: Session -> IO (HashMap TeamId Team)
mmGetTeams Session
sess =
  Session -> String -> String -> IO (HashMap TeamId Team)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetTeams" String
"/api/v3/teams/all"

-- |
-- route: @\/api\/v3\/teams\/create@
mmCreateTeam :: Session -> TeamsCreate -> IO Team
mmCreateTeam :: Session -> TeamsCreate -> IO Team
mmCreateTeam Session
sess TeamsCreate
payload = do
  let path :: String
path = String
"/api/v3/teams/create"
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateTeam" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ TeamsCreate -> String
forall a. Show a => a -> String
show TeamsCreate
payload)
  Response_String
rsp <- Session -> URI -> TeamsCreate -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri TeamsCreate
payload
  (Value
val, Team
r) <- String -> Response_String -> IO (Value, Team)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Team" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateTeam" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  Team -> IO Team
forall (m :: * -> *) a. Monad m => a -> m a
return Team
r

-- | Requires an authenticated user. Returns the full list of channels
-- for a given team of which the user is a member
--
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/@
mmGetChannels :: Session -> TeamId -> IO Channels
mmGetChannels :: Session -> TeamId -> IO Channels
mmGetChannels Session
sess TeamId
teamid = Session -> String -> String -> IO Channels
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetChannels" (String -> IO Channels) -> String -> IO Channels
forall a b. (a -> b) -> a -> b
$
  String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/" (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)

-- | Requires an authenticated user. Returns the channels for a team of
-- which the user is not already a member
--
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/more\/{offset}\/{limit}@
mmGetMoreChannels :: Session -> TeamId -> Int -> Int -> IO Channels
mmGetMoreChannels :: Session -> TeamId -> Int -> Int -> IO Channels
mmGetMoreChannels Session
sess TeamId
teamid Int
offset Int
limit =
  Session -> String -> String -> IO Channels
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetMoreChannels" (String -> IO Channels) -> String -> IO Channels
forall a b. (a -> b) -> a -> b
$
    String -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/more/%d/%d"
           (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
           Int
offset
           Int
limit

-- | Requires an authenticated user. Returns the details of a
-- specific channel.
--
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}@
mmGetChannel :: Session
             -> TeamId
             -> ChannelId
             -> IO ChannelWithData
mmGetChannel :: Session -> TeamId -> ChannelId -> IO ChannelWithData
mmGetChannel Session
sess TeamId
teamid ChannelId
chanid = Session
-> String
-> String
-> (ChannelWithData -> IO ChannelWithData)
-> IO ChannelWithData
forall t a.
FromJSON t =>
Session -> String -> String -> (t -> IO a) -> IO a
mmWithRequest Session
sess String
"mmGetChannel"
  (String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/"
          (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
          (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid))
  ChannelWithData -> IO ChannelWithData
forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Get channel/user metadata in bulk.
mmGetAllChannelDataForUser :: Session
                           -> TeamId
                           -> UserId
                           -> IO (Seq.Seq ChannelData)
mmGetAllChannelDataForUser :: Session -> TeamId -> UserId -> IO (Seq ChannelData)
mmGetAllChannelDataForUser Session
sess TeamId
teamid UserId
userid =
    Session -> String -> String -> IO (Seq ChannelData)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetAllChannelDataForUser" (String -> IO (Seq ChannelData)) -> String -> IO (Seq ChannelData)
forall a b. (a -> b) -> a -> b
$
      String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/users/%s/teams/%s/channels/members"
             (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
userid)
             (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)

mmGetAllChannelsForUser :: Session
                        -> TeamId
                        -> UserId
                        -> IO (Seq.Seq Channel)
mmGetAllChannelsForUser :: Session -> TeamId -> UserId -> IO Channels
mmGetAllChannelsForUser Session
sess TeamId
teamid UserId
userid =
    Session -> String -> String -> IO Channels
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetAllChannelsForUser" (String -> IO Channels) -> String -> IO Channels
forall a b. (a -> b) -> a -> b
$
      String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/users/%s/teams/%s/channels"
             (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
userid)
             (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)

mmGetAllChannelsWithDataForUser :: Session
                                -> TeamId
                                -> UserId
                                -> IO (HM.HashMap ChannelId ChannelWithData)
mmGetAllChannelsWithDataForUser :: Session
-> TeamId -> UserId -> IO (HashMap ChannelId ChannelWithData)
mmGetAllChannelsWithDataForUser Session
sess TeamId
teamid UserId
userid = do
    Channels
chans <- Session -> TeamId -> UserId -> IO Channels
mmGetAllChannelsForUser Session
sess TeamId
teamid UserId
userid
    Seq ChannelData
datas <- Session -> TeamId -> UserId -> IO (Seq ChannelData)
mmGetAllChannelDataForUser Session
sess TeamId
teamid UserId
userid

    let dataMap :: HashMap ChannelId ChannelData
dataMap = [(ChannelId, ChannelData)] -> HashMap ChannelId ChannelData
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ([(ChannelId, ChannelData)] -> HashMap ChannelId ChannelData)
-> [(ChannelId, ChannelData)] -> HashMap ChannelId ChannelData
forall a b. (a -> b) -> a -> b
$ Seq (ChannelId, ChannelData) -> [(ChannelId, ChannelData)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (Seq (ChannelId, ChannelData) -> [(ChannelId, ChannelData)])
-> Seq (ChannelId, ChannelData) -> [(ChannelId, ChannelData)]
forall a b. (a -> b) -> a -> b
$ (\ChannelData
d -> (ChannelData -> ChannelId
channelDataChannelId ChannelData
d, ChannelData
d)) (ChannelData -> (ChannelId, ChannelData))
-> Seq ChannelData -> Seq (ChannelId, ChannelData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq ChannelData
datas
        mkPair :: Channel -> (ChannelId, ChannelWithData)
mkPair Channel
chan = (Channel -> ChannelId
forall x y. HasId x y => x -> y
getId Channel
chan, Channel -> ChannelData -> ChannelWithData
ChannelWithData Channel
chan (ChannelData -> ChannelWithData) -> ChannelData -> ChannelWithData
forall a b. (a -> b) -> a -> b
$ Maybe ChannelData -> ChannelData
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ChannelData -> ChannelData)
-> Maybe ChannelData -> ChannelData
forall a b. (a -> b) -> a -> b
$ ChannelId -> HashMap ChannelId ChannelData -> Maybe ChannelData
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (Channel -> ChannelId
forall x y. HasId x y => x -> y
getId Channel
chan) HashMap ChannelId ChannelData
dataMap)

    HashMap ChannelId ChannelWithData
-> IO (HashMap ChannelId ChannelWithData)
forall (m :: * -> *) a. Monad m => a -> m a
return (HashMap ChannelId ChannelWithData
 -> IO (HashMap ChannelId ChannelWithData))
-> HashMap ChannelId ChannelWithData
-> IO (HashMap ChannelId ChannelWithData)
forall a b. (a -> b) -> a -> b
$ [(ChannelId, ChannelWithData)] -> HashMap ChannelId ChannelWithData
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ([(ChannelId, ChannelWithData)]
 -> HashMap ChannelId ChannelWithData)
-> [(ChannelId, ChannelWithData)]
-> HashMap ChannelId ChannelWithData
forall a b. (a -> b) -> a -> b
$ Seq (ChannelId, ChannelWithData) -> [(ChannelId, ChannelWithData)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (Seq (ChannelId, ChannelWithData)
 -> [(ChannelId, ChannelWithData)])
-> Seq (ChannelId, ChannelWithData)
-> [(ChannelId, ChannelWithData)]
forall a b. (a -> b) -> a -> b
$ Channel -> (ChannelId, ChannelWithData)
mkPair (Channel -> (ChannelId, ChannelWithData))
-> Channels -> Seq (ChannelId, ChannelWithData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Channels
chans

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/view@
mmViewChannel :: Session
              -> TeamId
              -> ChannelId       -- ^ channel to view
              -> Maybe ChannelId -- ^ previous channel
              -> IO ()
mmViewChannel :: Session -> TeamId -> ChannelId -> Maybe ChannelId -> IO ()
mmViewChannel Session
sess TeamId
teamid ChannelId
chanid Maybe ChannelId
previd = do
  let path :: String
path    = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/view"
                       (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
      prev :: [(Text, ChannelId)]
prev    = Maybe (Text, ChannelId) -> [(Text, ChannelId)]
forall a. Maybe a -> [a]
maybeToList ((Text
"prev_channel_id" :: T.Text,) (ChannelId -> (Text, ChannelId))
-> Maybe ChannelId -> Maybe (Text, ChannelId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ChannelId
previd)
      payload :: HashMap Text ChannelId
payload = [(Text, ChannelId)] -> HashMap Text ChannelId
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ([(Text, ChannelId)] -> HashMap Text ChannelId)
-> [(Text, ChannelId)] -> HashMap Text ChannelId
forall a b. (a -> b) -> a -> b
$ [(Text
"channel_id" :: T.Text, ChannelId
chanid)] [(Text, ChannelId)] -> [(Text, ChannelId)] -> [(Text, ChannelId)]
forall a. [a] -> [a] -> [a]
++ [(Text, ChannelId)]
prev
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmViewChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ HashMap Text ChannelId -> String
forall a. Show a => a -> String
show HashMap Text ChannelId
payload)
  Response_String
_ <- Session -> URI -> HashMap Text ChannelId -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri HashMap Text ChannelId
payload
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmViewChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path Maybe String
forall a. Maybe a
Nothing
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/join@
mmJoinChannel :: Session
              -> TeamId
              -> ChannelId
              -> IO ()
mmJoinChannel :: Session -> TeamId -> ChannelId -> IO ()
mmJoinChannel Session
sess TeamId
teamid ChannelId
chanid = do
  let path :: String
path = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/join"
                   (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                   (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmJoinChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path Maybe String
forall a. Maybe a
Nothing
  Response_String
rsp <- Session -> URI -> Text -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (Text
""::T.Text)
  (Value
val, (Channel
_::Channel)) <- String -> Response_String -> IO (Value, Channel)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Channel" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmJoinChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/leave@
mmLeaveChannel :: Session
               -> TeamId
               -> ChannelId
               -> IO ()
mmLeaveChannel :: Session -> TeamId -> ChannelId -> IO ()
mmLeaveChannel Session
sess TeamId
teamid ChannelId
chanid = do
  let path :: String
path = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/leave"
                   (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                   (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
      payload :: HashMap Text ChannelId
payload = [(Text, ChannelId)] -> HashMap Text ChannelId
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
"id" :: T.Text, ChannelId
chanid)]
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmLeaveChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ HashMap Text ChannelId -> String
forall a. Show a => a -> String
show HashMap Text ChannelId
payload)
  Response_String
rsp <- Session -> URI -> HashMap Text ChannelId -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri HashMap Text ChannelId
payload
  (Value
val, (HashMap Text ChannelId
_::HM.HashMap T.Text ChannelId)) <- String -> Response_String -> IO (Value, HashMap Text ChannelId)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Channel name/ID map" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateDirect" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/page\/{offset}\/{limit}@
mmGetPosts :: Session
           -> TeamId
           -> ChannelId
           -> Int -- offset in the backlog, 0 is most recent
           -> Int -- try to fetch this many
           -> IO Posts
mmGetPosts :: Session -> TeamId -> ChannelId -> Int -> Int -> IO Posts
mmGetPosts Session
sess TeamId
teamid ChannelId
chanid Int
offset Int
limit =
  Session -> String -> String -> IO Posts
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetPosts" (String -> IO Posts) -> String -> IO Posts
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/page/%d/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
         Int
offset
         Int
limit

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/since\/{utc_time}@
mmGetPostsSince :: Session
           -> TeamId
           -> ChannelId
           -> ServerTime
           -> IO Posts
mmGetPostsSince :: Session -> TeamId -> ChannelId -> ServerTime -> IO Posts
mmGetPostsSince Session
sess TeamId
teamid ChannelId
chanid ServerTime
since =
  Session -> String -> String -> IO Posts
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetPostsSince" (String -> IO Posts) -> String -> IO Posts
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Text -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/since/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
         (ServerTime -> Int
timeToServer ServerTime
since)

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/{post_id}\/get@
mmGetPost :: Session
          -> TeamId
          -> ChannelId
          -> PostId
          -> IO Posts
mmGetPost :: Session -> TeamId -> ChannelId -> PostId -> IO Posts
mmGetPost Session
sess TeamId
teamid ChannelId
chanid PostId
postid = do
  let path :: String
path = String -> Text -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/%s/get"
             (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
             (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
             (PostId -> Text
forall x. IsId x => x -> Text
idString PostId
postid)
  URI
uri <- String -> IO URI
mmPath String
path
  Response_String
rsp <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  (Value
raw, Posts
json) <- String -> Response_String -> IO (Value, Posts)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Posts" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmGetPost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
raw)
  Posts -> IO Posts
forall (m :: * -> *) a. Monad m => a -> m a
return Posts
json

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/{post_id}\/after\/{offset}\/{limit}@
mmGetPostsAfter :: Session
                -> TeamId
                -> ChannelId
                -> PostId
                -> Int -- offset in the backlog, 0 is most recent
                -> Int -- try to fetch this many
                -> IO Posts
mmGetPostsAfter :: Session -> TeamId -> ChannelId -> PostId -> Int -> Int -> IO Posts
mmGetPostsAfter Session
sess TeamId
teamid ChannelId
chanid PostId
postid Int
offset Int
limit =
  Session -> String -> String -> IO Posts
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetPosts" (String -> IO Posts) -> String -> IO Posts
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Text -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/%s/after/%d/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
         (PostId -> Text
forall x. IsId x => x -> Text
idString PostId
postid)
         Int
offset
         Int
limit

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/{post_id}\/before\/{offset}\/{limit}@
mmGetPostsBefore :: Session
                -> TeamId
                -> ChannelId
                -> PostId
                -> Int -- offset in the backlog, 0 is most recent
                -> Int -- try to fetch this many
                -> IO Posts
mmGetPostsBefore :: Session -> TeamId -> ChannelId -> PostId -> Int -> Int -> IO Posts
mmGetPostsBefore Session
sess TeamId
teamid ChannelId
chanid PostId
postid Int
offset Int
limit =
  Session -> String -> String -> IO Posts
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetPosts" (String -> IO Posts) -> String -> IO Posts
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Text -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/%s/before/%d/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
         (PostId -> Text
forall x. IsId x => x -> Text
idString PostId
postid)
         Int
offset
         Int
limit

-- |
-- route: @\/api\/v4\/teams\/{team_id}\/posts\/search@
mmSearchPosts :: Session
              -> TeamId
              -> T.Text
              -> Bool
              -> IO Posts
mmSearchPosts :: Session -> TeamId -> Text -> Bool -> IO Posts
mmSearchPosts Session
sess TeamId
teamid Text
terms Bool
isOrSearch = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/teams/%s/posts/search" (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid
  URI
uri <- String -> IO URI
mmPath String
path
  let req :: SearchPosts
req = Text -> Bool -> SearchPosts
SearchPosts Text
terms Bool
isOrSearch
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmSearchPosts" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ SearchPosts -> String
forall a. Show a => a -> String
show SearchPosts
req)
  Response_String
rsp <- Session -> URI -> SearchPosts -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri SearchPosts
req
  (Value
raw, Posts
value) <- String -> Response_String -> IO (Value, Posts)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"SearchPostsResult" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmSearchPosts" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
raw)
  Posts -> IO Posts
forall (m :: * -> *) a. Monad m => a -> m a
return Posts
value

-- |
-- route: @\/api\/v3\/files\/{file_id}\/get_info@
mmGetFileInfo :: Session
              -> FileId
              -> IO FileInfo
mmGetFileInfo :: Session -> FileId -> IO FileInfo
mmGetFileInfo Session
sess FileId
fileId =
  Session -> String -> String -> IO FileInfo
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetFileInfo" (String -> IO FileInfo) -> String -> IO FileInfo
forall a b. (a -> b) -> a -> b
$
  String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/files/%s/get_info" (FileId -> Text
forall x. IsId x => x -> Text
idString FileId
fileId)

-- |
-- route: @\/api\/v4\/files\/{file_id}@
mmGetFile :: Session
          -> FileId
          -> IO B.ByteString
mmGetFile :: Session -> FileId -> IO ByteString
mmGetFile sess :: Session
sess@(Session ConnectionData
cd Token
_) FileId
fileId = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/files/%s" (FileId -> Text
forall x. IsId x => x -> Text
idString FileId
fileId)
  URI
uri  <- String -> IO URI
mmPath String
path
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
"mmGetFile" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
GET String
path Maybe String
forall a. Maybe a
Nothing
  Response_String
rsp  <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> ByteString
B.pack (Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp))

-- |
-- route: @\/api\/v3\/users\/{user_id}\/get@
mmGetUser :: Session -> UserId -> IO User
mmGetUser :: Session -> UserId -> IO User
mmGetUser Session
sess UserId
userid = Session -> String -> String -> IO User
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetUser" (String -> IO User) -> String -> IO User
forall a b. (a -> b) -> a -> b
$
  String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/users/%s/get" (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
userid)

-- |
-- route: @\/api\/v3\/users\/{offset}\/{limit}@
mmGetUsers :: Session -> Int -> Int -> IO (HashMap UserId User)
mmGetUsers :: Session -> Int -> Int -> IO (HashMap UserId User)
mmGetUsers Session
sess Int
offset Int
limit =
  Session -> String -> String -> IO (HashMap UserId User)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetUsers" (String -> IO (HashMap UserId User))
-> String -> IO (HashMap UserId User)
forall a b. (a -> b) -> a -> b
$
    String -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/users/%d/%d" Int
offset Int
limit

-- |
-- route: @\/api\/v3\/teams\/members\/{team_id}@
mmGetTeamMembers :: Session -> TeamId -> IO (Seq.Seq TeamMember)
mmGetTeamMembers :: Session -> TeamId -> IO (Seq TeamMember)
mmGetTeamMembers Session
sess TeamId
teamid = Session -> String -> String -> IO (Seq TeamMember)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetTeamMembers" (String -> IO (Seq TeamMember)) -> String -> IO (Seq TeamMember)
forall a b. (a -> b) -> a -> b
$
  String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/members/%s" (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/users\/{offset}\/{limit}@
mmGetChannelMembers :: Session
                    -> TeamId
                    -> ChannelId
                    -> Int
                    -> Int
                    -> IO (HashMap UserId User)
mmGetChannelMembers :: Session
-> TeamId -> ChannelId -> Int -> Int -> IO (HashMap UserId User)
mmGetChannelMembers Session
sess TeamId
teamid ChannelId
chanid Int
offset Int
limit = Session -> String -> String -> IO (HashMap UserId User)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetChannelMembers" (String -> IO (HashMap UserId User))
-> String -> IO (HashMap UserId User)
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/users/%d/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
         Int
offset
         Int
limit

-- |
-- route: @\/api\/v3\/users\/profiles_for_dm_list\/{team_id}@
mmGetProfilesForDMList :: Session -> TeamId
                       -> IO (HashMap UserId User)
mmGetProfilesForDMList :: Session -> TeamId -> IO (HashMap UserId User)
mmGetProfilesForDMList Session
sess TeamId
teamid =
  Session -> String -> String -> IO (HashMap UserId User)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetProfilesForDMList" (String -> IO (HashMap UserId User))
-> String -> IO (HashMap UserId User)
forall a b. (a -> b) -> a -> b
$
    String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/users/profiles_for_dm_list/%s" (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)

-- |
-- route: @\/api\/v3\/users\/me@
mmGetMe :: Session -> IO User
mmGetMe :: Session -> IO User
mmGetMe Session
sess = Session -> String -> String -> IO User
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetMe" String
"/api/v3/users/me"

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/users\/{offset}\/{limit}@
mmGetProfiles :: Session
              -> TeamId
              -> Int
              -> Int
              -> IO (HashMap UserId User)
mmGetProfiles :: Session -> TeamId -> Int -> Int -> IO (HashMap UserId User)
mmGetProfiles Session
sess TeamId
teamid Int
offset Int
limit = Session -> String -> String -> IO (HashMap UserId User)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetProfiles" (String -> IO (HashMap UserId User))
-> String -> IO (HashMap UserId User)
forall a b. (a -> b) -> a -> b
$
  String -> Text -> Int -> Int -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/users/%d/%d"
         (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
         Int
offset
         Int
limit

-- |
-- route: @\/api\/v3\/users\/status@
mmGetStatuses :: Session -> IO (HashMap UserId T.Text)
mmGetStatuses :: Session -> IO (HashMap UserId Text)
mmGetStatuses Session
sess = Session -> String -> String -> IO (HashMap UserId Text)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetStatuses" (String -> IO (HashMap UserId Text))
-> String -> IO (HashMap UserId Text)
forall a b. (a -> b) -> a -> b
$
  String -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/users/status"

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/create_direct@
mmCreateDirect :: Session -> TeamId -> UserId -> IO Channel
mmCreateDirect :: Session -> TeamId -> UserId -> IO Channel
mmCreateDirect Session
sess TeamId
teamid UserId
userid = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/create_direct" (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
      payload :: HashMap Text UserId
payload = [(Text, UserId)] -> HashMap Text UserId
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
"user_id" :: T.Text, UserId
userid)]
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateDirect" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ HashMap Text UserId -> String
forall a. Show a => a -> String
show HashMap Text UserId
payload)
  Response_String
rsp <- Session -> URI -> HashMap Text UserId -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri HashMap Text UserId
payload
  (Value
val, Channel
r) <- String -> Response_String -> IO (Value, Channel)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Channel" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateDirect" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  Channel -> IO Channel
forall (m :: * -> *) a. Monad m => a -> m a
return Channel
r

-- { name, display_name, purpose, header }
-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/create@
mmCreateChannel :: Session -> TeamId -> MinChannel -> IO Channel
mmCreateChannel :: Session -> TeamId -> MinChannel -> IO Channel
mmCreateChannel Session
sess TeamId
teamid MinChannel
payload = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/create" (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ MinChannel -> String
forall a. Show a => a -> String
show MinChannel
payload)
  Response_String
rsp <- Session -> URI -> MinChannel -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri MinChannel
payload
  (Value
val, Channel
r) <- String -> Response_String -> IO (Value, Channel)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Channel" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmCreateChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  Channel -> IO Channel
forall (m :: * -> *) a. Monad m => a -> m a
return Channel
r

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/delete@
mmDeleteChannel :: Session -> TeamId -> ChannelId -> IO ()
mmDeleteChannel :: Session -> TeamId -> ChannelId -> IO ()
mmDeleteChannel Session
sess TeamId
teamid ChannelId
chanid = do
  let path :: String
path = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/delete"
               (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid) (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmDeleteChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path Maybe String
forall a. Maybe a
Nothing
  Response_String
_ <- Session -> URI -> ByteString -> IO Response_String
mmRawPOST Session
sess URI
uri ByteString
""
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmDeleteChannel" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path Maybe String
forall a. Maybe a
Nothing
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/{post_id}\/delete@
mmDeletePost :: Session
             -> TeamId
             -> ChannelId
             -> PostId
             -> IO ()
mmDeletePost :: Session -> TeamId -> ChannelId -> PostId -> IO ()
mmDeletePost Session
sess TeamId
teamid ChannelId
chanid PostId
postid = do
  let path :: String
path   = String -> Text -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/%s/delete"
                      (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
                      (PostId -> Text
forall x. IsId x => x -> Text
idString PostId
postid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmDeletePost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path Maybe String
forall a. Maybe a
Nothing
  Response_String
rsp <- Session -> URI -> [String] -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri ([]::[String])
  (Value
_, Value
_::Value) <- String -> Response_String -> IO (Value, Value)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Post" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmDeletePost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path Maybe String
forall a. Maybe a
Nothing
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/update@
mmUpdatePost :: Session
             -> TeamId
             -> Post
             -> IO Post
mmUpdatePost :: Session -> TeamId -> Post -> IO Post
mmUpdatePost Session
sess TeamId
teamid Post
post = do
  let chanid :: ChannelId
chanid = Post -> ChannelId
postChannelId Post
post
      path :: String
path   = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/update"
                      (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmUpdatePost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (Post -> String
forall a. Show a => a -> String
show Post
post))
  Response_String
rsp <- Session -> URI -> Post -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Post
post
  (Value
val, Post
r) <- String -> Response_String -> IO (Value, Post)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Post" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmUpdatePost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  Post -> IO Post
forall (m :: * -> *) a. Monad m => a -> m a
return Post
r

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/create@
mmPost :: Session
       -> TeamId
       -> PendingPost
       -> IO Post
mmPost :: Session -> TeamId -> PendingPost -> IO Post
mmPost Session
sess TeamId
teamid PendingPost
post = do
  let chanid :: ChannelId
chanid = PendingPost -> ChannelId
pendingPostChannelId PendingPost
post
      path :: String
path   = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/create"
                      (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmPost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ PendingPost -> String
forall a. Show a => a -> String
show PendingPost
post)
  Response_String
rsp <- Session -> URI -> PendingPost -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri PendingPost
post
  (Value
val, Post
r) <- String -> Response_String -> IO (Value, Post)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Post" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmPost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  Post -> IO Post
forall (m :: * -> *) a. Monad m => a -> m a
return Post
r

-- | Get the system configuration. Requires administrative permission.
--
-- route: @\/api\/v3\/admin\/config@
mmGetConfig :: Session
            -> IO Value
mmGetConfig :: Session -> IO Value
mmGetConfig Session
sess =
  Session -> String -> String -> IO Value
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetConfig" String
"/api/v3/admin/config"

-- | Get a subset of the server configuration needed by the client. Does not
-- require administrative permission. The format query parameter is currently
-- required with the value of "old".
--
-- route: @\/api\/v4\/config\/client@
mmGetClientConfig :: Session
                  -> IO Value
mmGetClientConfig :: Session -> IO Value
mmGetClientConfig Session
sess =
  Session -> String -> String -> IO Value
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetClientConfig" String
"/api/v4/config/client?format=old"

mmSaveConfig :: Session
             -> Value
             -> IO ()
mmSaveConfig :: Session -> Value -> IO ()
mmSaveConfig Session
sess Value
config = do
  let path :: String
path = String
"/api/v3/admin/save_config"
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmSaveConfig" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
config)
  Response_String
_ <- Session -> URI -> Value -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
config
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmSaveConfig" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path Maybe String
forall a. Maybe a
Nothing
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/add@
mmChannelAddUser :: Session
                 -> TeamId
                 -> ChannelId
                 -> UserId
                 -> IO ChannelData
mmChannelAddUser :: Session -> TeamId -> ChannelId -> UserId -> IO ChannelData
mmChannelAddUser Session
sess TeamId
teamid ChannelId
chanId UserId
uId = do
  let path :: String
path = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/add"
                    (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
                    (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
chanId)
      req :: Value
req = [Pair] -> Value
object [Text
"user_id" Text -> UserId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= UserId
uId]
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmChannelAddUser" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
req)
  Response_String
rsp <- Session -> URI -> Value -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
req
  (Value
val, ChannelData
r) <- String -> Response_String -> IO (Value, ChannelData)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"ChannelData" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmChannelAddUser" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  ChannelData -> IO ChannelData
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelData
r

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/add_user_to_team@
mmTeamAddUser :: Session
              -> TeamId
              -> UserId
              -> IO ()
mmTeamAddUser :: Session -> TeamId -> UserId -> IO ()
mmTeamAddUser Session
sess TeamId
teamid UserId
uId = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/add_user_to_team"
                    (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
      req :: Value
req  = [Pair] -> Value
object [Text
"user_id" Text -> UserId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= UserId
uId]
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmTeamAddUser" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
req)
  Response_String
_ <- Session -> URI -> Value -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
req
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmTeamAddUSer" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path Maybe String
forall a. Maybe a
Nothing
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/commands\/execute@
mmExecute :: Session
          -> TeamId
          -> MinCommand
          -> IO CommandResponse
mmExecute :: Session -> TeamId -> MinCommand -> IO CommandResponse
mmExecute Session
sess TeamId
teamid MinCommand
command = do
  let path :: String
path   = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/commands/execute"
                      (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmExecute" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ MinCommand -> String
forall a. Show a => a -> String
show MinCommand
command)
  Response_String
rsp <- Session -> URI -> MinCommand -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri MinCommand
command
  (Value
val, CommandResponse
r) <- String -> Response_String -> IO (Value, CommandResponse)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Value" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmExecute" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  CommandResponse -> IO CommandResponse
forall (m :: * -> *) a. Monad m => a -> m a
return CommandResponse
r

-- |
-- route: @\/api\/v3\/users\/create@
mmUsersCreate :: ConnectionData
              -> UsersCreate
              -> IO User
mmUsersCreate :: ConnectionData -> UsersCreate -> IO User
mmUsersCreate ConnectionData
cd UsersCreate
usersCreate = do
  let path :: String
path = String
"/api/v3/users/create"
  URI
uri <- String -> IO URI
mmPath String
path
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
"mmUsersCreate" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ UsersCreate -> String
forall a. Show a => a -> String
show UsersCreate
usersCreate)
  Response_String
rsp <- ConnectionData -> URI -> UsersCreate -> IO Response_String
forall t.
ToJSON t =>
ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
uri UsersCreate
usersCreate
  (Value
val, User
r) <- String -> Response_String -> IO (Value, User)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"User" Response_String
rsp
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
"mmUsersCreate" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  User -> IO User
forall (m :: * -> *) a. Monad m => a -> m a
return User
r

-- |
-- route: @\/api\/v3\/users\/create@
mmUsersCreateWithSession :: Session
                         -> UsersCreate
                         -> IO User
mmUsersCreateWithSession :: Session -> UsersCreate -> IO User
mmUsersCreateWithSession Session
sess UsersCreate
usersCreate = do
  let path :: String
path = String
"/api/v3/users/create"
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmUsersCreateWithToken" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ UsersCreate -> String
forall a. Show a => a -> String
show UsersCreate
usersCreate)
  Response_String
rsp <- Session -> URI -> UsersCreate -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri UsersCreate
usersCreate
  (Value
val, User
r) <- String -> Response_String -> IO (Value, User)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"User" Response_String
rsp
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmUsersCreateWithToken" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
val)
  User -> IO User
forall (m :: * -> *) a. Monad m => a -> m a
return User
r

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/{channel_id}\/posts\/{post_id}\/reactions@
mmGetReactionsForPost :: Session
                      -> TeamId
                      -> ChannelId
                      -> PostId
                      -> IO [Reaction]
mmGetReactionsForPost :: Session -> TeamId -> ChannelId -> PostId -> IO [Reaction]
mmGetReactionsForPost Session
sess TeamId
tId ChannelId
cId PostId
pId = do
  let path :: String
path = String -> Text -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/%s/posts/%s/reactions"
                    (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
tId)
                    (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
cId)
                    (PostId -> Text
forall x. IsId x => x -> Text
idString PostId
pId)
  Session -> String -> String -> IO [Reaction]
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetReactionsForPost" String
path

mmSetPreferences :: Session
                 -> UserId
                 -> Seq.Seq Preference
                 -> IO ()
mmSetPreferences :: Session -> UserId -> Seq Preference -> IO ()
mmSetPreferences Session
sess UserId
uId Seq Preference
prefs = do
  URI
uri <- String -> IO URI
mmPath (String -> IO URI) -> String -> IO URI
forall a b. (a -> b) -> a -> b
$ String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/users/%s/preferences" (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
uId)
  Response_String
_ <- Session -> URI -> Seq Preference -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPUT Session
sess URI
uri Seq Preference
prefs
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/preferences\/save@
mmSavePreferences :: Session
                  -> Seq.Seq Preference
                  -> IO ()
mmSavePreferences :: Session -> Seq Preference -> IO ()
mmSavePreferences Session
sess Seq Preference
pref = do
  URI
uri <- String -> IO URI
mmPath String
"/api/v3/preferences/save"
  Response_String
_ <- Session -> URI -> Seq Preference -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Seq Preference
pref
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/preferences\/save@
mmDeletePreferences :: Session
                  -> Seq.Seq Preference
                  -> IO ()
mmDeletePreferences :: Session -> Seq Preference -> IO ()
mmDeletePreferences Session
sess Seq Preference
pref = do
  URI
uri <- String -> IO URI
mmPath String
"/api/v3/preferences/delete"
  Response_String
_ <- Session -> URI -> Seq Preference -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Seq Preference
pref
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/preferences\/save@
--
-- This is a convenience function for a particular use of
-- 'mmSavePreference'
mmFlagPost :: Session
           -> UserId
           -> PostId
           -> IO ()
mmFlagPost :: Session -> UserId -> PostId -> IO ()
mmFlagPost Session
sess UserId
uId PostId
pId = do
  let flaggedPost :: FlaggedPost
flaggedPost =
        FlaggedPost :: UserId -> PostId -> Bool -> FlaggedPost
FlaggedPost
          { flaggedPostUserId :: UserId
flaggedPostUserId = UserId
uId
          , flaggedPostId :: PostId
flaggedPostId     = PostId
pId
          , flaggedPostStatus :: Bool
flaggedPostStatus = Bool
True
          }
  let rawPath :: String
rawPath = String
"/api/v3/preferences/save"
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmFlagPost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
rawPath (String -> Maybe String
forall a. a -> Maybe a
Just ([FlaggedPost] -> String
forall a. Show a => a -> String
show [FlaggedPost
flaggedPost]))
  URI
uri <- String -> IO URI
mmPath String
rawPath
  Response_String
_ <- Session -> URI -> Seq FlaggedPost -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (FlaggedPost -> Seq FlaggedPost
forall a. a -> Seq a
Seq.singleton FlaggedPost
flaggedPost)
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- |
-- route: @\/api\/v3\/preferences\/save@
--
-- This is a convenience function for a particular use of
-- 'mmSavePreference'
mmUnflagPost :: Session
             -> UserId
             -> PostId
             -> IO ()
mmUnflagPost :: Session -> UserId -> PostId -> IO ()
mmUnflagPost Session
sess UserId
uId PostId
pId = do
  let flaggedPost :: FlaggedPost
flaggedPost =
        FlaggedPost :: UserId -> PostId -> Bool -> FlaggedPost
FlaggedPost
          { flaggedPostUserId :: UserId
flaggedPostUserId = UserId
uId
          , flaggedPostId :: PostId
flaggedPostId     = PostId
pId
          , flaggedPostStatus :: Bool
flaggedPostStatus = Bool
True
          }
  let rawPath :: String
rawPath = String
"/api/v3/preferences/delete"
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmUnflagPost" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
rawPath (String -> Maybe String
forall a. a -> Maybe a
Just ([FlaggedPost] -> String
forall a. Show a => a -> String
show [FlaggedPost
flaggedPost]))
  URI
uri <- String -> IO URI
mmPath String
rawPath
  Response_String
_ <- Session -> URI -> Seq FlaggedPost -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (FlaggedPost -> Seq FlaggedPost
forall a. a -> Seq a
Seq.singleton FlaggedPost
flaggedPost)
  () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

mmGetFlaggedPosts :: Session
                  -> UserId
                  -> IO Posts
mmGetFlaggedPosts :: Session -> UserId -> IO Posts
mmGetFlaggedPosts Session
sess UserId
uId =
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/users/%s/posts/flagged" (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
uId)
  in Session -> String -> String -> IO Posts
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmGetFlaggedPosts" String
path

mmGetMyPreferences :: Session
                -> IO (Seq.Seq Preference)
mmGetMyPreferences :: Session -> IO (Seq Preference)
mmGetMyPreferences Session
sess =
  Session -> String -> String -> IO (Seq Preference)
forall t. FromJSON t => Session -> String -> String -> IO t
mmDoRequest Session
sess String
"mmMyPreferences" String
"/api/v4/users/me/preferences"

-- | Remove the specified user from the specified channel.
mmChannelRemoveUser :: Session
                    -> ChannelId
                    -> UserId
                    -> IO ()
mmChannelRemoveUser :: Session -> ChannelId -> UserId -> IO ()
mmChannelRemoveUser Session
sess ChannelId
cId UserId
uId =
  let path :: String
path = String -> Text -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v4/channels/%s/members/%s" (ChannelId -> Text
forall x. IsId x => x -> Text
idString ChannelId
cId) (UserId -> Text
forall x. IsId x => x -> Text
idString UserId
uId)
  in Session -> URI -> IO ()
mmDeleteRequest Session
sess (URI -> IO ()) -> IO URI -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> IO URI
mmPath String
path

-- | Create a group channel containing the specified users in addition
-- to the user making the request.
mmCreateGroupChannel :: Session
                     -> [UserId]
                     -> IO Channel
mmCreateGroupChannel :: Session -> [UserId] -> IO Channel
mmCreateGroupChannel sess :: Session
sess@(Session ConnectionData
cd Token
_) [UserId]
uIds = do
  let path :: String
path = String
"/api/v4/channels/group"
      fnname :: String
fnname = String
"mmCreateGroupChannel"
  URI
uri <- String -> IO URI
mmPath String
path
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
fnname (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ [UserId] -> String
forall a. Show a => a -> String
show [UserId]
uIds)
  Response_String
rsp <- Session -> URI -> [UserId] -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri [UserId]
uIds
  (Value
raw, Channel
json) <- String -> Response_String -> IO (Value, Channel)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
fnname Response_String
rsp
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
fnname (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
raw)
  Channel -> IO Channel
forall (m :: * -> *) a. Monad m => a -> m a
return Channel
json

mmDeleteRequest :: Session -> URI -> IO ()
mmDeleteRequest :: Session -> URI -> IO ()
mmDeleteRequest (Session ConnectionData
cd Token
token) URI
path = do
  Result Response_String
rawRsp <- ConnectionData
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd ((MMConn -> IO (Result Response_String))
 -> IO (Result Response_String))
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let request :: Request String
request = Request :: forall a. URI -> RequestMethod -> [Header] -> a -> Request a
Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
DELETE
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> String -> Header
mkHeader HeaderName
HdrAuthorization (String
"Bearer " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Token -> String
getTokenString Token
token)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrHost          (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrUserAgent     String
defaultUserAgent
                        ] [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: String
rqBody    = String
""
          }
    MMConn -> Request String -> IO (Result Response_String)
forall s.
Stream s =>
s -> Request String -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request String
request
  Response_String
rsp <- Either ConnectionException Response_String -> IO Response_String
forall e r. Exception e => Either e r -> IO r
hoistE (Either ConnectionException Response_String -> IO Response_String)
-> Either ConnectionException Response_String -> IO Response_String
forall a b. (a -> b) -> a -> b
$ (ConnError -> ConnectionException)
-> Result Response_String
-> Either ConnectionException Response_String
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left ConnError -> ConnectionException
ConnectionException Result Response_String
rawRsp
  URI -> Response_String -> IO ()
assert200Response URI
path Response_String
rsp

-- | This is for making a generic authenticated request.
mmRequest :: Session -> URI -> IO Response_String
mmRequest :: Session -> URI -> IO Response_String
mmRequest (Session ConnectionData
cd Token
token) URI
path = do
  Result Response_String
rawRsp <- ConnectionData
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd ((MMConn -> IO (Result Response_String))
 -> IO (Result Response_String))
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let request :: Request String
request = Request :: forall a. URI -> RequestMethod -> [Header] -> a -> Request a
Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
GET
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> String -> Header
mkHeader HeaderName
HdrAuthorization (String
"Bearer " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Token -> String
getTokenString Token
token)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrHost          (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrUserAgent     String
defaultUserAgent
                        ] [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: String
rqBody    = String
""
          }
    MMConn -> Request String -> IO (Result Response_String)
forall s.
Stream s =>
s -> Request String -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request String
request
  Response_String
rsp <- Either ConnectionException Response_String -> IO Response_String
forall e r. Exception e => Either e r -> IO r
hoistE (Either ConnectionException Response_String -> IO Response_String)
-> Either ConnectionException Response_String -> IO Response_String
forall a b. (a -> b) -> a -> b
$ (ConnError -> ConnectionException)
-> Result Response_String
-> Either ConnectionException Response_String
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left ConnError -> ConnectionException
ConnectionException Result Response_String
rawRsp
  URI -> Response_String -> IO ()
assert200Response URI
path Response_String
rsp
  Response_String -> IO Response_String
forall (m :: * -> *) a. Monad m => a -> m a
return Response_String
rsp

-- This captures the most common pattern when making requests.
mmDoRequest :: FromJSON t
            => Session
            -> String
            -> String
            -> IO t
mmDoRequest :: Session -> String -> String -> IO t
mmDoRequest Session
sess String
fnname String
path = Session -> String -> String -> (t -> IO t) -> IO t
forall t a.
FromJSON t =>
Session -> String -> String -> (t -> IO a) -> IO a
mmWithRequest Session
sess String
fnname String
path t -> IO t
forall (m :: * -> *) a. Monad m => a -> m a
return

-- The slightly more general variant
mmWithRequest :: FromJSON t
              => Session
              -> String
              -> String
              -> (t -> IO a)
              -> IO a
mmWithRequest :: Session -> String -> String -> (t -> IO a) -> IO a
mmWithRequest sess :: Session
sess@(Session ConnectionData
cd Token
_) String
fnname String
path t -> IO a
action = do
  URI
uri  <- String -> IO URI
mmPath String
path
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
fnname (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
GET String
path Maybe String
forall a. Maybe a
Nothing
  Response_String
rsp  <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  (Value
raw,t
json) <- String -> Response_String -> IO (Value, t)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
fnname Response_String
rsp
  ConnectionData -> String -> LogEventType -> IO ()
runLogger ConnectionData
cd String
fnname (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    Int -> String -> Maybe String -> LogEventType
HttpResponse Int
200 String
path (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Value -> String
forall a. Show a => a -> String
show Value
raw)
  t -> IO a
action t
json

mmPOST :: ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST :: Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
path t
json =
  Session -> URI -> ByteString -> IO Response_String
mmRawPOST Session
sess URI
path (ByteString -> ByteString
BL.toStrict (t -> ByteString
forall a. ToJSON a => a -> ByteString
encode t
json))

mmPUT :: ToJSON t => Session -> URI -> t -> IO Response_String
mmPUT :: Session -> URI -> t -> IO Response_String
mmPUT Session
sess URI
path t
json =
  Session -> URI -> ByteString -> IO Response_String
mmRawPUT Session
sess URI
path (ByteString -> ByteString
BL.toStrict (t -> ByteString
forall a. ToJSON a => a -> ByteString
encode t
json))

-- |
-- route: @\/api\/v3\/teams\/{team_id}\/channels\/update_header@
mmSetChannelHeader :: Session -> TeamId -> ChannelId -> T.Text -> IO Channel
mmSetChannelHeader :: Session -> TeamId -> ChannelId -> Text -> IO Channel
mmSetChannelHeader Session
sess TeamId
teamid ChannelId
chanid Text
header = do
  let path :: String
path = String -> Text -> String
forall r. PrintfType r => String -> r
printf String
"/api/v3/teams/%s/channels/update_header"
                    (TeamId -> Text
forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- String -> IO URI
mmPath String
path
  let req :: SetChannelHeader
req = ChannelId -> Text -> SetChannelHeader
SetChannelHeader ChannelId
chanid Text
header
  Session -> String -> LogEventType -> IO ()
runLoggerS Session
sess String
"mmSetChannelHeader" (LogEventType -> IO ()) -> LogEventType -> IO ()
forall a b. (a -> b) -> a -> b
$
    RequestMethod -> String -> Maybe String -> LogEventType
HttpRequest RequestMethod
POST String
path (String -> Maybe String
forall a. a -> Maybe a
Just (SetChannelHeader -> String
forall a. Show a => a -> String
show SetChannelHeader
req))
  Response_String
rsp <- Session -> URI -> SetChannelHeader -> IO Response_String
forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri SetChannelHeader
req
  (Value
_, Channel
r) <- String -> Response_String -> IO (Value, Channel)
forall t. FromJSON t => String -> Response_String -> IO (Value, t)
mmGetJSONBody String
"Channel" Response_String
rsp
  Channel -> IO Channel
forall (m :: * -> *) a. Monad m => a -> m a
return Channel
r

mmRawPOST :: Session -> URI -> B.ByteString -> IO Response_String
mmRawPOST :: Session -> URI -> ByteString -> IO Response_String
mmRawPOST (Session ConnectionData
cd Token
token) URI
path ByteString
content = do
  Result Response_String
rawRsp <- ConnectionData
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd ((MMConn -> IO (Result Response_String))
 -> IO (Result Response_String))
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request String
request       = Request :: forall a. URI -> RequestMethod -> [Header] -> a -> Request a
Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
POST
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> String -> Header
mkHeader HeaderName
HdrAuthorization (String
"Bearer " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Token -> String
getTokenString Token
token)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrHost          (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrUserAgent     String
defaultUserAgent
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentType   String
"application/json"
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentLength (Int -> String
forall a. Show a => a -> String
show Int
contentLength)
                        ] [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: String
rqBody    = ByteString -> String
B.unpack ByteString
content
          }
    MMConn -> Request String -> IO (Result Response_String)
forall s.
Stream s =>
s -> Request String -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request String
request
  Response_String
rsp <- Either ConnectionException Response_String -> IO Response_String
forall e r. Exception e => Either e r -> IO r
hoistE (Either ConnectionException Response_String -> IO Response_String)
-> Either ConnectionException Response_String -> IO Response_String
forall a b. (a -> b) -> a -> b
$ (ConnError -> ConnectionException)
-> Result Response_String
-> Either ConnectionException Response_String
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left ConnError -> ConnectionException
ConnectionException Result Response_String
rawRsp
  URI -> Response_String -> IO ()
assert200Response URI
path Response_String
rsp
  Response_String -> IO Response_String
forall (m :: * -> *) a. Monad m => a -> m a
return Response_String
rsp

mmRawPUT :: Session -> URI -> B.ByteString -> IO Response_String
mmRawPUT :: Session -> URI -> ByteString -> IO Response_String
mmRawPUT (Session ConnectionData
cd Token
token) URI
path ByteString
content = do
  Result Response_String
rawRsp <- ConnectionData
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd ((MMConn -> IO (Result Response_String))
 -> IO (Result Response_String))
-> (MMConn -> IO (Result Response_String))
-> IO (Result Response_String)
forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request String
request       = Request :: forall a. URI -> RequestMethod -> [Header] -> a -> Request a
Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
PUT
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> String -> Header
mkHeader HeaderName
HdrAuthorization (String
"Bearer " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Token -> String
getTokenString Token
token)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrHost          (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrUserAgent     String
defaultUserAgent
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentType   String
"application/json"
                        , HeaderName -> String -> Header
mkHeader HeaderName
HdrContentLength (Int -> String
forall a. Show a => a -> String
show Int
contentLength)
                        ] [Header] -> [Header] -> [Header]
forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: String
rqBody    = ByteString -> String
B.unpack ByteString
content
          }
    MMConn -> Request String -> IO (Result Response_String)
forall s.
Stream s =>
s -> Request String -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request String
request
  Response_String
rsp <- Either ConnectionException Response_String -> IO Response_String
forall e r. Exception e => Either e r -> IO r
hoistE (Either ConnectionException Response_String -> IO Response_String)
-> Either ConnectionException Response_String -> IO Response_String
forall a b. (a -> b) -> a -> b
$ (ConnError -> ConnectionException)
-> Result Response_String
-> Either ConnectionException Response_String
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left ConnError -> ConnectionException
ConnectionException Result Response_String
rawRsp
  URI -> Response_String -> IO ()
assert200Response URI
path Response_String
rsp
  Response_String -> IO Response_String
forall (m :: * -> *) a. Monad m => a -> m a
return Response_String
rsp

assert200Response :: URI -> Response_String -> IO ()
assert200Response :: URI -> Response_String -> IO ()
assert200Response URI
path Response_String
rsp =
    let is20x :: (a, a, c) -> Bool
is20x (a
2, a
0, c
_) = Bool
True
        is20x (a, a, c)
_ = Bool
False
    in Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ ResponseCode -> Bool
forall a a c. (Eq a, Eq a, Num a, Num a) => (a, a, c) -> Bool
is20x (ResponseCode -> Bool) -> ResponseCode -> Bool
forall a b. (a -> b) -> a -> b
$ Response_String -> ResponseCode
forall a. Response a -> ResponseCode
rspCode Response_String
rsp) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        let httpExc :: HTTPResponseException
httpExc = String -> HTTPResponseException
HTTPResponseException (String -> HTTPResponseException)
-> String -> HTTPResponseException
forall a b. (a -> b) -> a -> b
$ String
"mmRequest: expected 200 response, got " String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
                                              (ResponseCode -> String
forall a. Show a => a -> String
show (ResponseCode -> String) -> ResponseCode -> String
forall a b. (a -> b) -> a -> b
$ Response_String -> ResponseCode
forall a. Response a -> ResponseCode
rspCode Response_String
rsp)
        in case ByteString -> Either String Value
forall a. FromJSON a => ByteString -> Either String a
eitherDecode (ByteString -> Either String Value)
-> ByteString -> Either String Value
forall a b. (a -> b) -> a -> b
$ String -> ByteString
BL.pack (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ Response_String -> String
forall a. Response a -> a
rspBody Response_String
rsp of
            Right (Object Object
o) ->
                case Text -> Object -> Maybe Value
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
"message" Object
o of
                    Just (String Text
msg) ->
                        let newMsg :: Text
newMsg = (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"Error requesting " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> URI -> String
forall a. Show a => a -> String
show URI
path String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
": ") Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
msg
                        in MattermostServerError -> IO ()
forall e a. Exception e => e -> IO a
throwIO (MattermostServerError -> IO ()) -> MattermostServerError -> IO ()
forall a b. (a -> b) -> a -> b
$ Text -> MattermostServerError
MattermostServerError Text
newMsg
                    Maybe Value
_ -> HTTPResponseException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (HTTPResponseException -> IO ()) -> HTTPResponseException -> IO ()
forall a b. (a -> b) -> a -> b
$ HTTPResponseException
httpExc
            Either String Value
_ -> HTTPResponseException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (HTTPResponseException -> IO ()) -> HTTPResponseException -> IO ()
forall a b. (a -> b) -> a -> b
$ HTTPResponseException
httpExc

mmCloseSession :: Session -> IO ()
mmCloseSession :: Session -> IO ()
mmCloseSession (Session ConnectionData
cd Token
_) = ConnectionData -> IO ()
destroyConnectionData ConnectionData
cd